Release Notes

v0.6.13 — Adaptive HNSW: Tiered Dimensional Search

2026-04-17

The HNSW vector store now adapts to the data it stores. A corpus probe analyzes the dimensional variance spectrum, tree calculus triage classifies the structure (Atom/Sequence/Branch), and EML computes tier parameters. Structured data gets multi-index tiered search; uniform data stays on standard flat HNSW. The system decides automatically.

The headline number

5000 vectors, 128 dims, k=10, clustered embeddings (20 clusters):

1.61x faster mean, 1.54x faster p99, +10% recall. The tiered search is both faster and higher recall because the coarse 20-dim HNSW finds the right cluster cheaply while flat HNSW at ef=20 sometimes misses neighbors.

What's in the release

• TieredSearch — multi-index dimensional search in hnsw_store.rs. Separate HNSW indexes at coarse/medium resolution, linear fine re-rank. cosine_partial for subset-dimension cosine similarity.

• Corpus probe — analyzes per-dimension variance, computes spectral steepness and variance knee. Runs once at build time (~1ms).

• Tree calculus triage — classifies spectrum as Atom (flat → skip tiering), Sequence (gradual → moderate tiering), or Branch (sharp → aggressive tiering). Follows the dual-substrate pattern from treecalc.rs: tree calculus for structural dispatch, EML for continuous parameters.

• 2-head EML ef model — joint ef + recall prediction. Head 0 learns the ef→latency mapping, head 1 learns ef→recall. Recall is backfilled from periodic brute-force measurements. Score strategy balances both.

• HnswService EML integration — every search call now runs through the EML predict+record path. Adaptive ef, adaptive rebuild timing, and search telemetry feeding back into model training.

• ExoChain events — hnsw.eml.observe (per-search), hnsw.eml.recall (periodic measurement), hnsw.eml.trained (training cycle), hnsw.eml.triage (strategy decision). Full audit trail for training provenance.

• 4-phase benchmark harness — mirrors the attention benchmark protocol. Phase 1 (warmup), Phase 2 (learning), Phase 3 (4-arm A/B: control vs overhead vs adaptive vs tiered), Phase 4 (scalability sweep). Structured test data generator with clustered embeddings and exponentially decaying dimensional variance.

• Stability diagnostic (EML notebook) — diagnose_stability() probes numerical gradient sensitivity of the attention forward pass. Catches stiffness from exp(x) - ln(y) tree saturation that MSE curves miss.

Tests

76 tests across hnsw_eml (36), hnsw_service (23), hnsw_store (17).

Documentation

• /weftos/adaptive-hnsw — full architecture, API, benchmark, and when-it-doesn't-help guide
• .planning/development_notes/adaptive-hnsw-tiered-search.md — detailed development narrative including what didn't work and why

Mesh transport boot integration

The K6 mesh transport layer was fully implemented (3,543 lines, 133 tests) but never instantiated during kernel boot. Now wired in:

• Boot phase 5d: creates MeshRuntime, wires to A2A router, spawns transport listener (TCP default, WebSocket available)
• [kernel.mesh] config: enabled, transport, listen_addr, discovery (Kademlia DHT), seed_peers
• mesh feature: added to kernel defaults
• Mesh starts before cluster so cluster can use mesh for peer communication

Universal Topology Browser

Complete framework for navigating any data structure as an interactive, drillable topology graph:

• TopologySchema: composable YAML geometry declarations with IRI identity (Docker-config style layering). 9 geometry types: force, tree, layered, timeline, stream, grid, geo, radial, wardley.
• IRI-based entity identity: resolves the "Service" ambiguity — same word, different IRIs, different concepts in the graph.
• Rust layout engine: Reingold-Tilford tree + Barnes-Hut force + tree calculus triage dispatch + auto-detection heuristic.
• Graph slicer: pre-computed drill-down JSON. Top level: 28 packages. Double-click drills into modules with edges. Cross-package dependency aggregation. Portal counts for external connections.
• Schema inference: weaver topology infer generates schemas from existing graphs. weaver topology diff detects architectural drift.
• VOWL JSON export: WebVOWL-compatible 8-key format for the navigator.
• Navigator widget: SliceNavigator (drill-down + breadcrumbs) and VowlNavigator (VOWL visual notation). 24 Playwright E2E tests.
• Domain presets: software.yaml (14 node types), investigation.yaml (13 node types) with full IRIs and Schema.org mappings.

Code Intelligence

• Tree calculus + EML AST extractor: native Rust source extraction using triage dispatch for structural classification and EML for confidence/ complexity scoring. No tree-sitter dependency.
• clawft-lsp-extract crate: LSP-based semantic extraction from any language server (rust-analyzer, tsserver, pylsp, gopls). Spawns servers via JSON-RPC, queries documentSymbol, builds semantic graph.

Security

• Unified prompt injection defense: sanitize_llm_input() at all 7 LLM input paths. sanitize_schema_input() for schema builder agents.
• Sprint 17 security plan: MAESTRO-informed hardening roadmap.

CI/CD

• eml-core published to crates.io (v0.1.0) — unblocked entire pipeline
• cargo-workspaces replaces manual tiered publish scripts
• Tiered parallel publishing and release gate workflow

Symposium

17 artifacts in .planning/symposiums/ontology-navigator/ covering schema design, layout algorithms, graph nesting, navigator modes, tree calculus + EML dual substrate, ArcKit governance, RAMP assessment (7R with Ratify), AI framework validation, schema builder agents, and investigative instrument design.

