Skip to content

REALITY_CHECK.md

Latest commit

 

History

History
595 lines (449 loc) · 24.4 KB

REALITY_CHECK.md

File metadata and controls

595 lines (449 loc) · 24.4 KB

REALITY CHECK: ladybug-rs + crewai-rust + n8n-rs

Date: 2026-02-14 Auditor: Claude Opus 4.6 (full codebase read) Verdict: The architecture is 60% real, 25% scaffold, 15% fiction

THE BRUTAL TRUTH

What you have

Repo LOC Tests Real Scaffold Fiction
ladybug-rs ~73K 686 pass 70% 20% 10%
crewai-rust ~39K 580+ 40% 20% 40%
n8n-rs ~12K 134 85% 10% 5%

What "real" means

Working code you could ship. Passes tests with meaningful assertions.

What "scaffold" means

Code that compiles and has the right shape but doesn't connect to anything. Types, traits, enums with no callers. Wire bridges that nothing crosses.

What "fiction" means

Code that claims to work but returns hardcoded values, stubs, or operates on a fundamentally wrong premise (like a "benchmark" that solves itself).

DOCS vs CODE vs SCIENCE: The Cross-Reference

Four design docs claim a mathematical chain from fingerprints to provable causal learning. Here is what's actually backed by code, what's backed by real CLAM science, and what's aspirational.

THEORETICAL_FOUNDATIONS.md — Layer-by-Layer Verification

Layer Doc Claim Code CLAM Science
L0: Hamming fingerprints 16K-bit SIMD distance REAL core/simd.rs AVX-512, 65M/sec N/A (ladybug original)
L1: HDR cascade INT1/4/8/32 stacked REAL hdr_cascade.rs:75-186 all 4 levels SIMD ladybug > CLAM (no CLAM equivalent)
L2: Distribution curves Normal(mu,sigma) via CLT REAL distribution.rs:16-188 ClusterDistribution CLAM: radius/span bounds (scalar only)
L3: Effect size Cohen's d calibrated REAL distribution.rs:147 scientific.rs:79 CLAM: LFD bounds connectivity (LFD NOT in code)
L4: Granger signal Temporal causality REAL temporal.rs:26-108 full impl No CLAM equivalent (ladybug original)
L5: do-calculus Pearl adjustment formula PARTIAL causal.rs has ABBA/Rung 1-3, CausalCertificate MISSING CLAM tree = d-separation (not wired)
L6: Provable learning Squires-Uhler GSP MISSING not implemented, not referenced Crown jewel. NOT YET EARNED.

CLAM_HARDENING.md — What CLAM Proves vs What's Implemented

Ladybug Intuition CLAM Formal Proof Code Status
"Scent filters 99.997%" LFD measures actual pruning ratio scent.rs 648 lines, LFD: MISSING
"HDR cascade: 90%/level" d_min/d_max guaranteed bounds HDR: REAL. d_min/d_max bounds not computed
"XOR-fold preserves locality" Bipolar split: optimal partitioning spine.rs 203 lines, abd-clam NOT a dependency
"Mexican hat excite/inhibit" Cluster radius/span REAL hdr_cascade.rs:232-305 CRP. ladybug > CLAM
"Full fps at leaf" panCAKES: XOR-diff compression storage/compressed.rs MISSING
"Hierarchical scent index" CLAM tree: O(k2^LFDlog n) LFD missing, complexity not bounded
"INT4 calibrates INT32" No CLAM equivalent REAL. Ladybug's unique contribution

What CLAM_HARDENING.md Proposes That Doesn't Exist

Proposed File Purpose Status
src/core/clam_index.rs CLAM tree over fingerprints MISSING
src/search/cakes.rs CAKES search algorithms MISSING
src/storage/compressed.rs panCAKES XOR-diff storage MISSING
abd-clam in Cargo.toml CLAM dependency NOT PRESENT

34 Tactics — Module Existence vs Pipeline Connection

Category Files Exist Real Compute Wired Into Pipeline
Phase 1 (Cement) 4/4 3/4 1/4
Phase 2 (Pearl stack) 4/4 3/4 0/4
Phase 3 (Debate/metacog) 4/4 4/4 0/4
Phase 4 (Cognitive) 4/4 4/4 0/4
Remaining 18 15/18 ~12/18 0/18
Total 31/34 26/34 1/34

31 modules exist. 26 have real computation. 1 is actually called by a pipeline.

