From d9da2161825bf115e4e4abd2973efc76b291d11a Mon Sep 17 00:00:00 2001
From: rUv
Date: Mon, 16 Feb 2026 14:43:04 +0000
Subject: [PATCH] docs: update READMEs with self-booting instructions, bump npm
versions
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
- Add Claude Code Appliance walkthrough and 5.1 MB self-boot line to
crate, examples, npm, and root READMEs
- Add missing live_boot_proof example to table (45→46 examples)
- Update segment count references from 20→24
- Improve rvf-node npm README with full API reference
- Expand AGI Cognitive Container documentation
- Bump npm packages: rvf-node 0.1.3, rvf-wasm 0.1.3,
rvf-mcp-server 0.1.3, rvf 0.1.5
- Include verified claude_code_appliance output files
Co-Authored-By: claude-flow
---
README.md | 16 +-
crates/rvf/Cargo.lock | 6 +-
crates/rvf/README.md | 321 ++++++++++++++++--
crates/rvf/rvf-node/README.md | 286 ++++++++++++----
examples/rvf/Cargo.lock | 6 +-
examples/rvf/README.md | 36 +-
examples/rvf/output/claude_code_appliance.rvf | Bin 17122 -> 5260093 bytes
.../rvf/output/claude_code_appliance_v1.rvf | Bin 0 -> 162 bytes
npm/packages/rvf-mcp-server/package.json | 2 +-
npm/packages/rvf-node/README.md | 308 +++++++++++++++--
npm/packages/rvf-node/package.json | 2 +-
npm/packages/rvf-wasm/package.json | 2 +-
npm/packages/rvf/README.md | 4 +-
npm/packages/rvf/package.json | 2 +-
14 files changed, 850 insertions(+), 141 deletions(-)
create mode 100644 examples/rvf/output/claude_code_appliance_v1.rvf
diff --git a/README.md b/README.md
index 0226dcd2a..e24857800 100644
--- a/README.md
+++ b/README.md
@@ -74,7 +74,7 @@ Most vector databases are static — they store embeddings and search them. That
| 21 | **Witness chains** | Tamper-evident hash-linked audit trail for every operation |
| 22 | **Post-quantum signatures** | ML-DSA-65 and SLH-DSA-128s alongside Ed25519 |
| 23 | **DNA-style lineage** | Track parent/child derivation chains with cryptographic hashes |
-| 24 | **20 segment types** | VEC, INDEX, KERNEL, EBPF, COW_MAP, WITNESS, CRYPTO, and 13 more |
+| 24 | **24 segment types** | VEC, INDEX, KERNEL, EBPF, WASM, COW_MAP, WITNESS, CRYPTO, and 16 more |
**Specialized Processing**
| # | Capability | What It Does |
@@ -221,7 +221,7 @@ npx @ruvector/rvf-mcp-server --transport stdio # MCP server for AI agents
| Tamper-evident audit | Hash-linked witness chain for every insert, query, and deletion |
| Post-quantum signatures | ML-DSA-65 and Ed25519 signing on every segment |
| DNA-style lineage | Parent/child derivation chains with cryptographic verification |
-| 20 segment types | VEC, INDEX, KERNEL, EBPF, WASM, COW_MAP, WITNESS, CRYPTO, and 12 more |
+| 24 segment types | VEC, INDEX, KERNEL, EBPF, WASM, COW_MAP, WITNESS, CRYPTO, and 16 more |
**Rust crates** (13): [`rvf-types`](https://crates.io/crates/rvf-types) `rvf-wire` `rvf-manifest` `rvf-quant` `rvf-index` `rvf-crypto` [`rvf-runtime`](https://crates.io/crates/rvf-runtime) `rvf-kernel` `rvf-ebpf` `rvf-launch` `rvf-server` `rvf-import` [`rvf-cli`](https://crates.io/crates/rvf-cli)
@@ -230,7 +230,7 @@ npx @ruvector/rvf-mcp-server --transport stdio # MCP server for AI agents
- **Full documentation**: [crates/rvf/README.md](./crates/rvf/README.md)
- **ADR-030**: [Cognitive Container Architecture](./docs/adr/ADR-030-rvf-cognitive-container.md)
- **ADR-031**: [COW Branching & Real Containers](./docs/adr/ADR-031-rvcow-branching-and-real-cognitive-containers.md)
-- **45 runnable examples**: [examples/rvf/examples/](./examples/rvf/examples/)
+- **46 runnable examples**: [examples/rvf/examples/](./examples/rvf/examples/)
@@ -1431,7 +1431,15 @@ let syndrome = gate.assess_coherence(&quantum_state)?;
| [rvf-import](./crates/rvf/rvf-import) | JSON, CSV, NumPy importers | [](https://crates.io/crates/rvf-import) |
| [rvf-cli](./crates/rvf/rvf-cli) | Unified CLI with 17 subcommands | [](https://crates.io/crates/rvf-cli) |
-**RVF Features:** Single-file cognitive containers that boot as Linux microservices, COW branching at cluster granularity, eBPF acceleration, witness chains, post-quantum signatures, 20 segment types. [Full README](./crates/rvf/README.md)
+**RVF Features:** Single-file cognitive containers that boot as Linux microservices, COW branching at cluster granularity, eBPF acceleration, witness chains, post-quantum signatures, 24 segment types. [Full README](./crates/rvf/README.md)
+
+**Self-booting example** — the `claude_code_appliance` builds a complete AI dev environment as one file:
+
+```bash
+cd examples/rvf && cargo run --example claude_code_appliance
+```
+
+Final file: **5.1 MB single `.rvf`** — boots Linux, serves queries, runs Claude Code. One file. Boots on QEMU/Firecracker. Runs SSH. Serves vectors. Installs Claude Code. Proves every step with a cryptographic witness chain.
### Personal AI Memory (OSpipe)
diff --git a/crates/rvf/Cargo.lock b/crates/rvf/Cargo.lock
index e30c828b2..8eb90a4ce 100644
--- a/crates/rvf/Cargo.lock
+++ b/crates/rvf/Cargo.lock
@@ -1689,7 +1689,7 @@ dependencies = [
[[package]]
name = "rvf-crypto"
-version = "0.1.0"
+version = "0.2.0"
dependencies = [
"ed25519-dalek",
"rand",
@@ -1795,7 +1795,7 @@ dependencies = [
[[package]]
name = "rvf-runtime"
-version = "0.1.0"
+version = "0.2.0"
dependencies = [
"rand",
"rvf-types",
@@ -1833,7 +1833,7 @@ dependencies = [
[[package]]
name = "rvf-types"
-version = "0.1.0"
+version = "0.2.0"
dependencies = [
"ed25519-dalek",
"rand_core",
diff --git a/crates/rvf/README.md b/crates/rvf/README.md
index 78c67b6a9..76efda7c0 100644
--- a/crates/rvf/README.md
+++ b/crates/rvf/README.md
@@ -16,10 +16,10 @@
-
-
-
-
+
+
+
+
@@ -69,7 +69,7 @@ This is not a database format. It is an **executable knowledge unit**.
| Capability | How | Segment |
|------------|-----|---------|
| 🤖 **Plug into AI agents** | An MCP server lets Claude Code, Cursor, and other AI tools create, query, and manage vector stores directly. | npm package |
-| 📦 **Use from any language** | Published as 13 Rust crates, 4 npm packages, a CLI tool, and an HTTP server. Works from Rust, Node.js, browsers, and the command line. | 13 crates + 4 npm |
+| 📦 **Use from any language** | Published as 14 Rust crates, 6 adapters, 4 npm packages, a CLI tool, and an HTTP server. Works from Rust, Node.js, browsers, and the command line. | 14 crates + 6 adapters + 4 npm |
| ♻️ **Always backward-compatible** | Old tools skip new segment types they don't understand. A file with COW branching still works in a reader that only knows basic vectors. | Format rule |
```
@@ -150,19 +150,20 @@ A single `.rvf` file is crash-safe (no WAL needed), self-describing, and progres
| Crate | Version | Description |
|-------|---------|-------------|
-| [`rvf-types`](https://crates.io/crates/rvf-types) | 0.1.0 | Segment types, 20 headers, enums (`no_std`) |
+| [`rvf-types`](https://crates.io/crates/rvf-types) | 0.2.0 | Segment types, 24 headers, quality, security, AGI container types (`no_std`) |
| [`rvf-wire`](https://crates.io/crates/rvf-wire) | 0.1.0 | Wire format read/write (`no_std`) |
| [`rvf-manifest`](https://crates.io/crates/rvf-manifest) | 0.1.0 | Two-level manifest, FileIdentity, COW pointers |
| [`rvf-quant`](https://crates.io/crates/rvf-quant) | 0.1.0 | Scalar, product, and binary quantization |
| [`rvf-index`](https://crates.io/crates/rvf-index) | 0.1.0 | HNSW progressive indexing (Layer A/B/C) |
-| [`rvf-crypto`](https://crates.io/crates/rvf-crypto) | 0.1.0 | SHAKE-256, Ed25519, witness chains, attestation |
-| [`rvf-runtime`](https://crates.io/crates/rvf-runtime) | 0.1.0 | Full store API, COW engine, compaction |
+| [`rvf-crypto`](https://crates.io/crates/rvf-crypto) | 0.2.0 | SHAKE-256, Ed25519, witness chains, seed crypto |
+| [`rvf-runtime`](https://crates.io/crates/rvf-runtime) | 0.2.0 | Full store API, COW engine, AGI containers, QR seeds, safety net |
| [`rvf-kernel`](https://crates.io/crates/rvf-kernel) | 0.1.0 | Linux kernel builder, initramfs, Docker pipeline |
| [`rvf-ebpf`](https://crates.io/crates/rvf-ebpf) | 0.1.0 | BPF C compiler (XDP, socket filter, TC) |
| [`rvf-launch`](https://crates.io/crates/rvf-launch) | 0.1.0 | QEMU microvm launcher, KVM/TCG, QMP |
| [`rvf-server`](https://crates.io/crates/rvf-server) | 0.1.0 | HTTP REST + TCP streaming server |
| [`rvf-import`](https://crates.io/crates/rvf-import) | 0.1.0 | JSON, CSV, NumPy importers |
| [`rvf-cli`](https://crates.io/crates/rvf-cli) | 0.1.0 | Unified CLI with 17 subcommands |
+| [`rvf-solver-wasm`](https://crates.io/crates/rvf-solver-wasm) | 0.1.0 | Thompson Sampling temporal solver (WASM, `no_std`) |
### npm Packages (npmjs.org)
@@ -215,10 +216,10 @@ npx @ruvector/rvf-mcp-server --transport stdio
```toml
# Cargo.toml
[dependencies]
-rvf-runtime = "0.1" # full store API
-rvf-types = "0.1" # types only (no_std)
+rvf-runtime = "0.2" # full store API
+rvf-types = "0.2" # types only (no_std)
rvf-wire = "0.1" # wire format (no_std)
-rvf-crypto = "0.1" # signatures + witness chains
+rvf-crypto = "0.2" # signatures + witness chains
rvf-import = "0.1" # JSON/CSV/NumPy importers
```
@@ -325,7 +326,7 @@ rvf inspect output/linux_microkernel.rvf
## 📋 What RVF Contains
-An RVF file is a sequence of typed segments. Each segment is self-describing, 64-byte aligned, and independently integrity-checked. The format supports 20 segment types that together constitute a complete cognitive runtime:
+An RVF file is a sequence of typed segments. Each segment is self-describing, 64-byte aligned, and independently integrity-checked. The format supports 24 segment types that together constitute a complete cognitive runtime:
```
.rvf file (Sealed Cognitive Engine)
@@ -350,6 +351,9 @@ An RVF file is a sequence of typed segments. Each segment is self-describing, 64
+-- REFCOUNT_SEG .... Cluster reference counts, rebuildable (0x21)
+-- MEMBERSHIP_SEG .. Vector visibility filter for branches (0x22)
+-- DELTA_SEG ....... Sparse delta patches / LoRA overlays (0x23)
+ +-- TRANSFER_PRIOR .. Transfer learning priors (0x30)
+ +-- POLICY_KERNEL ... Thompson Sampling policy state (0x31)
+ +-- COST_CURVE ...... Cost/reward curves for solver (0x32)
```
---
@@ -407,7 +411,7 @@ This is not a database. It is a **sealed, auditable, self-booting domain expert*
## 🔌 RuVector Ecosystem Integration
-RVF is the canonical binary format across 75+ Rust crates in the RuVector ecosystem:
+RVF is the canonical binary format across 87+ Rust crates in the RuVector ecosystem:
| Domain | Crates | RVF Segment |
|--------|--------|-------------|
@@ -439,7 +443,7 @@ The same `.rvf` file format runs on cloud servers, Firecracker microVMs, TEE enc
| **Temperature-tiered quantization** | Hot vectors stay fp16, warm use product quantization, cold use binary — automatically. |
| **Metadata filtering** | Filtered k-NN with boolean expressions (AND/OR/NOT/IN/RANGE). |
| **4 KB instant boot** | Root manifest fits in one page read. Cold boot < 5 ms. |
-| **20 segment types** | VEC, INDEX, MANIFEST, QUANT, WITNESS, CRYPTO, KERNEL, EBPF, COW_MAP, MEMBERSHIP, DELTA, and 9 more. |
+| **24 segment types** | VEC, INDEX, MANIFEST, QUANT, WITNESS, CRYPTO, KERNEL, EBPF, WASM, COW_MAP, MEMBERSHIP, DELTA, TRANSFER_PRIOR, POLICY_KERNEL, COST_CURVE, and 9 more. |
### COW Branching (RVCOW)
@@ -530,17 +534,18 @@ An `.rvf` file is a sequence of 64-byte-aligned segments. Each segment has a sel
| Crate | Lines | Purpose |
|-------|------:|---------|
-| `rvf-types` | 5,200+ | Segment types, 20 headers, COW/membership/delta/kernel-binding types, enums (`no_std`) |
+| `rvf-types` | 7,000+ | 24 segment types, AGI container, quality, security, WASM bootstrap, QR seed (`no_std`) |
| `rvf-wire` | 2,011 | Wire format read/write (`no_std`) |
| `rvf-manifest` | 1,700+ | Two-level manifest with 4 KB root, FileIdentity codec, COW pointers, double-root scheme |
| `rvf-index` | 2,691 | HNSW progressive indexing (Layer A/B/C) |
| `rvf-quant` | 1,443 | Scalar, product, and binary quantization |
-| `rvf-crypto` | 1,725 | SHAKE-256, Ed25519, witness chains, attestation, lineage witnesses |
-| `rvf-runtime` | 5,500+ | Full store API, COW engine, membership filters, compaction, branch/freeze |
+| `rvf-crypto` | 1,725 | SHAKE-256, Ed25519, witness chains, attestation, seed crypto |
+| `rvf-runtime` | 8,000+ | Full store API, COW engine, AGI containers, QR seeds, safety net, adversarial defense |
| `rvf-kernel` | 2,400+ | Real Linux kernel builder, cpio/newc initramfs, Docker build, SHA3-256 verification |
| `rvf-launch` | 1,200+ | QEMU microvm launcher, KVM/TCG detection, QMP shutdown protocol |
| `rvf-ebpf` | 1,100+ | Real BPF C compiler (XDP, socket filter, TC), vmlinux.h generation |
| `rvf-wasm` | 1,700+ | WASM control plane: in-memory store, query, segment inspection, witness chain verification (~46 KB) |
+| `rvf-solver-wasm` | 1,500+ | Thompson Sampling temporal solver, PolicyKernel, three-loop architecture (`no_std`) |
| `rvf-node` | 852 | Node.js N-API bindings with lineage, kernel/eBPF, and inspection |
| `rvf-cli` | 1,800+ | Unified CLI with 17 subcommands (create, ingest, query, delete, status, inspect, compact, derive, serve, launch, embed-kernel, embed-ebpf, filter, freeze, verify-witness, verify-attestation, rebuild-refcounts) |
| `rvf-server` | 1,165 | HTTP REST + TCP streaming server |
@@ -791,6 +796,115 @@ if let Some((header, program_data)) = store.extract_ebpf()? {
For the full specification including wire formats, attestation binding, and implementation phases, see [ADR-030: RVF Cognitive Container](docs/adr/ADR-030-rvf-computational-container.md).
+### End-to-End: Claude Code Appliance
+
+The `claude_code_appliance` example builds a complete self-booting AI development environment as a single `.rvf` file. It uses real infrastructure — a Docker-built Linux kernel, Ed25519 SSH keys, a BPF C socket filter, and a cryptographic witness chain.
+
+**Prerequisites:** Docker (for kernel build), Rust 1.87+
+
+```bash
+# Build and run the example
+cd examples/rvf
+cargo run --example claude_code_appliance
+```
+
+**What it produces** (5.1 MB file):
+
+```
+claude_code_appliance.rvf
+ ├── KERNEL_SEG Linux 6.8.12 bzImage (5.2 MB, x86_64)
+ ├── EBPF_SEG Socket filter — allows ports 2222, 8080 only
+ ├── VEC_SEG 20 package embeddings (128-dim)
+ ├── INDEX_SEG HNSW graph for package search
+ ├── WITNESS_SEG 6-entry tamper-evident audit trail
+ ├── CRYPTO_SEG 3 Ed25519 SSH user keys (root, deploy, claude)
+ ├── MANIFEST_SEG 4 KB root with segment directory
+ └── Snapshot v1 derived image with lineage tracking
+```
+
+**Boot sequence** (once launched on Firecracker/QEMU):
+
+```
+1. Firecracker loads KERNEL_SEG → Linux boots (<125 ms)
+2. SSH server starts on port 2222
+3. curl -fsSL https://claude.ai/install.sh | bash
+4. RVF query server starts on port 8080
+5. Claude Code ready for use
+```
+
+**Connect and use:**
+
+```bash
+# Boot the file (requires QEMU or Firecracker)
+rvf launch claude_code_appliance.rvf
+
+# SSH in
+ssh -p 2222 deploy@localhost
+
+# Query the package database
+curl -s localhost:8080/query -d '{"vector":[0.1,...], "k":5}'
+
+# Or use the CLI
+rvf query claude_code_appliance.rvf --vector "0.1,0.2,..." --k 5
+```
+
+**Verified output from the example run:**
+
+```
+=== Claude Code Appliance Summary ===
+ File size: 5,260,093 bytes (5.1 MB)
+ Segments: 8
+ Packages: 20 (203.1 MB manifest)
+ KERNEL_SEG: MicroLinux x86_64 (5,243,904 bytes)
+ EBPF_SEG: SocketFilter (3,805 bytes)
+ SSH users: 3 (Ed25519 signed, all verified)
+ Witness chain: 6 entries (tamper-evident, all verified)
+ Lineage: base + v1 snapshot (parent hash matches)
+```
+
+Final file: **5.1 MB single `.rvf`** — boots Linux, serves queries, runs Claude Code.
+
+One file. Boots Linux. Runs SSH. Serves vectors. Installs Claude Code. Proves every step.
+
+### Launching with QEMU
+
+```bash
+# CLI launcher (auto-detects KVM or falls back to TCG)
+rvf launch vectors.rvf
+
+# Manual QEMU (if you want control)
+rvf launch vectors.rvf --memory 512M --cpus 2 --port-forward 2222:22,8080:8080
+
+# Extract kernel for external use
+rvf inspect vectors.rvf --segment kernel --output kernel.bin
+qemu-system-x86_64 -M microvm -kernel kernel.bin -append "console=ttyS0" -nographic
+```
+
+### Building Your Own Bootable RVF
+
+Step-by-step to create a self-booting `.rvf` from scratch:
+
+```bash
+# 1. Create a vector store
+rvf create myservice.rvf --dimension 384
+
+# 2. Ingest your data
+rvf ingest myservice.rvf --input embeddings.json --format json
+
+# 3. Build and embed a Linux kernel (uses Docker)
+rvf embed-kernel myservice.rvf --arch x86_64
+
+# 4. Optionally embed an eBPF filter
+rvf embed-ebpf myservice.rvf --program filter.c
+
+# 5. Verify the result
+rvf inspect myservice.rvf
+# MANIFEST_SEG, VEC_SEG, INDEX_SEG, KERNEL_SEG, EBPF_SEG, WITNESS_SEG
+
+# 6. Boot it
+rvf launch myservice.rvf
+```
+
---
## 🔗 Library Adapters
@@ -808,6 +922,143 @@ RVF provides drop-in adapters for 6 libraries in the RuVector ecosystem:
---
+## 🤖 AGI Cognitive Container (ADR-036)
+
+An AGI container packages a complete AI agent runtime into a single sealed `.rvf` file. Where the [Self-Booting RVF](#%EF%B8%8F-self-booting-rvf-cognitive-container) section covers the compute tiers (WASM/eBPF/Kernel), the AGI container adds the intelligence layer on top: model identity, orchestration config, tool registries, evaluation harnesses, authority controls, and coherence gates.
+
+```
+AGI Cognitive Container (.rvf)
+├── Identity ────── container UUID, build UUID, model ID hash
+├── Orchestrator ── Claude Code / Claude Flow config (JSON)
+├── Tools ──────── MCP tool adapter registry
+├── Agent Prompts ─ role definitions per agent type
+├── Eval Harness ── task suite + grading rules
+├── Skills ──────── promoted skill library
+├── Policy ──────── governance rules + authority config
+├── Coherence ───── min score, contradiction rate, rollback ratio
+├── Resources ───── time/token/cost budgets with clamping
+├── Replay ──────── automation script for deterministic re-execution
+├── Kernel Config ─ boot parameters, network, SSH
+├── Domain Profile ─ coding / research / ops specialization
+└── Signature ───── HMAC-SHA256 or Ed25519 tamper seal
+```
+
+### Execution Modes
+
+| Mode | Purpose | Requires |
+|------|---------|----------|
+| **Replay** | Deterministic re-execution from witness logs | Witness chain |
+| **Verify** | Validate container integrity and run eval harness | Kernel + world model, or WASM + vectors |
+| **Live** | Full autonomous operation with tool use | Kernel + world model |
+
+### Authority Levels
+
+Authority is hierarchical — each level permits everything below it:
+
+| Level | Allows |
+|-------|--------|
+| `ReadOnly` | Read vectors, run queries |
+| `WriteMemory` | + Write to vector store, update index |
+| `ExecuteTools` | + Invoke MCP tools, run commands |
+| `WriteExternal` | + Network access, file I/O, push to git |
+
+Default authority per mode: Replay → ReadOnly, Verify → ExecuteTools, Live → WriteMemory.
+
+### Resource Budgets
+
+Every container carries hard limits that are clamped to safety maximums:
+
+| Resource | Max | Default |
+|----------|-----|---------|
+| Time | 3,600 sec | 300 sec |
+| Tokens | 1,000,000 | 100,000 |
+| Cost | $10.00 | $1.00 |
+| Tool calls | 500 | 100 |
+| External writes | 50 | 10 |
+
+### Coherence Gates
+
+Coherence thresholds halt execution when the agent's world model drifts:
+
+- `min_coherence_score` (0.0–1.0) — minimum quality gate
+- `max_contradiction_rate` (0.0–1.0) — tolerable contradiction frequency
+- `max_rollback_ratio` (0.0–1.0) — ratio of rolled-back decisions
+
+### Building a Container
+
+```rust
+use rvf_runtime::agi_container::AgiContainerBuilder;
+use rvf_types::agi_container::*;
+
+let (payload, header) = AgiContainerBuilder::new(container_id, build_id)
+ .with_model_id("claude-opus-4-6")
+ .with_orchestrator(b"{\"max_turns\":100}")
+ .with_tool_registry(b"[{\"name\":\"search\",\"type\":\"rvf_query\"}]")
+ .with_eval_tasks(b"[{\"id\":1,\"spec\":\"fix bug\"}]")
+ .with_eval_graders(b"[{\"type\":\"test_pass\"}]")
+ .with_authority_config(b"{\"level\":\"WriteMemory\"}")
+ .with_coherence_config(b"{\"min_cut\":0.7,\"rollback\":true}")
+ .with_project_instructions(b"# CLAUDE.md\nFix bugs, run tests.")
+ .with_segments(ContainerSegments {
+ kernel_present: true, manifest_present: true,
+ world_model_present: true, ..Default::default()
+ })
+ .build_and_sign(signing_key)?;
+
+// Parse and validate
+let manifest = ParsedAgiManifest::parse(&payload)?;
+assert_eq!(manifest.model_id_str(), Some("claude-opus-4-6"));
+assert!(manifest.is_autonomous_capable());
+assert!(header.is_signed());
+```
+
+See [ADR-036](../../docs/adr/ADR-036-agi-cognitive-container.md) for the full specification.
+
+## 📱 QR Cognitive Seed (ADR-034)
+
+A QR Cognitive Seed (RVQS) encodes a portable intelligence capsule into a scannable QR code. It carries bootstrap hosts, layer hashes, and cryptographic signatures in a compact binary format.
+
+```rust
+use rvf_runtime::seed_crypto;
+
+let hash = seed_crypto::seed_content_hash(data); // 8-byte SHAKE-256
+let sig = seed_crypto::sign_seed(key, payload); // 32-byte HMAC
+let ok = seed_crypto::verify_seed(key, payload, &sig);
+```
+
+Types: `SeedHeader`, `HostEntry`, `LayerEntry` (rvf-types), plus `qr_encode` for QR matrix generation (rvf-runtime).
+
+## 🔒 Quality & Safety Net
+
+The quality system tracks retrieval fidelity across progressive index layers and enforces graceful degradation when budgets are exceeded.
+
+- `RetrievalQuality` — Full / Partial / Degraded / Failed
+- `ResponseQuality` — per-query quality metadata with evidence
+- `SafetyNetBudget` — time, token, and cost budgets with automatic clamping
+- `DegradationReport` — structured fallback path and reason tracking
+
+## 🛡️ Security Hardening
+
+Built-in defenses against adversarial inputs and resource exhaustion:
+
+- `SecurityPolicy` / `HardeningFields` — declarative security configuration (rvf-types)
+- `adversarial` module — input validation and tamper detection (rvf-runtime)
+- `dos` module — rate limiting and resource exhaustion guards (rvf-runtime)
+
+## 🧬 WASM Self-Bootstrapping (0x10)
+
+WASM_SEG enables an RVF file to carry its own WASM interpreter, creating a three-layer bootstrap stack:
+
+```
+Raw bytes → WASM interpreter → microkernel → vector data
+```
+
+Types: `WasmRole` (Interpreter/Microkernel/Solver), `WasmTarget` (Browser/Node/Edge/Embedded), `WasmHeader` (rvf-types/wasm_bootstrap).
+
+The `rvf-solver-wasm` crate implements a Thompson Sampling temporal solver as a `no_std` WASM module with `dlmalloc`, producing segment types `TRANSFER_PRIOR` (0x30), `POLICY_KERNEL` (0x31), and `COST_CURVE` (0x32).
+
+---
+
45 Runnable Examples
@@ -906,12 +1157,13 @@ cargo run --example
| 42 | [`membership_filter`](../../examples/rvf/examples/membership_filter.rs) | Include/exclude bitmap filters for shared HNSW traversal |
| 43 | [`snapshot_freeze`](../../examples/rvf/examples/snapshot_freeze.rs) | Generation snapshots, immutable freeze, generation tracking |
-#### Appliance & Generation (2)
+#### Appliance & Generation (3)
| # | Example | What It Demonstrates |
|---|---------|---------------------|
| 44 | [`claude_code_appliance`](../../examples/rvf/examples/claude_code_appliance.rs) | Bootable AI dev environment: real kernel + eBPF + vectors + witness + crypto |
-| 45 | [`generate_all`](../../examples/rvf/examples/generate_all.rs) | Batch generation of all 45 example `.rvf` files |
+| 45 | [`live_boot_proof`](../../examples/rvf/examples/live_boot_proof.rs) | Docker-boot an `.rvf`, SSH in, verify segments are live and operational |
+| 46 | [`generate_all`](../../examples/rvf/examples/generate_all.rs) | Batch generation of all example `.rvf` files |
See the [examples README](../../examples/rvf/README.md) for tutorials, usage patterns, and detailed walkthroughs.
@@ -1317,10 +1569,14 @@ let dist = hamming_distance(&bits_a, &bits_b);
| `0x0D` | META_IDX | Metadata inverted indexes |
| `0x0E` | KERNEL | Compressed unikernel image (self-booting) |
| `0x0F` | EBPF | eBPF program for kernel-level acceleration |
+| `0x10` | WASM | WASM microkernel / self-bootstrapping bytecode |
| `0x20` | COW_MAP | Cluster ownership map (local vs parent) |
| `0x21` | REFCOUNT | Cluster reference counts (rebuildable) |
| `0x22` | MEMBERSHIP | Vector visibility filter for branches |
| `0x23` | DELTA | Sparse delta patches (LoRA overlays) |
+| `0x30` | TRANSFER_PRIOR | Transfer learning prior distributions |
+| `0x31` | POLICY_KERNEL | Thompson Sampling policy kernels |
+| `0x32` | COST_CURVE | Cost/reward curves for solver |
### Segment Flags
@@ -1700,10 +1956,14 @@ cargo run --example claude_code_appliance
# File size: 17 KB — sealed cognitive container
```
-### Integration Test Suite: 46/46 Passing
+### Test Suite: 1,156 Passing
```bash
cargo test --workspace
+# agi_e2e .................. 12 passed
+# adr033_integration ....... 34 passed
+# qr_seed_e2e .............. 11 passed
+# witness_e2e .............. 10 passed
# attestation .............. 6 passed
# crypto ................... 10 passed
# computational_container .. 8 passed
@@ -1711,10 +1971,11 @@ cargo test --workspace
# cross_platform ........... 6 passed
# lineage .................. 4 passed
# smoke .................... 4 passed
-# Total: 46/46 integration tests passed
+# + unit tests across all crates
+# Total: 1,156 tests passed
```
-### Generate All 45 Example Files
+### Generate All 46 Example Files
```bash
cd examples/rvf && cargo run --example generate_all
@@ -1731,7 +1992,21 @@ cd ruvector/crates/rvf
cargo test --workspace
```
-All contributions must pass `cargo clippy --all-targets` with zero warnings and maintain the existing test count (currently 795+).
+All contributions must pass `cargo clippy --all-targets` with zero warnings and maintain the existing test count (currently 1,156+).
+
+### Architecture Decision Records
+
+| ADR | Title |
+|-----|-------|
+| [ADR-030](docs/adr/ADR-030-rvf-computational-container.md) | RVF Cognitive Container (Kernel, eBPF, WASM tiers) |
+| [ADR-031](docs/adr/ADR-031-rvcow-branching-and-real-cognitive-containers.md) | RVCOW Branching & Real Cognitive Containers |
+| [ADR-033](../../docs/adr/ADR-033-progressive-indexing-hardening.md) | Progressive Indexing Hardening |
+| [ADR-034](../../docs/adr/ADR-034-qr-cognitive-seed.md) | QR Cognitive Seed (RVQS) |
+| [ADR-035](../../docs/adr/ADR-035-capability-report.md) | Capability Report |
+| [ADR-036](../../docs/adr/ADR-036-agi-cognitive-container.md) | AGI Cognitive Container |
+| [ADR-037](../../docs/adr/ADR-037-publishable-rvf-acceptance-test.md) | Publishable RVF Acceptance Tests |
+| [ADR-038](../../docs/adr/ADR-038-npx-ruvector-rvlite-witness-integration.md) | npx ruvector rvlite Witness Integration |
+| [ADR-039](../../docs/adr/ADR-039-rvf-solver-wasm-agi-integration.md) | RVF Solver WASM AGI Integration |
## 📄 License
diff --git a/crates/rvf/rvf-node/README.md b/crates/rvf/rvf-node/README.md
index 95e996077..ec20b738b 100644
--- a/crates/rvf/rvf-node/README.md
+++ b/crates/rvf/rvf-node/README.md
@@ -1,132 +1,278 @@
-# rvf-node
+# @ruvector/rvf-node
-Node.js N-API bindings for native RuVector Format operations.
+Native Node.js bindings for the [RuVector Format](https://github.com/ruvnet/ruvector/tree/main/crates/rvf) (RVF) vector database. Built with Rust via N-API for native speed with zero serialization overhead.
-## Overview
-
-`rvf-node` exposes the RVF runtime to Node.js via N-API for high-performance vector operations without leaving JavaScript:
-
-- **Async API** -- non-blocking vector store operations
-- **Native speed** -- Rust-compiled N-API addon, no serialization overhead
-- **Cross-platform** -- builds for Linux, macOS, and Windows
-- **Full feature parity** -- lineage, kernel/eBPF embedding, segment inspection
-
-## Build
+## Install
```bash
-cd crates/rvf/rvf-node
-npm run build
+npm install @ruvector/rvf-node
```
-## API
+## Features
+
+- **Native Rust performance** via N-API (napi-rs), no FFI marshaling
+- **Single-file vector database** — crash-safe, no WAL, append-only
+- **k-NN search** with HNSW progressive indexing (recall 0.70 → 0.95)
+- **Metadata filtering** — Eq, Ne, Lt, Gt, Range, In, And, Or, Not
+- **Lineage tracking** — DNA-style parent/child derivation chains
+- **Kernel & eBPF embedding** — embed compute alongside vector data
+- **Segment inspection** — enumerate all segments in the file
+- **Cross-platform** — Linux (x86_64, aarch64), macOS (x86_64, Apple Silicon), Windows (x86_64)
+
+## Quick Start
+
+```javascript
+const { RvfDatabase } = require('@ruvector/rvf-node');
+
+// Create a store
+const db = RvfDatabase.create('vectors.rvf', {
+ dimension: 384,
+ metric: 'cosine',
+});
+
+// Insert vectors
+const vectors = new Float32Array(384 * 2); // 2 vectors, 384 dims each
+vectors.fill(0.1);
+db.ingestBatch(vectors, [1, 2]);
+
+// Query nearest neighbors
+const query = new Float32Array(384);
+query.fill(0.15);
+const results = db.query(query, 5);
+// [{ id: 1, distance: 0.002 }, { id: 2, distance: 0.002 }]
+
+db.close();
+```
+
+## API Reference
### Store Lifecycle
```typescript
-import { RvfDatabase } from '@ruvector/rvf';
+// Create a new store
+const db = RvfDatabase.create(path: string, options: RvfOptions);
-// Create
-const db = RvfDatabase.create('/tmp/store.rvf', { dimension: 128, metric: 'cosine' });
+// Open existing store (read-write, acquires writer lock)
+const db = RvfDatabase.open(path: string);
-// Open for read-write
-const db = RvfDatabase.open('/tmp/store.rvf');
+// Open read-only (no lock, concurrent readers allowed)
+const db = RvfDatabase.openReadonly(path: string);
-// Open read-only (no lock)
-const db = RvfDatabase.openReadonly('/tmp/store.rvf');
-
-// Close
+// Close and flush
db.close();
```
-### Vector Operations
+**RvfOptions:**
+
+| Field | Type | Default | Description |
+|-------|------|---------|-------------|
+| `dimension` | `number` | required | Vector dimensionality |
+| `metric` | `string` | `"l2"` | `"l2"`, `"cosine"`, or `"inner_product"` |
+| `profile` | `number` | `0` | Hardware profile: 0=Generic, 1=Core, 2=Hot, 3=Full |
+| `signing` | `boolean` | `false` | Enable segment signing |
+| `m` | `number` | `16` | HNSW M parameter (neighbor count) |
+| `efConstruction` | `number` | `200` | HNSW index build quality |
+
+### Ingest Vectors
```typescript
-// Ingest vectors
-const vectors = new Float32Array([1,0,0,0, 0,1,0,0]);
-const result = db.ingestBatch(vectors, [0, 1]);
-// { accepted: 2, rejected: 0, epoch: 1 }
+const result = db.ingestBatch(
+ vectors: Float32Array, // flat array of n * dimension floats
+ ids: number[], // vector IDs
+ metadata?: RvfMetadataEntry[] // optional metadata per vector
+);
+// Returns: { accepted: number, rejected: number, epoch: number }
+```
-// Query
-const results = db.query(new Float32Array([1,0,0,0]), 5);
-// [{ id: 0, distance: 0.0 }, { id: 1, distance: 1.414 }]
+**Metadata entry format:**
-// Query with filter
-const results = db.query(new Float32Array([1,0,0,0]), 5, {
- filter: '{"op":"eq","fieldId":0,"valueType":"string","value":"cat_a"}'
+```typescript
+{ fieldId: 0, valueType: 'string', value: 'category_a' }
+{ fieldId: 1, valueType: 'f64', value: '0.95' }
+{ fieldId: 2, valueType: 'u64', value: '42' }
+```
+
+### Query
+
+```typescript
+const results = db.query(
+ vector: Float32Array, // query vector
+ k: number, // number of neighbors
+ options?: RvfQueryOptions // optional search parameters
+);
+// Returns: [{ id: number, distance: number }, ...]
+```
+
+**RvfQueryOptions:**
+
+| Field | Type | Default | Description |
+|-------|------|---------|-------------|
+| `efSearch` | `number` | `100` | HNSW search quality (higher = better recall, slower) |
+| `filter` | `string` | — | Filter expression as JSON string |
+| `timeoutMs` | `number` | `0` | Query timeout in ms (0 = no timeout) |
+
+### Filter Expressions
+
+Filters are passed as JSON strings. All leaf filters require `fieldId`, `valueType`, and `value`:
+
+```javascript
+// Equality
+db.query(vec, 10, {
+ filter: '{"op":"eq","fieldId":0,"valueType":"string","value":"science"}'
});
+// Range
+db.query(vec, 10, {
+ filter: '{"op":"range","fieldId":1,"valueType":"f64","low":"0.5","high":"1.0"}'
+});
+
+// In-set
+db.query(vec, 10, {
+ filter: '{"op":"in","fieldId":0,"valueType":"u64","values":["1","2","5"]}'
+});
+
+// Boolean combinations
+db.query(vec, 10, {
+ filter: JSON.stringify({
+ op: 'and',
+ children: [
+ { op: 'eq', fieldId: 0, valueType: 'string', value: 'science' },
+ { op: 'gt', fieldId: 1, valueType: 'f64', value: '0.8' }
+ ]
+ })
+});
+
+// Negation
+db.query(vec, 10, {
+ filter: '{"op":"not","child":{"op":"eq","fieldId":0,"valueType":"string","value":"spam"}}'
+});
+```
+
+**Supported operators:** `eq`, `ne`, `lt`, `le`, `gt`, `ge`, `in`, `range`, `and`, `or`, `not`
+
+**Supported value types:** `u64`, `i64`, `f64`, `string`, `bool`
+
+### Delete
+
+```typescript
// Delete by ID
-db.delete([0, 1]);
+const result = db.delete([1, 2, 3]);
+// Returns: { deleted: number, epoch: number }
// Delete by filter
-db.deleteByFilter('{"op":"gt","fieldId":1,"valueType":"f64","value":"0.5"}');
+const result = db.deleteByFilter(
+ '{"op":"gt","fieldId":1,"valueType":"f64","value":"0.9"}'
+);
+```
-// Compact
-const compaction = db.compact();
-// { segmentsCompacted: 2, bytesReclaimed: 4096, epoch: 3 }
+### Compact
-// Status
+Reclaims space from deleted vectors:
+
+```typescript
+const result = db.compact();
+// Returns: { segmentsCompacted: number, bytesReclaimed: number, epoch: number }
+```
+
+### Status
+
+```typescript
const status = db.status();
-// { totalVectors, totalSegments, fileSize, currentEpoch, ... }
+// {
+// totalVectors: number,
+// totalSegments: number,
+// fileSize: number,
+// currentEpoch: number,
+// profileId: number,
+// compactionState: 'idle' | 'running' | 'emergency',
+// deadSpaceRatio: number,
+// readOnly: boolean
+// }
```
-### Lineage
+### Lineage & Derivation
+
+RVF tracks parent/child relationships with cryptographic hashes:
```typescript
-// Get file identity
-const fileId = db.fileId(); // "a1b2c3d4..."
-const parentId = db.parentId(); // "00000000..." for root
-const depth = db.lineageDepth(); // 0 for root
+db.fileId(); // hex string — unique file identifier
+db.parentId(); // hex string — parent's ID (zeros if root)
+db.lineageDepth(); // 0 for root files
-// Derive a child store
-const child = db.derive('/tmp/child.rvf', { dimension: 128 });
+// Derive a child store (inherits dimensions and options)
+const child = db.derive('/tmp/child.rvf');
child.lineageDepth(); // 1
+child.parentId(); // matches parent's fileId()
```
-### Kernel / eBPF Embedding
+### Kernel & eBPF Embedding
+
+Embed compute segments alongside vector data:
```typescript
-// Embed a kernel image
-const kernelImage = Buffer.from(fs.readFileSync('kernel.bin'));
-const segId = db.embedKernel(
- 1, // arch: x86_64
- 0, // kernel_type
- 0, // flags
- kernelImage, // image bytes
- 9000, // api_port
- 'root=/dev/sda' // cmdline (optional)
+// Embed a Linux microkernel
+db.embedKernel(
+ 1, // arch: 0=x86_64, 1=aarch64
+ 0, // kernel type
+ 0, // flags
+ Buffer.from(kernelImage), // kernel binary
+ 8080, // API port
+ 'console=ttyS0 quiet' // kernel cmdline (optional)
);
// Extract kernel
const kernel = db.extractKernel();
if (kernel) {
- // kernel.header: Buffer (128-byte KernelHeader)
- // kernel.image: Buffer (kernel image bytes)
+ console.log(kernel.header); // Buffer: 128-byte KernelHeader
+ console.log(kernel.image); // Buffer: kernel image bytes
}
-// Embed an eBPF program
-const ebpfCode = Buffer.from(fs.readFileSync('program.o'));
-db.embedEbpf(1, 2, 128, ebpfCode);
+// Embed an eBPF XDP program
+db.embedEbpf(
+ 1, // program type (XDP distance)
+ 2, // attach type (XDP ingress)
+ 384, // max vector dimension
+ Buffer.from(bytecode), // BPF ELF object
+ Buffer.from(btf) // optional BTF section
+);
// Extract eBPF
const ebpf = db.extractEbpf();
if (ebpf) {
- // ebpf.header: Buffer (64-byte EbpfHeader)
- // ebpf.payload: Buffer (bytecode + optional BTF)
+ console.log(ebpf.header); // Buffer: 64-byte EbpfHeader
+ console.log(ebpf.payload); // Buffer: bytecode + BTF
}
```
### Segment Inspection
```typescript
-// List all segments
const segments = db.segments();
-// [{ id: 1, offset: 0, payloadLength: 4096, segType: "vec" }, ...]
+// [{ id: 1, offset: 0, payloadLength: 4096, segType: 'manifest' },
+// { id: 2, offset: 4160, payloadLength: 51200, segType: 'vec' },
+// { id: 3, offset: 55424, payloadLength: 12288, segType: 'index' }]
-// Get dimension
-const dim = db.dimension(); // 128
+db.dimension(); // 384
```
+## Build from Source
+
+```bash
+# Prerequisites: Rust 1.87+, Node.js 18+
+cd crates/rvf/rvf-node
+npm install
+npm run build
+```
+
+## Related Packages
+
+| Package | Description |
+|---------|-------------|
+| [`@ruvector/rvf`](https://www.npmjs.com/package/@ruvector/rvf) | Unified TypeScript SDK |
+| [`@ruvector/rvf-wasm`](https://www.npmjs.com/package/@ruvector/rvf-wasm) | Browser WASM package |
+| [`@ruvector/rvf-mcp-server`](https://www.npmjs.com/package/@ruvector/rvf-mcp-server) | MCP server for AI agents |
+| [`rvf-runtime`](https://crates.io/crates/rvf-runtime) | Rust runtime (powers this package) |
+
## License
MIT OR Apache-2.0
diff --git a/examples/rvf/Cargo.lock b/examples/rvf/Cargo.lock
index e72bc7caf..5c7fa6ea0 100644
--- a/examples/rvf/Cargo.lock
+++ b/examples/rvf/Cargo.lock
@@ -441,7 +441,7 @@ dependencies = [
[[package]]
name = "rvf-crypto"
-version = "0.1.0"
+version = "0.2.0"
dependencies = [
"ed25519-dalek",
"rvf-types",
@@ -517,14 +517,14 @@ dependencies = [
[[package]]
name = "rvf-runtime"
-version = "0.1.0"
+version = "0.2.0"
dependencies = [
"rvf-types",
]
[[package]]
name = "rvf-types"
-version = "0.1.0"
+version = "0.2.0"
[[package]]
name = "rvf-wire"
diff --git a/examples/rvf/README.md b/examples/rvf/README.md
index 24aac4f56..421097843 100644
--- a/examples/rvf/README.md
+++ b/examples/rvf/README.md
@@ -353,12 +353,46 @@ cargo run --example network_interfaces # Network OS telemetry (60 interfaces)
|---------|---------|-------------|
| DNA-Style Lineage | (API) | Every derived file records its parent's hash and derivation type |
| Domain Profiles | (API) | `.rvdna`, `.rvtext`, `.rvgraph`, `.rvvis` — same format, domain-specific hints |
-| Computational Container | (API) | Embed a WASM microkernel, eBPF program, or bootable unikernel |
+| Computational Container | `claude_code_appliance` | Embed a WASM microkernel, eBPF program, or bootable unikernel |
+| Self-Booting Appliance | `claude_code_appliance` | 5.1 MB `.rvf` — boots Linux, serves queries, runs Claude Code |
| Import (JSON/CSV/NumPy) | (API) | Load embeddings from `.json`, `.csv`, or `.npy` files via `rvf-import` or `rvf ingest` CLI |
| Unified CLI | `rvf` | 9 subcommands: create, ingest, query, delete, status, inspect, compact, derive, serve |
| Compaction | (API) | Garbage-collect tombstoned vectors and reclaim disk space |
| Batch Delete | (API) | Delete vectors by ID with tombstone markers |
+### Self-Booting RVF — Claude Code Appliance
+
+The `claude_code_appliance` example builds a complete self-booting AI development environment as a single `.rvf` file. It uses real infrastructure — a Docker-built Linux kernel, Ed25519 SSH keys, a BPF C socket filter, and a cryptographic witness chain.
+
+```bash
+cd examples/rvf
+cargo run --example claude_code_appliance
+```
+
+**What it produces** (5.1 MB file):
+
+```
+claude_code_appliance.rvf
+ ├── KERNEL_SEG Linux 6.8.12 bzImage (5.2 MB, x86_64)
+ ├── EBPF_SEG Socket filter — allows ports 2222, 8080 only
+ ├── VEC_SEG 20 package embeddings (128-dim)
+ ├── INDEX_SEG HNSW graph for package search
+ ├── WITNESS_SEG 6-entry tamper-evident audit trail
+ ├── CRYPTO_SEG 3 Ed25519 SSH user keys (root, deploy, claude)
+ ├── MANIFEST_SEG 4 KB root with segment directory
+ └── Snapshot v1 derived image with lineage tracking
+```
+
+**Boot and connect:**
+
+```bash
+rvf launch claude_code_appliance.rvf # Boot on QEMU/Firecracker
+ssh -p 2222 deploy@localhost # SSH in
+curl -s localhost:8080/query -d '{"vector":[0.1,...], "k":5}'
+```
+
+Final file: **5.1 MB single `.rvf`** — boots Linux, serves queries, runs Claude Code.
+
diff --git a/examples/rvf/output/claude_code_appliance.rvf b/examples/rvf/output/claude_code_appliance.rvf
index 6d5080682737ba9cd2fa9e090ca1e84fe1ab13ea..a8f8748f1bf39581157480bbd25107fcc49da12c 100644
GIT binary patch
literal 5260093
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