---

v0.6.12 — Universal Topology Browser

2026-04-17

See v0.6.13 above — the topology browser work landed across v0.6.11-0.6.13. v0.6.12 was the first release with all crates successfully published to crates.io (eml-core unblocked the pipeline).

---

v0.6.11 — Vault Cultivation

2026-04-16

Ported weave-nn's Obsidian vault tooling to Rust as weaver vault: enrich (frontmatter), analyze (link graph), suggest (connections), auto-link (wikilinks), backlinks (backlink sections). CI fix: eml-core added to publish pipeline, Docker race eliminated via workflow_run trigger.

---

v0.6.10 — EML vs Baseline Attention (Measurement Release)

2026-04-15

Two things in this release. First, a saturation-safe tree (SafeTree) replaces the classical EmlTree path inside ToyEmlAttention — the Iteration-2 substrate work. Second — and this is the headline — a plain-affine BaselineAttention is added alongside, trained with the exact same gradient-free optimizer, so the EML substrate can be measured head-to-head against a float-only reference. Measurement is reported honestly.

The head-to-head number

At (d_model=4, d_k=2, seq_len=2, depth=3), 5000 trials × 3 rounds, same seed (measured 2026-04-15):

Gate (separate run, 15k trials): 7.3% reduction. EML convergence is noisy; baseline is consistent.

Under identical training budget and optimizer, plain affine attention reaches 76% MSE reduction where EML regresses slightly, runs 3.3× faster on forward pass, and uses 2.4× fewer parameters at this scale. What EML buys is weight-snapping interpretability, closed-form expressibility, and seamless integration with the rest of the WeftOS EML substrate — not convergence speed or latency.

The measurement is deliberately embedded in the release so the next decision (scale EML attention further, or pivot to hybrid / keep EML for scalar heuristics and use plain attention for sequence work) is grounded in numbers.

Also in this release

• NVIDIA Quantum roadmap doc for v0.7.x — /weftos/quantum-nvidia. Research delivered on NVIDIA's CUDA-Q + cuQuantum ecosystem. Main finding: the "Ising" page is an AI model for QPU builders, not a QUBO solver; cuDensityMat inside cuQuantum is the piece worth integrating. Deferred to v0.7.x after GUI ship. ADR-048 queued.

• SafeTree — new depth-N tree with |v| + c2 + 1 safety guard. Unblocks the saturation path that capped Iteration 1; EML's Iteration-1 bounded post-processor is removed.

• BaselineAttention — plain affine Q/K/V/out, same API as ToyEmlAttention, same coordinate-descent optimizer.

• compare_eml_vs_baseline — runs identical workload on both and returns an AttentionComparison struct. Primary artifact for the measurement work.

• Live demo mode toggle: /clawft_eml-notebook gains an "EML vs baseline" mode that runs both leg-by-leg in-browser and renders the comparison as a table. Previous "Iteration 0" and "Iteration 1" modes remain.

• Gate passes at the small reference shape.

Honest calls

• Single-param CD on a 352-param SafeTree plateaus at -4% to +8% reduction. The same optimizer hits 76% on a 148-param plain affine. Iteration 3 would try multi-param coordinated perturbation; the measurement shows this is needed to close the gap, not that SafeTree is fundamentally better.
• Default builds byte-identical to 0.6.9. Feature flag experimental-attention still gates the whole module.
• 13 attention tests + 4 new baseline tests + 40 existing — 57 total.

Highlights

• New SafeTree primitive: depth-N tree evaluating eml_safe(v·c0 + c1, |v| + c2 + 1) at each level. The |v| + c2 + 1 guard keeps the ln argument ≥ 1 always, so nested composition never hits the ln(MIN_POSITIVE) ≈ -744 → exp(20) = 4.85e8 saturation path that capped Iteration 1.
• Round-trip compatible with the browser demo's JSON export. SafeTree::from_json deserializes the same schema the live trainer at /clawft_eml-notebook produces.
• Gate PASS (5 of 5):
  • baseline 1.64 → final 1.52 = 7.3% MSE reduction on per-position-mean
  • p99 inference 1174 ns
  • serialization roundtrip + polynomial scaling green
• Q/K/V/softmax/out fields are now SafeTree. The train_end_to_end API is unchanged; callers get saturation-safe composition without code changes.

Deliberately narrower gate

SafeTree's level-0 affine scales with inputs × heads (~10× Iteration 1's EmlModel-backed budget). The gate uses (seq_len=2, d_model=4, d_k=2, depth=3) for sharp convergence signal; larger shapes ship via the Phase-4 scaling sweep.

What didn't change

• Forward pass interface, record, train_end_to_end, AttentionBenchmark
• 13 unit tests + 4-phase benchmark harness
• Default builds are byte-identical to 0.6.9
• Feature flag experimental-attention still gates the whole module

Iteration 3 scope

• Multi-param coordinated perturbation. Rust single-param CD plateaus at browser-scale shapes because each accepted perturbation changes output by ~1e-6 when sitting among thousands of parameters. Pattern search or small-batch gradient-free updates should unlock the same 90%+ reductions the TS port shows.
• Identity task remains information-theoretically bounded when d_k < d_model; revisit when raising capacity.

v0.6.9 — EML Attention, Iteration 1 (Experimental)

2026-04-15