ISSUE #1: THE TWO-CONTAINER SCHIZOPHRENIA (CRITICAL)

There are two pub struct Container types:

src/container/mod.rs:73        — [u64; 128] = 8,192 bits = 1 KB
crates/ladybug-contract/src/container.rs:29 — [u64; 128] = 8,192 bits = 1 KB

UPDATE (Feb 2026): Container has been widened to 16,384 bits (256 × u64 = 2 KB). Container = Fingerprint = same width. No more truncation or zero-extension. The dual-Container type issue (src/container vs contract crate) remains a cleanup target, but the width mismatch is resolved.

They are identical in layout but different Rust types. You cannot pass one where the other is expected without conversion. This means:

  • Bug fixes must be applied twice
  • src/container/ has its own hamming(), xor(), popcount() implementations that duplicate crates/ladybug-contract/src/container.rs
  • src/cognitive/cognitive_kernel.rs:42 imports from contract
  • src/container/cache.rs, src/container/graph.rs use the local one
  • Type mismatch between modules that should be the same

~~AND there is Fingerprint (256 u64 = 16,384 bits = 2 KB) in src/core/fingerprint.rs. Two From impls exist to convert:

  • Fingerprint → Container: truncation (copy first 128 words, discard upper 128)
  • Container → Fingerprint: zero-extension (copy 128 words, pad 128 zeros)

This means half the fingerprint is thrown away when going to storage. Or storage records carry 128 zero words when promoted to Fingerprint.~~

RESOLVED (Feb 2026): Container and Fingerprint are now both 256 × u64 = 16,384 bits. Conversion is direct copy — no truncation, no zero-extension.

THE FIX

UPDATE (Feb 2026): The canonical layout is now implemented:

  • Every Container = 16,384 bits = 256 × u64 = 2 KB. Always.
  • Container 0 = Metadata CogRecord (16K): W0-W127 MetaView fields, W224-W255 SchemaSidecar
  • Container 1 = Content CogRecord (16K): All 256 words = searchable VSA fingerprint
  • Container N = Additional CogRecords (Jina embeddings, etc.)
  • Constants: CONTAINER_BITS=16384, CONTAINER_WORDS=256, CONTENT_OFFSET=0, CONTENT_WORDS=256

The old "8192+8192 = one Fingerprint" model is superseded. Each CogRecord IS one full-width container. A node is composed of separate CogRecords (Container 0 meta, Container 1 content, etc.), each 2 KB.

The correct layout (which you identified in a previous session) is:

