This audit reconciles public collateral claims from the Drive files opened on 2026-05-25 with the current ABI checkout. Treat repo source, `build.zig`, `src/cli/usage.zig`, `src/mcp/handlers.zig`, this `docs/contracts/` directory, and `tests/contracts/` as the source of truth.

## Audited Sources

- `MLAI Infrastructure Components and Specifications` spreadsheet.
- `High-Performance Neural State Management: Technical Analysis of WDBX and Multi-Persona Architectures` Google Doc.

## Repo-Backed Claims

| Claim area | Current repo evidence | Safe external wording |
| --- | --- | --- |
| Toolchain | `.zigversion`, `build.zig`, README quick start | ABI targets Zig `0.17.0-dev.1442+972627084` (pin); `build.zig.zon` minimum is Zig `0.17.0-dev.1252+e4b325c19`. Older Zig 0.16 wording is stale. |
| WDBX vector store | `src/features/wdbx/mod.zig`, `hnsw.zig`, `tests/contracts/surface.zig` | WDBX provides an in-process vector store with fixed-capacity padded vectors, HNSW-style indexing, SIMD cosine distance, ordered search-result contract coverage, and disabled-feature stubs. |
| Block history | `src/features/wdbx/chain.zig`, `tests/contracts/surface.zig` | WDBX provides SHA-256-linked conversation blocks with snapshot iteration and integrity verification coverage. |
| Spatial records | `src/features/wdbx/spatial_3d.zig`, `Store.stats()` | WDBX includes an in-memory 3D spatial index with Euclidean, Manhattan, and cosine-distance searches. |
| AI profiles | `src/features/ai/router.zig`, `src/features/ai/mod.zig` | ABI has local Abbey, Aviva, and Abi profile routes selected by deterministic keyword-weighted heuristics, with optional EMA state persistence. |
| Abbey identity contract | `src/features/ai/identity.zig`, `src/features/ai/router.zig`, `src/features/ai/incremental.zig`, `docs/spec/abbey-core-identity.mdx` | Abbey is the primary local deterministic profile, Aviva is the direct expert mode, and ABI is the orchestration/governance mode. The preserved Primary Declaration is product direction: visual generation, accessibility adaptation, distributed AI, production multi-host WDBX, blanket security controls, and empirical quality/performance outcomes remain Partial or Proposed as mapped in the canonical spec. |
| Completion persistence | `CompletionRequest.store_result`, `completeWithStore()`, contract tests | Completion persistence is opt-in; when WDBX is enabled it records query/response vectors, metadata, and append-linked blocks in a caller-provided store. |
| MCP/CLI | `src/cli/usage.zig`, `src/mcp/handlers.zig`, `src/mcp/stdio_transport.zig`, `src/mcp/http_transport.zig`, `src/mcp/server.zig`, contract tests | Public CLI commands and MCP tools are small, frozen surfaces guarded by contract tests. MCP stdio is local IPC; loopback HTTP/SSE can require `Authorization: Bearer <token>` via `ABI_MCP_HTTP_TOKEN`, but this is not a production non-loopback exposure claim without TLS/authz/rate-limit review. |
| GPU | `src/features/gpu/`, `build.zig`, contract tests | GPU support is capability/status reporting plus vector operations (`dot` / `squaredL2` / `cosineSimilarity` / `batchCosineSimilarity` / `scale` / `relu` / demo-grade `softmax`) and `compute_api` elementwise map/reduce (`mul` / `l2diff` / `add` / `sub` / `max` / `min` / `div`) that use linked Metal kernels on macOS when the backend reports initialized native kernels (`cosine_parts_kernel` fused path, `add_kernel` / `sub_kernel` / `max_kernel` / `min_kernel` / `div_kernel` / `scale_kernel` / `relu_kernel`, multi-pass `reduce_sum_kernel` / `reduce_max_kernel`, and `softmax_kernel` + `softmax_norm_kernel` in `metal_kernels.zig` / `vector_ops.zig` / `compute_api.zig`), and otherwise deterministically fall back to vectorized CPU. Softmax uses on-GPU reduce_max when available and keeps host partition-sum (demo-grade, not a perf path). Do not claim general GPU speedup, CUDA/Vulkan dispatch, or ANE execution. |
| Shaders / MLIR | `src/features/shaders/mod.zig`, `src/features/mlir/mod.zig` | The `shaders` feature validates shader source and emits a checksummed descriptor (`backend="validated-local"`); the `mlir` feature emits a textual ABI-dialect lowering (`backend="textual-local"`). Both report `available=false`: no external shader compiler or MLIR/LLVM toolchain is linked. Do not claim real shader compilation or MLIR/LLVM lowering. |
| Mobile | `src/features/mobile/mod.zig`, `src/features/mobile/stub.zig`, contract tests | The `mobile` feature reports compile-target/profile metadata and renders a synthetic text view. `native_dispatch=false` is authoritative: no UIKit/Android runtime, packaged mobile app target, device/emulator execution, or native mobile dispatch is implemented. |
| Connectors | `src/connectors/`, `docs/contracts/public-api.mdx` | OpenAI, Anthropic, Discord, Grok, and Twilio connectors validate local/live boundaries; live HTTP dispatch is explicit; Discord/Twilio logs redact message and provider-response bodies to metadata. |
| WDBX roadmap demos | `src/features/wdbx/{wal,recovery,segments,temporal,retrieval,cluster,cluster_rpc,compute,compression,entropy,ans,neural_compress,crypto_he,fhe,remote_compute,net_line,rest}.zig`, `src/cli/handlers/wdbx*.zig`, `docs/spec/wdbx-north-star.mdx` | The `abi wdbx` namespace adds a durable write-ahead log (O(1) append, replay + corruption detection), epoch-gated crash-safe recovery (checkpoint + WAL-delta merge), segment checkpoints as the default checkpoint source with `db compact` checkpoint-retention policy, a snapshot-persisted temporal/causal graph, 32-dim feature-hashed embeddings, persona-isolated + MCP `wdbx_query` hybrid ranking, and a zero-copy vector read view. Repo-backed (single-host / reference-scoped): in-process Raft-style consensus **and** a real TCP RequestVote/AppendEntries transport (`cluster_rpc`, `cluster serve`, loopback and same-host routable-bind tested) with shared-secret frames via `ABI_WDBX_CLUSTER_TOKEN`, optional peer allowlisting via `ABI_WDBX_CLUSTER_PEERS`, and non-loopback bind refusal without a token; loopback-tested remote-compute DOT transport helpers (`remote_compute`) whose env configuration is currently report-only rather than wired dispatch; a CPU/GPU parity test + ANE hardware **detection** (`compute`); int8 quantization, exact order-0 Huffman (`entropy`), demo rANS + order-1 residual coding (`ans`), **and** a trained autoencoder codec (`neural_compress`); additive HE **and** a DGHV somewhat-homomorphic add+multiply scheme (`fhe`, reference parameters); loopback REST (`api serve`) with optional bearer-token enforcement via `ABI_WDBX_REST_TOKEN`. Present these honestly — **not** production multi-host distributed deployment or data sharding, **not** CUDA/Vulkan/ANE native dispatch or blanket GPU acceleration (macOS Metal fused cosine/dot/L2 parts, multi-pass `reduce_sum_kernel`, and demo-grade softmax kernels are real when initialized), **not** a production/learned-SOTA compression codec, **not** production-secure or bootstrapped full FHE, and **not** production-ready non-loopback MCP/WDBX HTTP without TLS/authz/rate-limit review. |