End-to-end joint coordinate descent across all 5 sub-models of the toy attention block. Gate passes: 57.8% MSE reduction in 3 rounds on the reference shape, 5 of 5 criteria green. Identity task remains saturated — an Iteration-2 concern.

Highlights

• Joint CD across Q/K/V/softmax/out via train_end_to_end. Random-param random-perturbation trials with annealed step size, accepting candidates that reduce end-to-end MSE on a 16-sample subset.
• EmlModel params exposed (params_slice, params_slice_mut, mark_trained) so composed models can iterate across the union of flat parameter vectors.
• Small-random init (~±0.05) in the attention constructor avoids the all-zeros regime where the nested tree saturates downstream.
• Bounded forward pass wraps raw output in a soft-saturation squash — Inf/NaN MSE no longer possible under composition.
• Gate PASS: baseline 2.13 → final 0.90 at (seq_len=4, d_model=8, d_k=4, depth=3) = 57.8% reduction. Inference p99 holds at 2 µs (well under the 5 µs target).

What still doesn't work — Iteration 2 scope

The identity task does not converge in Iteration 1. The Rust EmlTree composition saturates when any nested eml(x, y) sees y ≤ 0 — the ln(MIN_POSITIVE) ≈ -744 output feeds into the next level's exp(20) ≈ 4.85e8 clamp, and single-param coordinate descent can't escape that regime because most heads saturate together. The TS browser port doesn't suffer this because it wraps the tree's y argument with |v| + c + 1 (always positive).

Iteration 2 will either:

• Swap the tree formulation to a saturation-safe shape
• Add a learnable output projection whose weights are separate from the EmlModel tree
• Move to multi-param coordinated perturbation (pattern search)

Live demo

/clawft_eml-notebook gains an Iteration-1 mode that runs the joint CD in-browser and reports the same baseline-vs-final MSE reduction the Rust gate does.

Compatibility