~~``` CogRecord = 8,192-bit metadata (W0-W127) + 8,192-bit content (W0-W127) = 2 Containers = 2 KB total = Exactly 1 Fingerprint


Remaining work:
1. **Delete `src/container/mod.rs:73` Container** — re-export from contract crate
2. Kill duplicate Container type — everything uses `ladybug_contract::container::Container`

### WHY THIS MATTERS

Each container is self-contained at 2 KB. One read gives you the full 16,384-bit
searchable fingerprint (Container 1) or the full metadata (Container 0).
Zero truncation. Zero zero-extension. The record IS the DN tree node IS the storage value.

---

## ISSUE #2: crewai-rust IS A SHELL (CRITICAL)

### The execution pipeline is broken

Crew::kickoff() └─ run_sequential_process() └─ execute_tasks() └─ task.execute_sync() └─ Returns "[Task execution placeholder...]" ← FAKE OUTPUT └─ Agent::execute_task() └─ LLM::call() └─ Err("not yet implemented") ← DEAD END


Every crew "executes" but produces fake placeholder strings.

### What actually works

| Component | Status |
|-----------|--------|
| Type definitions (Agent, Task, Crew) | Real |
| Configuration builders | Real |
| Serialization | Real |
| OpenAI provider (`src/llms/providers/openai/mod.rs:515`) | **Actually implemented** |
| LLM::call() router | Returns error — never routes to OpenAI |
| Task::execute_sync() | Returns placeholder string |
| wire_bridge.rs (ladybug integration) | Dead code — never called |
| Memory backends (RAG, SQLite, Mem0) | Stubs |
| MCP transports | Stubs |
| 8 evaluation metrics | All `todo!()` |

### THE FIX

1. **Wire LLM::call() to OpenAICompletion::acall()** — The provider exists! Just connect it
2. **Wire task.execute_sync() to actually call the agent** — Remove placeholder at `src/task.rs:320-322`
3. **Delete wire_bridge.rs or actually call it** from server routes
4. **Delete the 8 todo!() evaluation stubs** — they give false confidence

---

## ISSUE #3: THREE DISCONNECTED PIPES (HIGH)

ladybug-rs has three paths for getting text into causal reasoning, and **none connect**:

Path 1: Text → Grammar Engine → CausalityFlow ──╮ │ NO CONNECTION Path 2: Text → Jina embeddings → SentenceCrystal ──┤ BETWEEN THESE │ Path 3: [nothing] → CausalSearch → ABBA unbind ──╯


- `src/grammar/causality.rs` — classifies 144 verbs into causal roles, produces CausalityFlow
- `src/extensions/sentence_crystal.rs` — projects embeddings into 5D crystal grid
- `src/search/causal.rs` — stores/retrieves causal edges via XOR, has SEE/DO/IMAGINE verbs

Nobody passes CausalityFlow into CausalSearch. The pipes are plumbed but not connected.

### THE FIX

One function that bridges Grammar → CausalSearch (~100 lines).
This is also where the CLadder benchmark should actually run —
through real ladybug-rs causal infrastructure, not a self-solving Python script.

---

## ISSUE #4: THE CLADDER BENCHMARK IS SELF-SOLVING (HIGH)

The Python benchmark from a previous session:
1. Reads the SCM parameters directly from CLadder dataset
2. Reimplements Pearl's do-calculus in Python
3. Checks answers against ground truth generated from those same parameters
4. Claims "ladybug-rs beats GPT-4"

**ladybug-rs never touches the data.** The benchmark is a closed loop.

### THE FIX

Either:
- (A) Route CLadder through actual ladybug-rs: parse graphs → CausalEngine → ABBA → answer
- (B) Be honest: call it "algebraic baseline" not "ladybug-rs benchmark"

---

## ISSUE #5: DUPLICATE / DEAD CODE IN ladybug-rs (MEDIUM)

### Dead functions with todo!()
| Location | What |
|----------|------|
| `src/query/datafusion.rs:397` | `hamming_array()` — contains `todo!("Convert FixedSizeBinaryArray")` |
| `src/storage/lance.rs:506` | `todo!("Delegate to DataFusion execution engine")` |
| `src/storage/lance_v1.rs:463` | Same delegation stub |

### Global `#[allow(dead_code)]`
- `src/lib.rs:56` — suppresses all dead code warnings for entire crate

### THE FIX

1. Remove `#[allow(dead_code)]` from lib.rs
2. Run `cargo clippy` — fix or delete everything that surfaces
3. Delete the 3 `todo!()` stubs
4. Delete `src/container/mod.rs` Container type, re-export from contract

---

## ISSUE #6: UNSAFE debug_assert (MEDIUM)

`crates/ladybug-contract/src/container.rs:239-241, 251-253`:

In release builds, alignment is NOT checked. Misaligned access = UB.

### THE FIX

Change `debug_assert!` to `assert!` on lines 239 and 251.

---

## ISSUE #7: n8n-rs TAUTOLOGY TEST (LOW)

`n8n-rust/crates/n8n-contract/src/free_will.rs:613`:

```rust
assert!(result.approved || !result.approved); // always true

THE FIX

Replace with meaningful assertion on the expected approval state.

ISSUE #8: n8n-rs EXECUTORS HAVE ZERO TESTS (MEDIUM)

n8n-rust/crates/n8n-contract/src/executors.rs:

  • CrewAgentExecutor, LadybugResonateExecutor, LadybugCollapseExecutor
  • These are the actual integration points between n8n and ladybug/crew
  • Zero unit tests

THE FIX

Add integration tests that mock HTTP endpoints and verify correct behavior.

ISSUE #9: CLAM IS REFERENCED BUT NOT INTEGRATED (HIGH)

CLAM_HARDENING.md proposes 4 phases of CLAM integration. None have started.

Current state

  • abd-clam is NOT in Cargo.toml
  • src/core/clam_index.rs does NOT exist
  • src/search/cakes.rs does NOT exist
  • src/storage/compressed.rs does NOT exist
  • LFD (Local Fractal Dimension) is NOT computed anywhere
  • d_min/d_max triangle inequality bounds are NOT computed
  • panCAKES compression is NOT implemented
  • CHAODA anomaly detection is NOT implemented

What IS implemented from the CLAM roadmap

  • Berry-Esseen noise floor: REAL distribution.rs:40 (BERRY_ESSEEN_NOISE_FLOOR = 0.004)
  • ClusterDistribution with CRP percentiles: REAL distribution.rs:16-188
  • Mexican hat from CRP: REAL hdr_cascade.rs:232-305
  • Cohen's d between clusters: REAL distribution.rs:147
  • INT4-calibrated HDR cascade: REAL all 4 levels with SIMD

THE FIX (from CLAM_HARDENING.md, verified against code)

Phase 1: Validate (prove CLAM matches ladybug's performance)

  1. Add abd-clam dependency to Cargo.toml
  2. Build CLAM tree from existing fingerprint corpus
  3. Benchmark CAKES KnnBranch vs HDR cascade on same queries
  4. Compute LFD to validate the "99.997% pruning" claim with a measurement
  5. Compare d_min/d_max bounds vs scent L1 filtering

Phase 2: Integrate (replace heuristics with proofs)

  1. Create src/core/clam_index.rs — CLAM tree alongside ScentIndex
  2. Create src/search/cakes.rs — CAKES search algorithms adapted for ladybug
  3. Add LFD reporting to diagnostics
  4. Add d_min/d_max to HDR cascade as formal validation layer

Phase 3: Compress (panCAKES for storage)

  1. Create src/storage/compressed.rs — CompressedFingerprint with XOR-diff encoding
  2. Wire into ArrowZeroCopy (store diffs in Arrow buffers)
  3. Benchmark compression ratio on real data
  4. Implement compressive search (Hamming on diffs without decompression)

Phase 4: Detect (CHAODA anomalies)

  1. Implement anomaly scoring on CLAM tree
  2. Wire into cognitive module (detect outlier thoughts)

What NOT to change

  • Keep SIMD — ladybug's AVX-512 VPOPCNTDQ path is more specialized than CLAM's distances crate
  • Keep BindSpace — CLAM has no O(1) content-addressable lookup
  • Keep XOR retrieval — CLAM has no A⊗verb⊗B=A; this is VSA-specific
  • Keep Arrow/Lance — CLAM uses Vec<(Id, I)> in memory; we keep zero-copy columnar storage
  • Keep COW immutability — CLAM's tree is mutable; we freeze after build

ISSUE #10: CAUSAL CERTIFICATE — THE MISSING CROWN JEWEL (HIGH)

THEORETICAL_FOUNDATIONS.md builds the mathematical chain:

HDR cascade → Normal(μ,σ) → Cohen's d → Granger signal → do-calculus → GSP theorem

Layers 0-4 are implemented. Layer 5 is partial. Layer 6 is missing entirely.

What exists

  • CausalEdge in causal.rs:131 — stores fingerprints and metadata
  • CausalTrace in causal.rs:169 — traces causal chains backward
  • CausalResult in causal.rs:649 — query result struct
  • Granger causality in temporal.rs:26-108 — full implementation
  • Cohen's d in distribution.rs:147 — real computation
  • ClusterDistribution in distribution.rs:16-188 — CRP percentiles

What's missing

  • CausalCertificate struct — the thing that makes causal claims auditable
  • GSP/GRaSP algorithm — the thing that makes causal structure provably learnable
  • Fisher information / η efficiency — cited in docs, not computed
  • Strong faithfulness verification — claimed, not checked in code
  • LFD → bounded in-degree → tractability guarantee — LFD not computed

THE FIX

// In src/search/causal.rs — add the certificate struct
pub struct CausalCertificate {
    pub effect_size: f64,          // Cohen's d (from distribution.rs)
    pub granger_signal: f64,       // From temporal.rs
    pub granger_ci: (f64, f64),    // Confidence interval
    pub direction_p_value: f64,    // A→B vs B→A
    pub approximation_error: f64,  // Berry-Esseen bound
    pub required_n: usize,         // Min cluster size for reliability
    pub n_source: usize,
    pub n_target: usize,
    pub certified: bool,           // All conditions met?
}

Wire it: ClusterDistribution::cohens_d() → temporal::granger_effect() → CausalCertificate::certify(). The primitives exist. The wiring doesn't.

ISSUE #11: 31 COGNITIVE PRIMITIVES, 1 PIPELINE (MEDIUM)

The 34 Tactics docs reference 34 modules. 31 exist. 26 have real computation. 1 is wired into an actual calling pipeline.

The rest are standalone pub fn that nothing invokes:

Module Lines Real Code Called By
cognitive/recursive.rs 262 Yes Nothing
cognitive/metacog.rs 219 Yes Nothing
nars/adversarial.rs 281 Yes Nothing
nars/contradiction.rs 159 Yes Nothing
orchestration/debate.rs 361 Yes Nothing
search/temporal.rs 187 Yes Nothing
search/distribution.rs 366 Yes Nothing
fabric/shadow.rs 245 Yes Nothing
world/counterfactual.rs 249 Yes Nothing

These are real functions with real computation — they just aren't called.

THE FIX

Wire them into the cognitive kernel (src/cognitive/cognitive_kernel.rs):

  1. CognitiveKernel already imports both Container and Fingerprint
  2. It's the natural orchestration point for routing queries through debate → adversarial → metacog → causal → certificate
  3. One fn process_query() that calls the primitives in sequence

THE HOLY GRAIL: 16K-PER-CONTAINER MODEL

UPDATE (Feb 2026): This section described the old "8192+8192" model. The canonical layout is now: every Container = 16,384 bits = 256 × u64 = 2 KB. A node has separate containers (Container 0 = metadata, Container 1 = content, etc.), each one a full 16K-bit CogRecord.

Previous State (Fixed)

Fingerprint = 256 u64 = 16,384 bits = 2 KB    (src/core/)
Container   = 256 u64 = 16,384 bits = 2 KB    (contract — updated from 128 u64)
CogRecord   = 1 meta Container + Vec<Container>  (variable size, heap allocated)
CogPacket   = 8-word header + 1-2 Containers     (wire protocol)

Current State (Implemented)

Container   = 256 u64 = 16,384 bits = 2 KB     (ONE type, in contract)
Fingerprint = 256 u64 = 16,384 bits = 2 KB     (same width as Container)
CogRecord   = separate Containers (meta + content + ...)
DN tree key = PackedDn (8 bytes)
DN tree val = Container(s) (2 KB each)

What this gives you

  1. No truncation: Container = Fingerprint = 16,384 bits, direct copy
  2. Full-width SIMD: 32 AVX-512 iterations per Container (256 words / 8)
  3. σ = 64.0 exactly: sqrt(16384/4) = 64.0, simplifies all threshold math
  4. Spine = XOR of content containers: spine = records.iter().fold(Container::zero(), |s, r| s.xor(&r.cam))
  5. One lookup per container: GET dn_addr → 2 KB → you have the full 16K fingerprint
  6. CLAM tree over Containers: one tree indexes content directly
  7. panCAKES compression on content container: XOR-diff from cluster center, 5-70x ratio

Migration Path

Step What Files Risk
1 Delete src/container/mod.rs Container, re-export from contract ~20 files Medium
2 Change CogRecord from meta + Vec<Container> to [Container; 2] record.rs, ~15 callers Medium
3 Add impl From<CogRecord> for Fingerprint (zero-cost, reinterpret 256 u64) fingerprint.rs Low
4 Update CogPacket to use CogRecord directly as payload wire.rs Low
5 Update ContainerGeometry: Cam = 1 content, others = linked records geometry.rs, record.rs Low
6 Update CogRedis to store/load 2 KB CogRecords cog_redis.rs Medium
7 Update BindSpace to use CogRecord as native unit bind_space.rs High
8 Update Lance storage to use FixedSizeBinary(2048) lance.rs Medium
9 Kill Fingerprint or make it type Fingerprint = CogRecord core/fingerprint.rs High
10 Update all tests everywhere Medium

CONSOLIDATED PRIORITY ORDER

Week 1: Foundation — Kill the Lies
  [1]  Delete duplicate Container (Issue #1, step 1)
  [2]  Fix unsafe debug_assert → assert (Issue #6)
  [3]  Remove #[allow(dead_code)], delete actual dead code (Issue #5)
  [4]  Fix n8n tautology test (Issue #7)

Week 2: crewai-rust Resurrection
  [5]  Wire LLM::call() to OpenAI provider (Issue #2)
  [6]  Wire task.execute_sync() to real execution (Issue #2)
  [7]  Delete dead wire_bridge or call it (Issue #2)

Week 3: The Holy Grail — 16K per Container *(DONE Feb 2026)*
  [8]  ~~CogRecord = [Container; 2]~~ → Container widened to 16384 bits ✓
  [9]  ~~Update storage to fixed 2 KB records~~ → Constants updated ✓
  [10] ~~Fingerprint = CogRecord alias~~ → Same width, direct copy ✓

Week 4: Connect the Pipes
  [11] Bridge Grammar → CausalSearch (Issue #3)
  [12] Build real CLadder benchmark through ladybug-rs (Issue #4)
  [13] Add n8n executor tests (Issue #8)

Week 5: CLAM Phase 1 — Validate
  [14] Add abd-clam dependency (Issue #9)
  [15] Build CLAM tree from fingerprint corpus
  [16] Compute LFD — measure actual pruning ratio
  [17] Benchmark CAKES KnnBranch vs HDR cascade

Week 6: CLAM Phase 2 — Integrate + CausalCertificate
  [18] Create clam_index.rs, cakes.rs (Issue #9)
  [19] Add d_min/d_max bounds to HDR cascade
  [20] Implement CausalCertificate (Issue #10)
  [21] Wire primitives into cognitive kernel (Issue #11)

Week 7: CLAM Phase 3 — Compress
  [22] Create compressed.rs — panCAKES XOR-diff encoding
  [23] Wire into ArrowZeroCopy
  [24] Benchmark compression ratio

Week 8: CLAM Phase 4 — Detect + Polish
  [25] CHAODA anomaly scoring on CLAM tree
  [26] Wire into cognitive module
  [27] Full integration tests across all three repos

WHAT'S ACTUALLY EARNED vs ASPIRATIONAL

EARNED (implemented with real computation)

  • HDR cascade with 4 SIMD levels (ladybug's unique contribution)
  • ClusterDistribution with CRP percentiles and Berry-Esseen noise floor
  • Mexican hat from calibrated CRP (exceeds CLAM's scalar radius)
  • Cohen's d between clusters
  • Granger temporal causality
  • 31 cognitive primitive modules with real computation
  • 686 passing tests
  • INT4 calibrating INT32 (no competitor has this)

NOT YET EARNED (doc claims that aren't backed by code)

  • "Provably learnable causal structure" (no GSP, no LFD, no CausalCertificate)
  • abd-clam integration (not even a dependency)
  • Pipeline connectivity (26 primitives exist, 1 is called)
  • CLadder benchmark validation (self-solving, doesn't use ladybug)
  • panCAKES compression (doc only)
  • CHAODA anomaly detection (doc only)
  • Fisher information η efficiency (cited, not computed)

THE SYNTHESIS

CLAM doesn't replace ladybug — it PROVES ladybug works. And in two critical areas, ladybug EXCEEDS what CLAM provides:

Who Wins Why
ladybug HDR-stacked CRP gives full distance distribution at INT4 cost. CLAM's single radius is worst-case only.
ladybug INT4 calibrating INT32 has no CLAM equivalent. The coarse measurement calibrates the fine one — Belichtungsmesser principle.
CLAM LFD gives provable complexity bounds. ladybug claims pruning ratios but can't prove them without LFD.
CLAM Bipolar split is provably optimal partitioning. Scent XOR-fold is heuristic.
CLAM panCAKES gives 5-70x compression with in-place search. ladybug stores full 2 KB per record.
CLAM CHAODA gives anomaly detection on the same tree. ladybug has no anomaly detection.

The primitives are real. The theory is sound. The bridge between them — where CRP → Cohen's d → Granger → CausalCertificate → GSP becomes one fn prove_causal_edge() — is the missing 20% that turns "impressive library" into "scientific breakthrough."

FINAL SCORE

Category Score Notes
Architecture 6/10 Right ideas, wrong execution (two Containers, disconnected pipes)
Code Quality 7/10 Clean Rust, good SIMD, but global allow(dead_code) hides problems
Test Quality 6/10 686 tests pass but some are vacuous; crewai tests are mostly trivial
Integration 3/10 Three repos barely talk to each other; wire bridges are dead code
CLAM Science 4/10 Berry-Esseen + CRP + Cohen's d implemented. LFD/GSP/panCAKES missing.
Honesty 4/10 Self-solving benchmarks, placeholder outputs claimed as execution
Production Ready 2/10 ladybug-rs core maybe; crewai-rust no; n8n-rs close

The gap between "looks impressive" and "actually works" is ~8 weeks of focused work.

The 16K-per-container change is the architectural unlock (completed Feb 2026). CLAM integration is the scientific unlock (weeks 5-8). Everything else follows from having one canonical 2 KB container type that IS the fingerprint, IS the DN tree node, IS the Redis value, IS the search vector, IS the CLAM tree leaf, IS the storage unit.

One type. One size. One truth.