## Claims To Remove Or Downgrade

| External claim | Repo status | Replacement wording |
| --- | --- | --- |
| WDBX is a distributed database with intelligent sharding. | Not currently proven by repo source or tests. Cluster RPC has shared-secret and peer-allowlist controls plus same-host routable-bind tests, but no cross-host production deployment or sharding proof. | WDBX is currently an in-process vector/key-value/block store with a tested consensus RPC transport, not a sharded distributed database. |
| WDBX proves `12,000 QPS`, `8.2 ms` latency, or `20-30%` lower latency. | Not currently proven by repo source, tests, or benchmark artifacts. | The repo validates functional search/block contracts; publish performance only with fresh benchmark artifacts. |
| WDBX includes AES-256 encryption or RBAC. | Not currently implemented as WDBX storage features. | Do not claim WDBX encryption/RBAC. Mention connector credential validation only where relevant. |
| ABI/WDBX is implemented in Swift 6 or Swift 6.2 Span. | Not present in the repo. | ABI/WDBX are Zig modules; macOS builds may link Metal/Foundation/Objective-C for GPU status paths. |
| ABI is implemented as a Python/JavaScript framework using TensorFlow, PyTorch, PostgreSQL, MongoDB, RabbitMQ, Kafka, Docker, Kubernetes, or Jenkins. | Not currently reflected by this repo's implementation or build. | ABI is a Zig codebase with local connectors, feature modules, build-time plugin registry generation, and Zig build/test gates. |
| ABI proves `295x` GPU matmul speedup or `13x` neural-network speedup. | Not currently proven by repo benchmark outputs. | GPU paths report backend capabilities and CPU fallback behavior. |
| WDBX proves `10,000 req/s`, `50 ms` latency, or `95%` accuracy. | Not currently proven by repo tests or benchmark artifacts. | Keep these as future benchmark targets unless a reproducible ABI benchmark artifact exists. |
| Abbey/Aviva/Abi have measured empathy, technical-accuracy, SQuAD, CodeSearchNet, or model-comparison scores. | Not currently proven by repo tests. | The repo has deterministic local routing/profile behavior and validation helpers, not external model-quality benchmarks. |
| The multi-persona system proves `15 kWh/1k` energy use or `25%` efficiency gains. | Not currently measured by repo tests or tooling. | Do not publish energy-efficiency claims without a reproducible measurement artifact. |
| ABI performs dynamic neural persona blending using model-output interpolation formulas. | Not implemented as neural output blending. | ABI uses keyword-weighted profile selection and optional EMA smoothing of route weights. |
| ABI is deployed on H100/A100 clusters, Kubernetes auto-scaling, InfiniBand/NVLink, or decentralized blockchain nodes. | Not currently proven by this repo. | Present those only as external deployment proposals, not current ABI repo capabilities. |
| ABI is certified for GDPR, CCPA, HIPAA, ISO 27001, or compliance-by-design guarantees. | Not currently proven by repo source or tests. | The repo has local constitution checks, connector validation, and POSIX credential-file permission hardening, but no regulatory certification evidence. |

