Maturity is evidence, not elapsed time.
AletheiaGraph treats maturity as the durable accumulation of evidence about what the engine can and cannot be trusted to do. Calendar age and installed base matter because they create unpredictable field exposure, but they are proxies for experience—not the definition of maturity itself.
Why this page exists
Software has traditionally acquired much of its confidence through elapsed production time. A broad installed base supplies accidental chaos experiments: unusual workloads, timing combinations, hardware failures, operator mistakes and interactions its designers did not anticipate. That evidence is real. But field age is only one way a system accumulates experience. A modern qualification program can deliberately manufacture many classes of adversity, preserve every discovered failure as an executable regression, and rerun that accumulated experience against every subsequent change.
Field exposure
Production diversity reveals unknown interactions that no finite laboratory program can guarantee it has anticipated.
Qualification depth
Defined invariants are attacked through deterministic failure injection, concurrency, recovery, scaling, semantic equivalence and boundary cases.
Failure memory
A discovered defect becomes a reproducible test and permanent regression gate, so the system does not have to relearn the same lesson through institutional memory.
The relevant maturity question is therefore not simply “How old is the software?” It is “What has the software been required to prove, under what conditions, and what evidence is retained?”
The development testbed
AletheiaGraph's current hardening work is being performed on the FreeBSD family, presently using GhostBSD for development convenience, with SBCL as the Common Lisp runtime. Qualification runners are designed to make test setup explicit and repeatable. Exact hardware, filesystem and revision metadata should accompany published benchmark results rather than being hidden behind generalized performance claims.
Current qualification snapshot
The testbed is broader than a unit-test counter. We publish the smallest defensible numbers we can reconstruct from surviving qualification output, and keep larger durability, scaling, recovery and multi-backend runs separate rather than pretending every run is equivalent to one assertion.
From the ordered-index baseline alone, before later qualification stages.
Named durability, index, planner, reasoning and integrated qualification runs.
Skip List and B+ tree paths are both exercised.
B+ tree scaling work extends beyond toy graphs and micro-fixtures.
Qualification ledger by wall
| Area | What was exercised | Count we can safely publish | Status |
|---|---|---|---|
| Authoritative write-path, concurrency & recovery — Wall A | Transaction correctness, WAL durability, deterministic crash/killpoint recovery, shared-node concurrency, OCC conflict semantics, write intent/reservation, publication ordering, checkpoint correctness, multi-key overlap, dirty-read prevention, after-apply hooks and recovery conflict semantics. | 21 canonical qualification stages: 20 subordinate runners + 1 current-semantics multi-key overlap gate. Includes a 16,000-transaction shared-node lost-update workload and 200 multi-key transactions / 400 node updates. | Qualification complete |
| Indexing, access paths & index integrity — Wall B | Ordered and single-field indexes, exact/range lookup, ASC/DESC traversal, LIMIT, keyset pagination, composite and directional composite indexes, statistics, verify/repair, reopen/recovery integrity, transactional maintenance, tombstones, lifecycle/GC, cold/warm reverse lookup, traversal indexes, backend parity and scaling. | 370 enumerated ordered-index baseline tests + approximately 13 additional named qualification stages. | Qualification complete |
| Native query, planning & execution — Wall C | Graph-native query IR/algebra, explicit scan and index access paths, statistics and cost estimation, plan selection, missing/unbound-field semantics, ordered execution, pagination, projection, composite indexes, joins, aggregation, EXPLAIN/plan introspection, execution integration and fallback behavior. | Exact individual case count not yet reconstructed; approximately 16 named qualification stages across 3A–3H plus P10/P11/P12 closure. | Qualification complete |
| Reasoning Engine Safety & Correctness — Wall D | Core semantics, recursion, functors, graph predicates, mutation, concurrency, repeated-query isolation, inference budgets, cycle protection, timeouts and spatial reasoning. | 4 explicitly identified hardening cases + 6 major suite groups. | Qualification complete |
| Reasoning Durability & Recovery — Wall E | Committed-fact visibility, reopen consistency, durable retract, denied-write behavior, deterministic re-query and inference limits after reopen. | 8 integrated qualification checks. | Qualification complete |
| Epistemic Classification — Wall F1 | :stored, :inferred and :proposed semantics, multi-graph schema, graph-local persistence, validation, transaction provenance and reopen durability. | 6 multi-graph qualification checks. | Qualification complete |
| Proof Topology & Evidence Provenance — Wall F2 | Vertex evidence, edge evidence, multi-support conclusions, reusable support records, source ID + commit-epoch, graph isolation, reopen durability and authority preservation. | 10 qualification gates. | Qualification complete |
| Evidence Validity & Invalidation — Wall F3 | Classifies cited evidence as :current, :stale, :retracted or :missing; preserves immutable historical citations; keeps validity support-local, read-only, graph-isolated and reopen-durable. | 10 qualification gates. | Qualification complete |
| Authority Transition / Promotion — Wall F4 | Inferred/proposed claims remain non-authoritative until explicit governed promotion; current evidence is required; promotion is durable and preserves epistemic state, claim version and historical proof. | 12 qualification gates. | Qualification complete |
| Advanced Epistemic / Truth / Decision Qualification — Wall F5 through F6H | Durable proof recovery; truthiness, confidence and provenance semantics; canonical logical graph state; SHA-256 state hashing; physical-layout and recovery reproducibility; same-pin epistemic binding; pinned provenance reconstruction; and durable Decision Records. | Qualification has progressed through F6H-D; the durable Decision Record line closed with 12/12 qualification gates passing. | Qualification complete through F6H-D |
| Chandra governed CU workload | Real Chandra append, lookup, spoke-tail, chain traversal, chain verification, reopen and contention paths executed against AletheiaGraph rather than synthetic CRUD alone. | Each canonical sweep executes 1,200 governed CU commits: 240 commits at each of 1, 2, 4, 8 and 16 writers. A sweep exercises approximately 21,600 persistent secondary-index insertions and 8,400 removals, with exact authoritative-chain verification and persistent-backend correctness checked at every concurrency point. | Baseline qualified / hardening |
| Durable commit-path optimization | Optimize and requalify the Aletheia durable commit/publication path under governed Chandra workloads without weakening ordering, durability, recovery or attribution semantics. | 1T qualified. Delta-aware secondary-index maintenance skips physical mutation when an update preserves the same canonical indexed key. The canonical 1T semantic closure completed 449/449 checks across memory, skip-list and B+ tree backends, update transitions, canonical-equivalent keys, delete, reopen and authoritative verification. In the governed CU benchmark, P16 secondary-index time fell from 845.8 μs to 516.7 μs, total Apply fell 24.8%, total commit fell 13.9%, and throughput increased 13.0% versus the preceding 1S baseline, without weakening durable ordering or recovery semantics. | Qualification complete — 1T |
| Cross-stack memory / GC / lifecycle | Sustained allocation behavior, retained heap, repeated full GC, close/reopen cycles, resource release and long-running workload stability across query, reasoning and governed writes. | Qualified. The integrated lifecycle gate completed 160/160 checks over 12 repeated mutation/query/reasoning/reopen cycles. Authoritative reads, maintained indexes, native query and Prolog remained in agreement before and after reopen; read-only Prolog policy continued to deny mutation; alternating snapshot/non-snapshot closes passed; and post-GC live heap remained essentially flat at approximately 122 MiB. | Qualification complete |
| Sustained mixed-workload qualification | Repeated committed mutation, indexed native query, direct index verification, Prolog reasoning, policy enforcement, close/reopen activity and full-GC lifecycle checks in one sustained workload rather than isolated component tests. | Qualified. The 16-cycle / 512-background-row mixed workload completed 245/245 checks. Every pre- and post-reopen native equality query used a scan-verified :INDEX path, direct index lookup matched authoritative state, Prolog agreed with the same truth set, secondary indexes verified clean, denied writes remained denied, alternating reopen modes passed and retained heap stayed bounded at approximately 121–122.5 MiB. | Qualification complete |
| Native scalar-query planner integration | Ensure a one-predicate native :QUERY reaches the qualified scalar planner instead of being misrouted through composite-only planning, while preserving authoritative scan verification and fallback behavior. | Qualification exposed a production integration defect: semantically correct native queries were silently falling back to :SCAN with :NO-ELIGIBLE-COMPOSITE-INDEX even though a valid single-field index existed. Dispatch was corrected so one predicate uses the qualified scalar planner and two-or-more predicates retain the conjunctive/composite planner. Focused qualification passed 5/5, including indexed execution after reopen and safe scan fallback for an unindexed predicate. | Qualification complete |
| Production Prolog / reasoning integration | Production integration of the qualified reasoning substrate with graph-backed predicates, recursion/cycle controls, inference budgets, deadlines, provenance and reopen-safe behavior. | Reasoning safety, durability and cross-stack lifecycle behavior are already qualified. The next v1 frontier is production integration: turning the qualified reasoning substrate into the production execution path without losing bounded execution, provenance, policy enforcement or reopen determinism. | Current v1 frontier |
| Decision Record → Chandra evidence binding | Bind Aletheia durable Decision Records into Chandra CU evidence so evaluated state, provenance and disposition become part of the governed evidentiary path without making Aletheia the owner of CU semantics. | Aletheia Decision Records are qualified; Chandra evidence binding remains an integration step. | Required before freeze |
| Form-defined composite index optimization | Composite indexes created from user-designed Form Designer fields must support left-prefix reuse, correct key-order semantics, composite-prefix statistics, redundant-index detection, reusable native query IR templates, authoritative-scan-equivalent fallback, reopen/rebuild integrity and characterized write/storage amplification. | Composite index and planner substrate exists; this gate qualifies the application-facing optimization path without making automatic index recommendation/tuning a v1 requirement. | Required before freeze |
| SPARQL compatibility subset | Restricted SPARQL lowering into the native query IR. | Implementation remains a compatibility-layer task rather than a prerequisite for the native planner. | Planned for v1 |
| End-to-end Chandra / Aletheia qualification | Integrated governed-write, query, reasoning, provenance, Decision Record, reopen/recovery and authority-boundary qualification across the combined stack. | Individual substrate and workload gates are passing; the final integrated qualification run remains. | Required before freeze |
| Networked query / Marshaller boundary | Federated query routing, pushdown, partial-result handling, source attribution and CRC-preserving combination across independently governed graph instances. | Architecture is defined sufficiently to preserve authority boundaries, but distributed/surface-aware execution is not a v1 freeze requirement. | Post-v1 / later hardening |
| CRC federation reference harness | Run semantically equivalent distributed graph workloads against independent reference engines (RDF4J FedX, Apache Jena ARQ/Fuseki and GraphDB) and later AletheiaGraph/Marshaller; capture source selection, remote requests, boundary exchanges, transferred data, graph work, traversal depth and planned-versus-actual exposure. | This is the external validation path for CRC reachability/federation claims. It is intentionally independent of AletheiaGraph's own implementation so the standard is not validated only against itself. | Planned / post-v1 qualification |
| Full v1 regression / release freeze | Cross-wall regression, Skip List/B+ tree backend parity, governed-workload regression, memory/GC and sustained-performance checks, reasoning integration, reopen/recovery, source provenance and warning baseline. | Final consolidated freeze run has not yet been executed. | Final gate |
Wall A in detail
Wall A is broader than a transaction smoke test. It qualifies the authoritative write and recovery path under contention, interruption and restart. The canonical v6 runner executes 20 subordinate qualification runners and one additional current-semantics multi-key overlap gate, for 21 qualification stages. Four superseded historical runners are explicitly excluded from that count.
| Wall A subdomain | What it covers |
|---|---|
| Atomicity & concurrency | Commit behavior, shared-node contention, lost-update prevention, multi-thread correctness and multi-key overlap. |
| Durability & recovery | WAL persistence, committed-state survival, deterministic killpoints, reopen/recovery and sidecar/checkpoint behavior. |
| Conflict & visibility semantics | OCC conflicts, authoritative last-writer behavior, read-only validation, dirty-read prevention and recovery conflict semantics. |
| Publication & checkpoint correctness | Ordered publication, successor wakeup, waiter behavior, checkpoint durability and highest-transaction markers. |
| Write reservation / intent | Reservation acquisition, synchronous and asynchronous write-intent paths, cancellation and cleanup. |
| Apply-hook & provenance integrity | After-apply behavior, one-time hook consumption and qualification against the intended current source tree. |
Wall B in detail
Wall B qualifies the entire index substrate as a derived acceleration layer over the authoritative graph. The objective is not merely to prove that an index can return values; it is to characterize correctness, ordering, pagination, lifecycle, recovery, memory behavior, planner statistics, traversal support and backend behavior under realistic scale.
Correctness & access paths
Exact/range lookup, ASC/DESC traversal, single-field and composite structures, LIMIT, keyset pagination and agreement with authoritative scans.
Integrity & recovery
Verify/repair, reopen integrity, transactional maintenance, recovery behavior, regeneration from authoritative graph state and tombstone semantics.
Planner substrate & traversal
Cardinality/distinct/selectivity statistics, traversal-oriented and reverse indexes, and the physical information consumed later by Wall C.
Scale, lifecycle & backends
Scaling, build/rebuild cost, write amplification, memory/GC lifecycle, cold/warm behavior and parity across Skip List and B+ tree backends.
Wall B capability coverage
| Wall B capability | What was qualified |
|---|---|
| Ordered index correctness | Exact lookup, range lookup, ascending/descending traversal and ordered retrieval. |
| Index vs scan agreement | Indexed results must match authoritative full-scan semantics rather than becoming a second source of truth. |
| Single-field indexes | Core property/value index construction, maintenance and lookup behavior. |
| Composite indexes | Multi-field index structures and compound lookup semantics. |
| Directional composite indexes | Composite ordering capable of preserving ASC/DESC planning behavior across multiple properties. |
| LIMIT support | Bounded ordered-index execution without unnecessarily consuming the full qualifying result set. |
| Keyset pagination | Stable continuation through ordered index space without offset scanning. |
| Range semantics | Inclusive/exclusive boundaries and bounded range traversal. |
| Statistics generation | Entry counts, distinct counts and selectivity/cardinality summaries. |
| Planner statistics substrate | Index statistics designed for direct consumption by Wall C cost estimation and plan selection. |
| Verify / consistency checking | Detection of divergence between derived index state and the authoritative graph. |
| Repair / regeneration | Reconstruction of indexes from authoritative graph state rather than trusting corrupted derived state. |
| Reopen integrity | Persisted indexes remain semantically correct after close/reopen. |
| Recovery behavior | Index state remains consistent through transaction and recovery lifecycle events. |
| Transactional maintenance | Index changes remain synchronized with committed graph mutations and do not expose partial authoritative state. |
| Soft-delete / tombstone behavior | Deleted graph objects cease appearing through indexes while lifecycle/tombstone metadata remains correct. |
| GC / lifecycle behavior | Index caches, waiter state and reverse-index references do not indefinitely retain closed graphs. |
| Cold vs warm behavior | Reverse/index paths behave correctly after cold reopen as well as with warmed caches. |
| Traversal-oriented indexes | Adjacency/reverse lookup support required for efficient graph traversal. |
| Wrong-graph isolation | Index lookup resolves against the graph explicitly passed to the operation rather than accidentally consulting ambient *graph*. |
| Backend parity | Both Skip List and B+ tree persistence/index paths are exercised. |
| Scaling | Larger cardinalities/selectivities, build/rebuild cost, write amplification, memory cost and query latency. |
Qualification found and removed real defects
Wall B was also an optimization and lifecycle hardening campaign. Qualification exposed defects that would not have been visible in a feature checklist, including an O(n²)-style secondary-index apply path that was reduced to a fast exact-lookup path, graph retention through write-reservation waiter state, and graph retention through reverse-index cache state. The important result is not only broader feature coverage, but improved correctness, recoverability, memory safety and scaling behavior of the index substrate.
Wall C in detail
Wall C qualifies the full native query decision path: from graph-native logical representation, through statistics and physical access-path choice, into real execution. The goal is not merely to make queries faster; it is to prove that optimized execution preserves the semantics of the authoritative graph.
Query semantics & algebra
Graph-native logical representation and operators: filtering, projection, ordering, joins, aggregation, pagination and bounded execution.
Statistics & cost estimation
Cardinality, distinct counts, selectivity, range estimates, index-cost estimates and behavior when statistics are stale, absent or incomplete.
Plan selection & access paths
Choosing among scans, equality/range indexes, ordered access and directional composite indexes without changing query meaning.
Execution correctness & advanced operators
Real executor integration, authoritative-result agreement, joins, aggregation, EXPLAIN and safe fallback behavior.
Wall C capability coverage
| Wall C capability | What was qualified |
|---|---|
| Native query IR / algebra | Internal graph-native representation for filtering, projection, ordering, joins, aggregation, pagination and bounded execution. |
| Explicit access paths | Authoritative graph scan, index equality, range, ordered-index paths and explicit-path execution. |
| Cost estimation | Cardinality/selectivity estimates, range estimates, index-cost estimates and planner confidence in available statistics. |
| Statistics substrate | Distinct counts, cardinality and selectivity summaries, including stale-, absent- and incomplete-statistics behavior. |
| Plan selection | Choosing among scan and indexed alternatives while preserving the logical query's semantics. |
| Authoritative-result equivalence | Planned and indexed results must agree with authoritative scan execution rather than becoming a second source of truth. |
| Missing / unbound fields | Queries remain correct when a field is absent; the planner cannot assume indexed values represent every possible match. |
| Ordered execution | ASC/DESC execution, ordered indexes, LIMIT interaction and directional composite-index behavior. |
| Pagination | LIMIT and keyset-style paging behavior, including use of qualified ordered access paths rather than full rescans where applicable. |
| Projection | Returning selected fields/results without altering filtering, ordering or underlying query semantics. |
| Composite indexes | Multi-field access paths and directional composite planning for queries whose useful physical ordering spans more than one property. |
| Joins | Join execution plus cost-based join planning across the native query substrate. |
| Aggregation | Aggregate execution and aggregate planning as native operators rather than application-side post-processing. |
| EXPLAIN / plan introspection | Selected access paths and physical plans are observable so planner decisions can be qualified and debugged. |
| Execution integration | Selected plans are run through the real executor; qualification is not limited to planner objects or estimated costs. |
| Fallback behavior | Correct execution when statistics are stale/absent, an index is unusable, or no optimized path is appropriate. |
Wall D in detail
Wall D qualifies the reasoning engine itself: whether Prolog and graph-backed reasoning execute correctly, recursively, concurrently and within explicit resource bounds. This is the in-memory/runtime safety wall for reasoning, distinct from Wall E's persistence and recovery guarantees.
Semantics & graph integration
Core Prolog behavior, recursion, structured terms/functors, compiled rule behavior and graph-backed predicates over AletheiaGraph state.
Mutation & concurrency
Reasoning-side mutation/retract behavior, concurrent reasoning operations and isolation of bindings and transient query state.
Resource bounds
Explicit inference budgets, cyclic-recursion protection, spin-loop interruption and wall-clock deadlines.
Failure containment
Runaway or resource-bound reasoning fails gracefully without crashing or contaminating the graph engine.
Wall D capability coverage
| Wall D capability | What was qualified |
|---|---|
| Core Prolog semantics | Basic rule/query behavior and recursive reasoning. |
| Structured terms / functors | Functors, structured term handling and compiled rule behavior. |
| Graph-backed predicates | Reasoning directly over graph vertices and edges rather than a separate logical truth store. |
| Mutation semantics | Prolog-triggered retract and mutation paths. |
| Concurrent reasoning | Multiple reasoning operations execute without cross-query state contamination. |
| Query-state isolation | Repeated and recursive queries do not leak bindings or transient execution state. |
| Inference budgets | Recursive reasoning is bounded by an explicit inference limit. |
| Cycle protection | Cyclic recursion aborts gracefully instead of running forever. |
| Wall-clock timeout | Runaway reasoning can be terminated by deadline. |
| Spatial / graph reasoning integration | Prolog integrates with graph and spatial predicates. |
| Failure containment | Resource-bound failures do not crash the engine or corrupt surrounding reasoning state. |
| Deterministic control behavior | Budget and timeout enforcement behave consistently enough to be tested and relied upon. |
inference-budget-bounds-recursion, cyclic-recursion-fails-gracefully, inference-budget-breaks-spin-loop, and query-timeout-breaks-spin-loop. Larger qualification groups covered D1–D3 core semantics/algorithms, D2 functors, D4 mutation, D5 concurrency, D6–D9 stress/isolation/resource bounds and D10 spatial-Prolog integration.Wall E in detail
Wall E moves the reasoning system across the persistence boundary. It asks whether facts visible to reasoning, reasoning-side retractions, denied writes, deterministic answers and resource controls remain correct after commit, close/reopen and recovery.
| Wall E capability | What was qualified |
|---|---|
| Committed fact visibility | Prolog sees facts only after they are durably committed. |
| Reopen consistency | The same committed facts remain reasoning-visible after close/reopen. |
| Retract durability | A committed Prolog retract remains effective after reopen. |
| Denied-write safety | Rejected reasoning-side writes have no side effect. |
| Denied-write durability | The no-effect guarantee for rejected writes still holds after reopen. |
| Deterministic result recovery | Ordinary Prolog query results remain the same across reopen. |
| Inference-budget persistence | Inference limits still work after the graph is reopened. |
| Timeout persistence | Deadline enforcement still works after reopen. |
What skepticism does the test answer?
A raw count is less useful than the engineering question behind it. These are the failure modes the qualification program is intended to answer directly.
| Enterprise question | Evidence exercised in the testbed |
|---|---|
| Does it survive crashes and restarts? | Wall A v6: 21 canonical stages spanning WAL/recovery, deterministic killpoints, checkpoint durability, OCC conflict semantics, dirty-read prevention, publication ordering and close/reopen verification. |
| Can indexes be trusted instead of scans? | 370-case ordered-index baseline plus verify/repair, reopen integrity and backend qualification. |
| Does it scale beyond toy graphs? | 100k-record B+ tree qualification, scaling-matrix work and memory/GC testing. |
| Can the optimizer change the answer? | Wall C qualification spans native query algebra, statistics and cost estimation, plan selection, joins, ordering, aggregation and execution-level agreement with authoritative graph semantics—including missing/unbound fields and stale-statistics fallback. |
| Can agents reason recursively without taking down the engine? | Inference budgets, cyclic-recursion guards, infinite-loop protection and wall-clock deadlines. |
| Does reasoning survive database lifecycle events? | Wall E durable reasoning and reopen qualification. |
| Can the engine distinguish facts, inferences and proposed actions? | Wall F1 graph-native epistemic typing and persistence qualification. |
| Can a conclusion retain proof of exactly which committed evidence supported it? | Wall F2 qualifies durable proof relationships from conclusions to version-specific vertex or edge evidence using source identity plus commit-epoch, with graph isolation and reopen durability. |
| Are multiple physical backends exercised? | Both Skip List and B+ tree index backends are included in qualification. |
| What remains unfinished? | Wall F has progressed through F6H-D. Remaining v1 work is systems hardening and integration: durable commit-path optimization under governed CU workloads, integrated memory/GC and sustained mixed-workload qualification, Form Designer composite-index optimization, production reasoning integration, Decision Record → Chandra evidence binding, the restricted SPARQL subset, end-to-end Chandra/Aletheia qualification and the final release freeze. |
Wall F in detail
Wall F covers proof, provenance, truth semantics and durable decision evidence. The work did not stop at F4: F5 closed durable proof recovery, and F6 was deliberately decomposed into a longer qualification sequence so confidence, disposition, truthiness, ingestion confidence, divergence and finally pinned decision-state evidence could be qualified separately rather than hidden behind one “truth score.”
F1 — Epistemic classification
F2 — Proof topology & evidence provenance
F3 — Evidence validity & invalidation
F4 — Authority transition / promotion
F5 — Durable proof recovery
F6A — Reference determination
F6B — Actionability reference
F6C — Confidence reference
F6CG1–CG9 — Confidence / provenance extensions
F6D — Disposition
F6E — Truthiness
F6F — Ingestion confidence
F6G — Client divergence
F6H — Epistemically pinned decision-state and durable Decision Records
| Stage | Public label | What it proves | Status |
|---|---|---|---|
| F1 | Epistemic Classification | Durable distinction among :stored, :inferred and :proposed; graph-local system schema; commit provenance; reopen durability. | Qualification complete |
| F2 | Proof Topology & Evidence Provenance | Vertex evidence, edge evidence, multi-support conclusions, reusable support records, source ID + commit-epoch, graph isolation, reopen durability and authority preservation. | Qualification complete — 10 gates |
| F3 | Evidence Validity & Invalidation | Classify cited evidence as :current, :stale, :retracted or :missing; preserve historical proof; keep validity support-local, read-only and graph-local; preserve classifications across reopen. | Qualification complete — 10 gates |
| F4 | Authority Transition / Promotion | Keep inferred/proposed claims non-authoritative until explicit promotion; require current evidence; create durable authority-transition state; preserve epistemic kind, exact claim version and historical proof. | Qualification complete — 12 gates |
| F5 | Durable Proof Recovery | Proof DAGs, support state, invalidation state and authority state remain correct through close/reopen, recovery and deterministic failure boundaries. | Qualification complete |
| F6A | Reference Determination | Establish the reference determination semantics used by the later truth/confidence decision path. | Qualification complete |
| F6B | Actionability Reference | Establish actionability semantics independently from later confidence and disposition decisions. | Qualification complete |
| F6C | Confidence Reference | Establish confidence semantics on the qualified evidence/provenance substrate. | Qualification complete |
| F6CG1–CG9 | Confidence / Provenance Extensions | Extend and qualify confidence behavior across provenance, temporal, evidence-strength, staleness, conflict, domain/density and measured-confidence concerns. | Qualification complete |
| F6D | Disposition | Keep policy/disposition evidence distinct from execution authority and preserve the basis used to classify an outcome. | Qualification complete |
| F6E | Truthiness | Evaluate truthiness on the qualified proof/confidence substrate without creating a parallel authoritative truth store. | Qualification complete |
| F6F | Ingestion Confidence | Preserve ingestion confidence and its contribution to effective confidence as explicit evidence. | Qualification complete |
| F6G | Client Divergence | Preserve client-side divergence/evaluation differences as explicit decision evidence rather than silently collapsing them. | Qualification complete |
| F6H | Pinned Decision-State & Durable Decision Records | Bind evaluation to canonical logical graph state, reconstruct provenance at the same pin and persist durable, replay-resistant Decision Records. | Qualification complete through F6H-D |
F6H qualified sequence
| Stage | Qualified behavior | Status |
|---|---|---|
| F6H-A0 | Snapshot enumeration over the logical graph state. | 12/12 PASS |
| F6H-A0H1 | Generic / type-0 edge coverage. | 4/4 PASS |
| F6H-A0H2 | Hard-purge exclusion from canonical logical state. | 12/12 PASS |
| F6H-A1 | Canonical logical state representation. | 12/12 PASS |
| F6H-A2 | SHA-256 logical graph-state hash. | 12/12 PASS |
| F6H-A3 | Physical/index-layout invariance of the logical state hash. | 12/12 PASS |
| F6H-A4 | Recovery reproducibility of the canonical logical state. | 12/12 PASS |
| F6H-B | Same-pin epistemic binding. | 12/12 PASS |
| F6H-C | Pinned provenance reconstruction. | 12/12 PASS |
| F6H-D | Durable Decision Record preserving evaluated state, evidence, provenance, confidence and disposition across commit/reopen boundaries. | 12/12 PASS |
F3 qualified behaviors
| Gate | Qualified behavior |
|---|---|
| F3.1 | Fresh vertex evidence classifies as :current. |
| F3.2 | Fresh edge evidence classifies as :current. |
| F3.3–F3.4 | Updating cited vertex or edge evidence makes the historical support :stale without rewriting the citation. |
| F3.5 | Deleted cited evidence classifies as :retracted. |
| F3.6 | Unresolvable cited evidence classifies as :missing. |
| F3.7 | Validity remains local to the support being evaluated. |
| F3.8 | Historical evidence citations remain immutable. |
| F3.9 | Validity classifications survive close/reopen. |
| F3.10 | Classification is read-only and graph-local; wrong-graph use is rejected. |
F4 qualified behaviors
| Qualification focus | Qualified behavior |
|---|---|
| Authority by origin | Stored state is authoritative by origin; inferred and proposed state is not. |
| Eligibility vs promotion | Current supporting evidence can establish promotion eligibility without implicitly promoting the conclusion. |
| Explicit promotion | Authority transition requires an explicit governed promotion and creates durable transition state. |
| Epistemic preservation | Promotion preserves the claim's epistemic kind, proposition, exact claim version and historical proof rather than rewriting its history. |
| Invalid evidence rejection | Stale, retracted or missing evidence blocks promotion. |
| Boundary rejection | Unsupported, repeated and wrong-graph promotion attempts are rejected. |
| Reopen durability | Authority-transition state remains correct after close/reopen. |
| Proof preservation | Promotion does not mutate the underlying proof relationship. |
Epistemic state
Stored, inferred and proposed objects remain distinct and durable.
Evidence & proof topology
Conclusions retain explicit, reusable and version-specific support relationships.
Validity & authority
Evidence can become stale without erasing history, and conclusions cannot silently promote themselves into authoritative state.
Truth scoring & contradiction
Competing evidence is interpreted only after proof and provenance semantics are established.
Operational-path hardening
Agent-first qualification is not only about database features in isolation. Autonomous clients repeatedly stress authoritative writes, repeated reasoning, concurrent mutation, recovery and long-lived memory behavior. AletheiaGraph therefore hardens the operational paths those clients actually drive.
Governed mutations & CU append
Ordinary graph create/update/delete behavior remains transactional, while Chandra CUs follow append-only governed publication semantics with spoke-tail advancement, lineage verification, publication ordering and durable recovery.
Chandra CU workload optimization
Canonical sweeps exercise 1,200 governed commits across five contention levels. Remove-path qualification reduced persistent skip-list traversal from three searches per removal to one; insertion-path hardening now focuses on measured persistent pointer-mutation cost while preserving ordered visibility, durability, lineage, attribution and recovery semantics.
Memory / GC behavior — qualified
The integrated 12-cycle lifecycle gate held authoritative/index/native-query/Prolog agreement across repeated reopen while full-GC live heap remained essentially flat around 122 MiB.
Lean indexed execution
Lean B+ tree descent, partial decode, in-place edits, equality/range/ordered LIMIT and planner reuse of qualified indexes.
Composite index optimization
User-designed forms may define composite indexes and reusable query shapes. v1 qualification covers prefix reuse, key ordering, prefix statistics, overlap detection, safe fallback and reopen/rebuild behavior without allowing form metadata or derived indexes to become authoritative.
Repeated autonomous reasoning
Recursion, graph-backed predicates, concurrency, inference budgets, cycle termination, infinite-loop breaking and timeout enforcement.
Durable re-query
Committed facts, retract durability, denied writes, deterministic results and resource controls after graph reopen.
What we test
| Family | What the qualification is trying to prove | Status |
|---|---|---|
| Durability / killpoints | Interrupted execution cannot silently publish ambiguous authoritative state; reopen recovers to a valid boundary. | Foundation qualification complete / regression |
| Transaction publication | Graph and derived structures cross publication boundaries consistently; partial work does not masquerade as committed work. | Hardening |
| Concurrent writers | Handoff, cancellation, stale state and contention have defined behavior rather than accidental ordering. | Qualified / regression |
| Index lookup / range | Indexed paths return the same graph objects and semantics as authoritative scans. | Qualification complete |
| Wrong-graph isolation | Index operations resolve against the graph argument supplied to the operation rather than leaking through ambient graph state. | Qualification complete |
| Index reopen / rebuild | Persistent indexes survive reopen or can be reconstructed and checked against authoritative graph state. | Qualification complete |
| Statistics edge cases | Empty indexes, zero distinct values, missing or stale statistics do not produce arithmetic failures or semantically invalid plans. | Qualification complete |
| Planner equivalence | Equality, range, ordered, join and aggregate plans agree with authoritative semantics before production selection is trusted. | Qualification complete / hardening |
| Constant-work scaling | Operations intended to be constant-work remain so as graph cardinality grows; write amplification, allocation and GC costs are measured. | Qualified baseline / continuing regression |
| Reasoning durability | Derived conclusions remain deterministic, attributable and recoverable; dependencies and invalidation remain explicit across reopen. | Qualification complete |
| Governed Chandra CU workload | Append, retrieve, traverse, verify, reopen and same-spoke contention exercise the real governed application path through AletheiaGraph. | Baseline qualified / hardening |
| Sustained integrated lifecycle | Mixed writes, queries, reasoning, memory/GC, checkpoint/reopen and long-run resource stability are exercised together. | Current v1 hardening |
A representative index invariant
Performance structures are tested as derived access paths. The engine should be able to prove that an indexed answer agrees with the underlying graph, including boundary cases where fields are missing or statistics are absent.
Failure is part of the workload
Database correctness is often exposed by what happens between ordinary operations. AletheiaGraph's durability program uses deterministic interruption points and reopen verification so failures can be reproduced at specific publication stages rather than approximated by occasional random process termination.
Establish the transaction and intended graph/index changes.
Terminate at a deterministic internal stage.
Recover the persistent graph rather than trusting in-memory state.
Compare graph, indexes and publication state against the defined valid outcomes.
Why AI changed the engineering economics
Two years earlier, the rational choice for this project likely would have been PostgreSQL beneath a graph/reasoning layer. In 2026, AI-assisted engineering makes deeper vertical integration economically realistic—not because a model can confer reliability, but because it can materially increase the rate of review, adversarial hypothesis generation, test construction, comparative analysis and regression expansion available to a small engineering effort.
More adversarial hypotheses
What if cardinality is zero? What if statistics are stale? What if the wrong graph is ambient? More failure hypotheses can be generated and checked before field deployment.
Faster conversion into evidence
A discovered defect can become a deterministic reproducer, qualification case and permanent regression gate rather than remaining tribal knowledge.
Broader comparative scrutiny
Design choices can be repeatedly challenged against established storage-engine techniques, prior failure patterns and competing implementations.
Evidentiary maturity
AletheiaGraph does not claim that qualification can predict every open-world interaction. Production diversity remains a distinct and valuable source of evidence. But calling a system simply “mature” or “unproven” collapses several different questions into one chronological label.
Specification maturity
Are the properties the engine must preserve explicit enough to test and falsify?
Qualification maturity
Have those properties survived meaningful recovery, concurrency, corruption, scale and semantic-boundary challenges?
Exposure maturity
Has deployment diversity revealed interactions and failure classes that the qualification program did not anticipate?
Failure-memory maturity
Does each discovered failure become durable, replayable engineering knowledge?
Operational diversity
How many workload, hardware, timing, lifecycle and integration combinations have exercised the system?
Adaptation velocity
How quickly can a new failure class be converted into an invariant, reproducer and permanent gate?
AletheiaGraph's maturity statement is therefore intentionally evidence-based: what behavior has been characterized, how was it challenged, what remains outside the evidence boundary, and can the accumulated lessons be replayed? That is what this page will continue to publish as v1 approaches freeze.