• Feature flag experimental-attention on eml-core unchanged; default builds are byte-identical to 0.6.8.
• 13 unit tests + 4-phase benchmark harness still pass.
• AttentionBenchmark struct gains phase2_baseline_mse and phase2_mse_reduction fields (additive; deserialization of prior JSONs still works via #[serde(default)] semantics on missing fields when reading 0.6.8-era benchmark artifacts).

v0.6.8 — EML Attention, Iteration 0 (Experimental)

2026-04-15

First step toward an EML-Transformer for WeftOS. Ships a toy-scale attention block composed of five EmlModel instances, a 4-phase benchmark harness for quantifying future iterations, and two live demos on the docs site. All additive behind experimental-attention; default builds unchanged.

Highlights

• ToyEmlAttention in eml-core: single-head attention block at d_model ≤ 32, seq_len ≤ 8, per-submodel depth 3-5. Five learned projections (Q/K/V + softmax + output) with f64 matmul between them — pragmatic hybrid consistent with the design note's Iteration 4+ guidance.
• Gradient-free training via self-distillation: train() runs a forward pass on buffered samples, derives per-submodel targets (numerical softmax for softmax_model; (context, target) for out_model), then runs the existing coordinate-descent loop.
• 4-phase benchmark run_benchmark() mirrors the WeftOS bench pattern (Warmup → Convergence → Compute → Scalability) and returns a single AttentionBenchmark struct. This sets the baseline future iterations will be quantified against.
• Explicit go/no-go gate. Iteration 1 is blocked until Iteration 0 passes: converges in ≤ 3 rounds, p99 ≤ 5 µs at the default shape, 1000 forward passes without NaN, serialization roundtrip, polynomial scaling.
• Documentation: new EML Attention page covering architecture, benchmarks, limitations, roadmap.
• Live demos deployed alongside the docs:
  • /clawft_eml-attention — pure-JS Iteration 0 forward-pass demonstrator with configurable shape + live latency.
  • /clawft_eml-notebook — Python Colab notebook that trains a Python mirror and exports JSON directly loadable by the Rust EmlModel::from_json interface.

What it adds to WeftOS

• Bridges the gap from scalar-output EmlModel wrappers (QueryFusionModel, CausalCollapseModel, SurpriseScorer, etc.) to sequence-aware primitives — without abandoning the gradient-free / weight-snapping / ExoChain-audited posture that defines the EML substrate.
• Ships the 4-phase benchmark as the canonical performance-quantification tool for all future EML work, not just attention.

Experimental status

• Feature flag experimental-attention on eml-core (off by default).
• Default builds are byte-identical to 0.6.7.
• Toy scale only; explicit roadmap through Iteration 4 gates each step on the previous one passing benchmarks.
• Q/K/V projections remain at default init in Iteration 0; end-to-end coordinate descent lands in Iteration 1.

v0.6.7 — Quantum Cognitive Layer (Experimental)

2026-04-15

Adds a neutral-atom quantum acceleration layer to ECC with a live Pasqal Cloud integration. The classical ECC path is unchanged; quantum is a compile-time opt-in via quantum-pasqal.

Highlights

• QuantumBackend trait — object-safe async interface with shared vendor-neutral types (JobHandle, QuantumResults, JobStatus, BackendStatus, EvolutionParams, QuantumError). Designed for fallback chaining: try Fresnel, fall through to EMU_TN, fall through to the classical simulator.
• Deterministic graph → atom layout — force-directed 2D embedding in quantum_register::build_register, enforcing device constraints (min 4 µm inter-atom distance, max trap extent).
• Live PasqalBackend — end-to-end against apis.pasqal.cloud:
  • Auth0 client_credentials with 24h token caching and 300s refresh skew
  • Batch create / job poll / batch results / job cancel wired to real endpoints
  • Best-effort Pulser abstract-repr JSON builder for AnalogDevice + global Rydberg channel
  • submit_raw_sequence() escape hatch for Python-generated golden JSON
  • {bitstring: count} → per-atom Rydberg probability reduction
• BraketBackend stub — interface-only for QuEra Aquila (256 atoms) on AWS Braket. Same register code works on both vendors; live impl deferred.
• 4-tier test strategy — T0 local wiremock (14 tests on every CI build) → T1 EMU-FREE (free cloud emulator) → T3 EMU-TN (paid GPU emulator) → T4 Fresnel QPU. Live tiers run with --ignored when PASQAL_* env vars are set.
• Docs — new Quantum Cognitive Layer page covering architecture, ECC integration, 4-tier test strategy, limitations, and roadmap. Linked from the ECC page header.

What it adds to ECC

Experimental status

The layer is gated on quantum-pasqal / quantum-braket features, both off by default. Default builds are byte-identical to 0.6.6. weave.toml wiring and DEMOCRITUS tick integration land in 0.7.x.

v0.6.6 — Sprint 17: Knowledge Graph Intelligence

2026-04-14

18 Knowledge Graph Tasks

Sprint 17 delivers the full knowledge graph intelligence stack across 5,252 new lines and 170+ tests.

• EML Score Fusion (KG-001): Hybrid query combining keyword, graph proximity, community, and type scoring
• Community Summaries (KG-002): GraphRAG-style summary generation for detected communities
• Causal Chain Tracing (KG-003): Typed BFS with natural-language explanations
• RFF Spectral Analysis (KG-004): O(m) approximate spectral analysis using random Fourier features
• Info Gain Pruning (KG-005): Redundant evidence filtering based on information gain
• Data Flow Tracing (KG-006): BFS dependency flow tracing through call chains
• MCTS Graph Exploration (KG-007): UCB1 + random rollout for knowledge graph traversal
• Entity Dedup (KG-008): Levenshtein + structural similarity deduplication
• Geometric Shadowing (KG-009): Age-aware decay with per-edge volatility
• Multi-hop Beam Search (KG-010): Prioritized traversal with edge priors
• Sonobuoy Sensor Graph (KG-013): GraphSAGE aggregation + temporal features
• VQ Codebook Cold-Start (KG-014): K-means++ initialization for new entities
• Entity Alignment (KG-015): Cross-graph matching via label + structural similarity
• Conversational Exploration (KG-016): Stateful multi-turn dialogue over knowledge graphs
• EML Distillation (KG-017): Depth-4 to depth-2 model compression
• Newman Modularity (KG-018): Global partition quality metric

Infrastructure

• Incremental graph updates: Efficient delta-based graph rebuilds
• Multi-key HNSW indexing: Multiple embedding keys per entity for richer semantic search
• Shaal synergy stubs (KG-011/012): LogQuantized + SIMD distance configs
• New modules: summary.rs, alignment.rs, conversation.rs, sensor_graph.rs, vector_quantization.rs
• 1,770 tests passing

---

v0.6.5 — EML Self-Learning Stack + ExoChain Certification

2026-04-04

EML Self-Learning Functions

• eml-core standalone crate: Zero-dep (just serde), configurable depth 2-5, multi-head outputs, coordinate descent training (36 tests)
• 16 EML models across 4 crates: Coherence, governance scoring, restart strategy, health thresholds, dead letter policy, gossip timing, complexity limits, HNSW distance/ef/path/rebuild, causal collapse, surprise scoring, cluster thresholds, layout tuning, forensic coherence
• Two-tier pattern: O(1) EML prediction every tick (~100ns), exact ground truth periodically, continuous self-improvement
• Causal collapse prediction: rank_evidence_by_impact() ranks candidate edges by predicted coherence impact using perturbation theory (delta_lambda_2 = w * (phi[u] - phi[v])^2)
• Conversation cycle detection: detect_conversation_cycle() identifies stuck/oscillating conversations via lambda_2 stagnation

ExoChain Compliance

• 66 gaps identified and closed: Systematic audit of all mutation paths
• 75+ EVENT_KIND constants: Structured audit data across all subsystems
• 21 governance gates: EffectVector evaluation on all security-critical paths
• EML ExoChain integration: EmlEvent types (Trained, Drift, Saved, Loaded) chain-witnessed via drain bridge
• Certification: 4 independent auditors verified all critical (5/5) and high (16/16) items pass

HNSW EML Training Infrastructure

• 4 models: Distance (dimension selection), AdaptiveEf (per-query beam width), Path (entry-point prediction), Rebuild (recall-based scheduling)
• 33 tests, all passing
• Configurable via HnswEmlConfig: train_every_n, recall_check_every_n, min_training_samples, distance_selected_dims

Pull Requests

• RuView PR #387: 5 EML improvements (governance scorer, health thresholds, dead letter, gossip timing, complexity)
• ruvector PR #353: 6 HNSW EML optimizations (distance model, adaptive ef, path prediction, rebuild trigger, training infra, persistence)

---

v0.6.4 — EML Depth-4 Multi-Head Coherence

2026-04-04

• Depth-4 multi-head EML coherence model: 50 parameters, 3 output heads (lambda_2, fiedler_norm, uncertainty)
• Two-tier DEMOCRITUS tick loop wired with EML coherence fast path
• 24 new tests

---

v0.6.3 — O(1) EML Coherence Approximation

2026-04-14

• EML coherence model: 34-parameter depth-3 master formula predicting algebraic connectivity from graph statistics
• Based on Odrzywolel 2026, "All elementary functions from a single operator" (arXiv:2603.21852v2)
• O(1) prediction (~100ns) vs O(k*m) Lanczos iteration (~500us) -- ~5000x speedup
• Enables coherence checking at 10,000 Hz ECC tick rate for robotics
• Self-training: accumulates data during operation, retrains when 50+ samples collected
• Convergence verified on 5 standard graph families (K_n, star, cycle, path, Erdos-Renyi)
• 16 new tests, all passing
• Two-tier coherence: fast every tick, exact on drift detection

---

v0.6.2 — Graphify Pipeline Wired

2026-04-04

• weaver graphify rebuild now functional: Runs the full detect -> extract -> build -> cluster -> analyze -> export pipeline
• weaver graphify export now functional: Loads graph JSON, deserializes into KnowledgeGraph, exports to 7 formats
• Outputs graphify-out/graph.json and graphify-out/GRAPH_REPORT.md

---

v0.6.1 — Graphify Pipeline + Workspace RPC + ECC Calibration

2026-04-04

Graphify Extraction Pipeline

• weaver graphify rebuild now functional: Runs the full detect -> extract -> build -> cluster -> analyze -> export pipeline, producing graphify-out/graph.json and graphify-out/GRAPH_REPORT.md
• weaver graphify ingest <dir> delegates to the full pipeline for local directories (equivalent to rebuild)
• weaver graphify export <format> now functional: Loads the graph JSON, deserializes into a KnowledgeGraph, and exports to JSON, HTML, GraphML, Obsidian, Wiki, Cypher, or SVG
• Two extraction modes: Default (file detection + co-location edges, no tree-sitter required) and full AST extraction (with --features ast-extract)

Workspace RPC

• weft workspace create/list/load/status/delete now functional: Workspace management commands connected to daemon RPC

Kernel Boot

• Cognitive tick auto-started during kernel boot sequence
• ECC tick auto-computed from calibration bands (0.01ms to 1000ms, was hardcoded at 50ms)

---

v0.6.0 — Cognitum Seed Gap Sprint + Tiered Kernel Profiles

2026-04-04

• 11 gaps identified and closed across the kernel via Cognitum Seed analysis
• Tiered kernel profiles (T0-T4): Boot-time calibration selects the appropriate resource tier from embedded microcontroller (T0) through GPU server (T4)
• Auto update check: weaver update / weft update commands
• Universal install script: Single-command installation for all platforms

---

v0.5.5 — Hybrid Vector Search + DiskANN

2026-04-04

Vector Search Backends

• VectorBackend trait: Pluggable vector search with insert/search/remove/flush interface
• HNSW backend (default): In-memory approximate nearest neighbor via instant-distance
• DiskANN backend: SSD-backed vector search via ruvector-diskann v2.1, Vamana graph with product quantization and mmap persistence
• Hybrid backend: Hot HNSW cache + cold DiskANN store with access-counted promotion, LRU eviction, and merged search results
• Configurable via kernel.vector in weave.toml: backend selection, dimensions, per-backend tuning

Documentation

• ECC page updated with vector search backend details, configuration examples, and selection guide
• Configuration reference updated with [kernel.vector] section
• Release notes updated

---

v0.5.4 — Benchmark v3 + ESP32 Edge Benchmark

2026-04-04

• Benchmark v3: 6-phase comprehensive performance suite (1,342 LOC) covering RPC latency, compute throughput, memory, persistence, concurrency, and stress
• ESP32-S3 edge benchmark: Compatible with weaver benchmark v3 for edge devices
• Fixed benchmark method names and parameter formats

---

v0.5.3 — Benchmark Scoring Recalibration

2026-04-04

• Scoring recalibrated: Pi 5 was incorrectly graded A+ due to overly generous thresholds, now correctly scores B/C

---

v0.5.2 — Kernel Default + Benchmark v1

2026-04-04

• Kernel enabled by default: No longer requires explicit --features kernel flag
• weaver benchmark: Standardized kernel performance test (RPC, compute, stress)
• ECC RPC dispatch: All ECC commands wired to daemon endpoints
• Per-project kernel runtime directory: Prevents state collision across projects
• weaver update / weft update: Unified update command

---

v0.5.1 — Knowledge Graph Builder

2026-04-07

clawft-graphify (New Crate)

• 11,896 lines of Rust across 35 modules with 88 tests
• AST extraction via tree-sitter for Python, JavaScript/TypeScript, Rust, Go
• Two-pass extraction: structural walk + call graph inference
• Community detection: label propagation with oversized splitting
• Analysis: god nodes, surprising connections (5-factor scoring), question generation (5 strategies), graph diff
• 7 export formats: JSON, HTML/vis.js, GraphML, Obsidian vault+canvas, Wiki
• URL ingestion: tweet, arXiv, PDF, webpage with SSRF protection
• WeftOS integration: CausalGraph bridge, 9th assessment analyzer, HNSW indexing
• Forensic domain: 14 entity types, 13 edge types, gap analysis, coherence scoring, counterfactual delta
• CLI: weaver graphify with 7 subcommands (ingest, query, export, diff, rebuild, watch, hooks)
• File watcher + git hooks for continuous graph updates

---

v0.5.0 — Sprint 16 Architecture

2026-04-04

• wasmtime v33 upgrade: Latest WASM runtime with performance improvements
• Security audit: Full review of kernel service boundaries
• ServiceApi: Unified kernel service registration and lifecycle management
• wasip2: Full wasm32-wasip2 target support finalized across all crates
• Playground phase 3-4: Browser WASM sandbox improvements
• Mesh K6 benchmarks: Performance baseline for mesh networking
• Browser WASM features: Enhanced client-side execution capabilities

---

v0.4.3 — Docs Coverage + Docker Optimization

2026-04-04

• Documentation coverage pass: Sprint 14-15 docs for assessment, GUI, browser, and plugins
• Docker Alpine optimization: Alpine + pre-built musl binaries, build time from ~30min to ~2min, image ~50MB to ~15MB
• crates.io pipeline fixes: Added clawft-plugin-treesitter and clawft-services to publish pipeline, handle duplicate-version errors gracefully

---

v0.4.2 — Sprint 15 Completion + Docker Optimization

2026-04-04

Plugin Ecosystem (WS5)

• clawft-plugin-npm: Node.js dependency parsing via package.json and lockfiles
• clawft-plugin-ci: GitHub Actions and Vercel config parsing and analysis
• Plugin marketplace scaffold: create-weftos-plugin CLI for authoring new plugins
• Rustdoc JSON-to-MDX converter: Generates native Fumadocs API pages from Rust documentation

Cross-Project Mesh (WS4)

• MeshCoordinator: Real mesh coordination with AssessmentMessage protocol and gossip discovery
• Bidirectional peer linking: clawft and weavelogic.ai linked and compared across projects
• Multi-project namespace: [project] section in weave.toml with org-based isolation

Browser Sandbox Improvements

• Full kernel boot sequence: ExoChain log now shows INIT, CONFIG, SERVICES, NETWORK, READY phases
• Rich markdown rendering: Headings, bold, italic, code blocks, links, lists in chat bubbles
• Document preview panel: Click internal doc links to open in a side panel

Infrastructure

• Docker optimization: Alpine + pre-built musl binaries -- build time from ~30min to ~2min, image ~50MB to ~15MB
• crates.io pipeline fixed: 12 crates now publish automatically on tag (was broken by missing deps)
• 25 crates in workspace (added clawft-plugin-npm, clawft-plugin-ci)
• 48 ADRs (unchanged)

---

v0.4.1 — Sprint 15: Assessment Depth, CI Hardening, Client Readiness

2026-04-03

Pluggable Assessment Analyzers

• AnalyzerRegistry with trait-based extensibility
• 5 built-in analyzers: complexity (>500-line files, TODO/FIXME), dependency (Cargo.toml/package.json parsing), security (hardcoded secrets, .env, unsafe), topology (Docker, K8s, .env), data source (postgres://, redis://, S3, API URLs)
• Assessment diff: compare current vs. previous runs, surface regressions
• Git hooks: weft assess hooks installs post-commit or pre-push hooks

CI/CD Hardening

• PR assessment gate: weft assess --scope ci --format github-annotations runs on every PR
• Cargo check gate: workspace-wide compilation check in PR pipeline
• Browser WASM CI fixed: pinned wasm-bindgen-cli to v0.2.108
• docs-assets manual dispatch: workflow_dispatch with skip_wasm input

Client Deployment Readiness

• Assessment config: loads triggers from .weftos/weave.toml
• Multi-project namespace: [project] section with org-based isolation
• Assessment dashboard: /assess route with project stats, findings, peer comparison
• Guided tour set pieces: 4 categories of starter prompts in WASM sandbox

Documentation Fixes

• Fixed all incorrect URLs (github.com/clawft/clawft to weave-logic-ai/weftos, ghcr.io same)
• Updated test badge (3,300+ to 3,900+), crate count (22 to 23)
• Added glossary entries: clawft-rpc, AssessmentService, Analyzer/AnalyzerRegistry
• WITNESS chain verification footer in ExoChain log panel

---

v0.4.0 — Sprint 14: WASM Sandbox, Assessment, CLI Compliance

2026-04-03

Sprint 14 ships the browser WASM sandbox, assessment framework, CLI kernel compliance, and 28 architectural decision records.

Browser WASM Sandbox (/clawft/)

• Live in your browser: clawft-wasm runs entirely client-side, loaded from CDN via GitHub Releases
• RVF Knowledge Base: 1,160 documentation segments with keyword search, acronym detection, and RAG-powered answers
• Two modes: Local (no API key, pure KB retrieval) and LLM (connect any provider via OpenRouter, Anthropic, OpenAI, etc.)
• ExoChain Log Panel: Live audit trail showing every operation -- KB search, queries, responses -- with linked hashes
• Runtime Introspection: Users can inspect their own WASM instance (memory, exports, KB stats, browser environment)

Assessment Framework

• weft assess CLI: run, status, init, link, peers, compare subcommands
• AssessmentService: Kernel-native SystemService with tree-sitter integration for Rust/TypeScript symbol extraction and cyclomatic complexity
• Cross-project coordination: Link projects via local path or HTTP URL, compare assessments side-by-side
• Daemon RPC: 5 new endpoints (assess.run, assess.status, assess.link, assess.peers, assess.compare) with ExoChain audit logging
• Validated: clawft (2,986 files, 412K LOC) and weavelogic.ai (2,549 files, 801K LOC)

CLI Kernel Compliance (ADR-021)

• New crate: clawft-rpc -- shared RPC client for both weft and weaver CLIs
• 32 commands migrated: All bypassing commands now use daemon-first RPC with graceful local fallback
• Categories: cron (6), assess (4), security (1), skills (7), tools (6), agents (3), workspace (8)
• Security: Every operation can now be audited via ExoChain when the daemon is running

Architecture Decision Records (28 new)

• ADR-020 to ADR-023: Kernel phase responsibilities, CLI compliance, ExoChain mandatory audit, assessment as kernel service
• ADR-024 to ADR-031: Noise encryption, Ed25519 identity, QUIC transport, selective libp2p, post-quantum dual signing, rvf-crypto fork, CBOR codec, rvf-wire mesh format
• ADR-032 to ADR-039: DashMap concurrency, three-branch governance, effect algebra, ServiceApi, hierarchical ToolRegistry, MSRV 1.93, Tauri shell, SWIM detection
• ADR-040 to ADR-047: LWW-CRDT process table, ChainAnchor trait, three operating modes, hash migration, wasip1 target, tiered router, forest of trees, self-calibrating tick

Documentation

• Previous/next page navigation on all doc pages
• "Edit on GitHub" links
• Glossary with 25+ terms
• Troubleshooting section in getting-started
• Assessment Workflow guide
• Deployment SOPs (SOP 1-5)

Infrastructure

• CDN asset delivery via GitHub Releases cdn-assets tag
• Vercel API route proxy with edge caching (s-maxage=604800)
• Blob URL WASM loading for MIME-type compatibility

---

v0.3.0 — Sprint 13: Integration + Paperclip

2026-04-01

Sprint 13 wires everything together and adds Paperclip-inspired orchestration patterns.

GUI Integration

• KernelDataProvider: Real Tauri data bridge replacing mock WebSocket -- polls kernel_status, metrics, processes, cost in parallel
• ThemeSwitcher: Runtime theme selection dropdown with localStorage/Tauri persistence
• BudgetBlock: Per-agent cost tracking dashboard with budget bar and agent table

Agent Pipeline (end-to-end)

• Config-based selection: PipelineConfig with scorer = "fitness" and learner = "trajectory" in config
• Factory functions: build_scorer() / build_learner() replace hardcoded NoOp in bootstrap and LLM adapter
• Skill improvement: improve_skill_instructions() uses TrajectoryLearner patterns to mutate prompts via skill_autogen.rs

Paperclip Patterns (Rust-native)

• Company/OrgChart: Company, OrgRole (Ceo/Manager/Worker), OrgNode, OrgChart with traversal helpers
• HeartbeatScheduler: Multi-agent wake/sleep cycle manager with 5-phase lifecycle (Wake->CheckQueue->Execute->Sleep->Report)
• GoalTree: Hierarchical goal tracking with status filtering (Pending/Active/Complete/Failed)
• HTTP API: Execute/govern/health endpoints behind http-api feature flag -- Paperclip adapter bridge

Platform

• Full WASI: All 10 publishable crates compile for wasm32-wasip2 (kernel + facade added)
• Windows ARM: Switched reqwest from rustls-tls to native-tls (removes ring dependency)
• Zero test failures: Fixed democritus embedding_error assertion, updated config snapshot
• native-tls: Uses OS TLS stack (SChannel/Security.framework/OpenSSL) for better cross-compilation

Testing

• 11 property tests (scorer bounds, mutation safety, token counting monotonicity)
• 9 fuzz tests (Config/RoutingConfig with random/malformed JSON)
• 4 criterion benchmark groups (count_tokens, compress_context, scorer, mutation)
• 6 context compression integration tests

---

v0.2.1 — docs.rs Cross-Links

2026-04-01

• All 8 publishable crates now show the WeftOS ecosystem table on docs.rs
• [package.metadata.docs.rs] with all-features = true for complete API surface
• 10 crates republished to crates.io

---

v0.2.0 — Sprint 12: Block Engine, Theming, Intelligence

2026-04-01

Lego Block Engine

• BlockRegistry, BlockRenderer, StateStore (Zustand + Tauri bridge)
• 10 composable blocks: Text, Code, Status, Table, Tree, Terminal, Button, Column, Row, Grid, Tabs
• JSON descriptor-driven layout with recursive rendering

Theming System

• 4 built-in themes: ocean-dark, midnight (cyberpunk), paper-light, high-contrast (WCAG AAA)
• CSS variable bridge via --weftos-* custom properties
• ThemeProvider with runtime switching, ANSI palette mapping, Tailwind integration

Context Compression

• Sliding-window context management (configurable max_context_tokens, default 8192)
• First-sentence summarization for older messages
• Opt-in: builder.with_compression(config)

GEPA Prompt Evolution

• TrajectoryLearner: trajectory collection, pattern extraction, evolution triggers
• FitnessScorer: 4-dimension weighted scoring (task_completion, efficiency, tool_accuracy, coherence)
• 4 prompt mutation strategies: rephrase, add examples, remove ineffective, emphasize

Local LLM Provider

• OpenAI-compatible provider for Ollama, vLLM, llama.cpp, LM Studio
• Key-optional auth, streaming, model listing
• Factory methods: LocalProvider::ollama(), ::vllm(), ::llamacpp(), ::lmstudio()

---

v0.1.4 — Sprint 11 Closing Release

2026-04-01

• musl static builds: x86_64-unknown-linux-musl + aarch64-unknown-linux-musl -- statically linked, runs on any Linux
• WASI binary: clawft-wasm for wasm32-wasip2 (57KB raw, 24KB gzip)
• vendored-openssl: Fixed musl cross-compilation (git2 crate)
• 7 native + 2 WASM = 9 targets

v0.1.3

2026-04-01

• Attempted 10 targets (musl + Windows ARM). musl blocked by openssl, Windows ARM by ring. Fixed in v0.1.4.

v0.1.2

2026-04-01

• Automated deploy test via weftos-build-deploy skill
• Validated full release pipeline end-to-end

v0.1.1

2026-03-31

• Fixed installer URLs: repository field corrected to weave-logic-ai/weftos
• Homebrew tap: Created weave-logic-ai/homebrew-tap, formula auto-publishing working
• HOMEBREW_TAP_TOKEN secret configured
• All 5 platform builds green

v0.1.0 — First Release

2026-03-31

First public release of WeftOS. 3 binaries x 5 platforms.

• weft: Agent CLI (primary user interface) -- 18 commands, 10 built-in tools
• weaver: Kernel operator CLI (daemon management, kernel lifecycle)
• weftos: Kernel daemon binary
• GitHub Releases with shell + PowerShell installers
• cargo-dist automated build pipeline

---

Pre-release Development

Sprint 11 Symposium (2026-03-28 -- 2026-03-31)

9-track symposium producing 11 documents, 55 work items, 15 technology decisions.

P0 fixes (9/9): opt-level z->3, publish=false on 13 crates, version.workspace on 22 crates, HNSW O(1) lookup, unimplemented!()->Err, #[non_exhaustive] on 118 enums, CHANGELOG rebuilt (134 commits), README fixed, rvf-crypto inlined.

P1 core (8/8): ONNX WordPiece tokenizer, sparse Lanczos spectral analysis (200x improvement), HNSW deferred rebuild, cargo-dist configuration, Registry trait (4 implementations), ChainLoggable trait (3 audit gaps closed), feature gate coarsening (18->3 fields), wasm_runner decomposition (5,046->8 files).

Documentation: Fumadocs unified (65+ pages), 20 ADRs, agent guide (448 lines), Hermes integration analysis, GEPA prompt evolution research.

Sprint 10 (2026-03-01 -- 2026-03-27)

6 weeks of kernel hardening and operational maturity.

• K8 GUI: Tauri 2.0 wrapper, component generator, 7 Rust commands
• Config/auth services: Runtime configuration, authentication, authorization
• Mesh discovery: mDNS LAN discovery, static seed peers
• 10 built-in tools: File operations, shell execution, web fetch/search, memory, spawn
• Observability: Metrics collection, health monitoring, event logging
• External codebase analysis: Knowledge graph visualization
• Docker packaging: Multi-arch Dockerfile, release-docker.yml
• E2E tests: Playwright-based testing
• Tool signing: Ed25519 signatures on tool definitions
• WASM shell execution: Sandbox environment for tool execution

Sprint 9 (2026-02-25 -- 2026-02-28)

Spectral analysis and cognitive substrate.

• ECC cognitive substrate: Causal DAG, HNSW semantic search, BLAKE3 cross-references
• DEMOCRITUS loop: Continuous cognitive processing (Sense->Embed->Search->Update->CrossRef->Prune->Report)
• Spectral analysis: Community detection, predictive change analysis
• Impulse queue: Ephemeral signal processing with configurable decay

Sprints 6-8 (2026-02-19 -- 2026-02-24)

Kernel foundation (K0-K6).

• K0: Boot sequence, process table, capability registry, REPL console
• K1: Agent supervisor with RBAC, process lifecycle, ExoChain integration
• K2: A2A IPC with topic pub/sub, inbox routing, delegation
• K3: WASM sandbox with wasmtime, fuel metering, capability enforcement
• K4: Container management, application framework
• K5: App packaging, manifest parsing, service wiring
• K6: Mesh networking (Noise protocol, heartbeat, discovery, framing)
• ExoChain: Append-only hash chain with SHAKE-256 + Ed25519 + ML-DSA-65 dual signatures
• Governance: Three-branch constitutional engine (Legislative/Executive/Judicial)
• Weaver CLI: Kernel operator interface with daemon mode

Sprints 1-5 (2026-02-17 -- 2026-02-18)

Initial framework development.

• Phase 1-2: Core agent loop, message bus, LLM provider abstraction
• Phase 3: Skills, agents, workspaces, MCP server, delegation, RVF format, WASM optimization
• Tiered routing: 3-tier model routing (WASM booster, Haiku, Sonnet/Opus)
• LLM providers: OpenAI, Anthropic, Google Gemini, xAI, Ollama, DeepSeek, OpenRouter, Groq
• Channels: CLI, Telegram, Discord, Slack, WebSocket, HTTP, MCP
• Plugin system: Trait-based plugins for tools, channels, pipeline stages
• Platform abstraction: Native + WASM + browser targets
• Security: Tool signing, routing validation, security policy engine