## Reusable Delta For External Artifacts

Use this concise replacement paragraph when updating Drive docs:

> Current ABI repo evidence supports a Zig 0.17 local AI orchestration framework with deterministic Abbey/Aviva/Abi profile routing, an in-process WDBX vector/key-value/block store, segment checkpoint plus WAL persistence with runtime recovery, a compatibility JSONL snapshot mirror, epoch reclamation helpers, snapshot-persisted temporal/causal graph records, MCP hybrid WDBX query ranking, HNSW-style cosine search, SHA-256-linked conversation blocks, 3D spatial search, feature-off stubs, CLI/MCP contract coverage, explicit connector live-mode boundaries, GPU capability reporting with macOS Metal fused cosine/dot/L2 parts, elementwise add/sub/max/min/div plus unary scale/relu kernels, multi-pass threadgroup `reduce_sum` / `reduce_max` (public `reduceMax` API), and demo-grade softmax when native kernels initialize (else CPU fallback), opt-in macOS login keychain credential backend (Windows/Linux OS secret stores Proposed), demo Huffman + rANS/order-1 compression surfaces, and a tested WDBX consensus RPC transport with shared-secret, optional peer-allowlist controls, and runtime peer-set reload (`ClusterPolicy.withPeers`, loopback-tested); plus production-hardening (incomplete HTTP bodies rejected 400 before dispatch, constant-time bearer, WAL fsync+parent-dir sync+skipped torn tails, putVector HNSW rollback+id-burn on WAL fail, REST rate-limit before auth, MCP durable fail-closed unless ABI_WDBX_ALLOW_MEMORY_FALLBACK, scheduler OOM-safe error_msg). The repo does not currently prove distributed sharding, production multi-host deployment, AES/RBAC WDBX storage, Swift/Python/TensorFlow implementation claims, Kubernetes/H100 deployment claims, regulatory certifications, QPS/latency/accuracy targets, GPU speedup figures, energy-efficiency metrics, or SQuAD/CodeSearchNet/GPT comparative scores.