diff --git a/.agents/rules/rules.md b/.agents/rules/rules.md
deleted file mode 100644
index 594d63f..0000000
--- a/.agents/rules/rules.md
+++ /dev/null
@@ -1,60 +0,0 @@
-# Spector — Agent Rules
-
-## Project Identity
-
-Spector is a **Java 25** vector search engine with biologically-inspired cognitive memory, built on Panama FFM, SIMD Vector API, and virtual threads. 22-module Maven reactor.
-
-## Critical Constraints
-
-- **JDK 25** with `jdk.incubator.vector`
-- **NEVER** use `synchronized` — always `ReentrantLock` (virtual thread pinning)
-- **NEVER** `System.out.println` — use SLF4J `LoggerFactory.getLogger()`
-- **NEVER** hardcode SIMD lane widths — use `FloatVector.SPECIES_PREFERRED`
-- **NEVER** commit secrets/tokens to repo
-- `.spector/` is in `.gitignore` — never remove
-
-## Architecture Boundaries
-
-| Layer | Modules | Depends On |
-|---|---|---|
-| Foundation | core, commons, config, storage | Each other only |
-| Embedding | embed-api, embed-ollama | commons |
-| Search | index, query, gpu | Foundation + embed-api |
-| Intelligence | rag, engine, ingestion, memory | Search + Foundation |
-| Runtime | runtime, node, mcp, cli, client | Intelligence |
-| Infrastructure | metrics, bench, dist, spring | Any |
-
-**`spector-memory` and `spector-engine` are independent peers — never depend on each other.** Wired only at `SpectorRuntime`.
-
-## Directory Paths
-
-- Engine: `.spector/index/` — Memory: `.spector/memory/` — WAL: `.spector/memory/wal/`
-- Source of truth: `SpectorConfigFactory.java`
-
-## Git Conventions
-
-- Format: `<type>(<scope>): <description>` (Conventional Commits)
-- Types: `feat`, `fix`, `perf`, `refactor`, `docs`, `test`, `build`, `chore`
-- Scope: module name without `spector-` (e.g., `engine`, `memory`)
-- Commit order: foundation → search → intelligence → runtime → docs → tests
-- Branch: `feat/desc`, `fix/desc`, `perf/desc`, `docs/desc`
-
-## Documentation
-
-- MkDocs Material site in `docs/`, build: `python -m mkdocs build --clean`
-- Module READMEs included via `--8<--` snippets in `docs/docs/modules/`
-- Binary layouts: RFC-style wire format diagrams
-- Design source of truth: `spector-memory/RnD/` for memory subsystem
-- Config docs: `docs/docs/configuration/parameters.md`
-
-## Key Patterns
-
-- Records for immutable data (`PersistenceFiles`, `NodeInfo`, `SearchResult`)
-- Builder pattern for configs (`SpectorConfig.builder()`, `SpectorEngine.builder()`)
-- Abstract Factory for component assembly (`EngineComponentFactory`)
-- `IngestionTarget` interface — both engine and memory implement their own
-- `AutoCloseable` for anything holding native resources
-
-## Skills Reference
-
-Detailed coding standards, code review process, and other skills are defined in `.agents/skills/`. Agents should read the relevant SKILL.md before performing specialized tasks.
diff --git a/.agents/skills/code-review/SKILL.md b/.agents/skills/code-review/SKILL.md
deleted file mode 100644
index 20fd33a..0000000
--- a/.agents/skills/code-review/SKILL.md
+++ /dev/null
@@ -1,141 +0,0 @@
-# Skill: Code Review
-
-This skill defines the code review process for the Spector project. Use this when reviewing PRs, inspecting diffs, or performing pre-commit quality checks.
-
-## Trigger
-
-This skill is triggered when:
-- The user requests a code review of changes or a PR
-- The user asks to "review", "check", or "audit" code
-- Before merging or pushing significant changes
-- As part of the PR Review workflow
-
-## Instructions
-
-### Step 1: Scope the Review
-
-Identify what changed:
-```bash
-git diff --stat                          # unstaged changes
-git diff --cached --stat                 # staged changes
-git diff main...HEAD --stat              # full PR diff vs main
-```
-
-Categorize changes by module and risk level:
-- **High risk:** core, index, storage (SIMD, Panama, hot paths)
-- **Medium risk:** engine, memory, query (business logic)
-- **Low risk:** docs, bench, scripts (non-production)
-
-### Step 2: Architecture Check
-
-For each changed module, verify module boundary rules:
-
-- [ ] No Foundation module depending on Intelligence/Runtime
-- [ ] `spector-memory` does NOT import from `spector-engine` (or vice versa)
-- [ ] No new circular dependencies between modules
-- [ ] New dependencies added to correct POM section
-- [ ] If a new module was added, it follows the layer hierarchy
-
-**Quick check command:**
-```bash
-# Find cross-module imports that violate boundaries
-grep -rn "import com.spectrayan.spector.engine" spector-memory/src/
-grep -rn "import com.spectrayan.spector.memory" spector-engine/src/
-```
-
-### Step 3: Java Standards Compliance
-
-For each changed `.java` file, check:
-
-**Hard blockers (must fix before merge):**
-- [ ] No `synchronized` keyword anywhere — must use `ReentrantLock`
-- [ ] No `System.out.println` — must use SLF4J logger
-- [ ] No hardcoded SIMD lane widths — must use `SPECIES_PREFERRED`
-- [ ] No `Thread.sleep()` in production — use `LockSupport.parkNanos()`
-- [ ] No swallowed exceptions (`catch (Exception e) { }`)
-- [ ] No hardcoded file paths — use `SpectorConfig` / `PersistenceFiles`
-- [ ] `AutoCloseable` implemented for classes holding native resources
-
-**Quality checks (should fix):**
-- [ ] Javadoc on all new public classes and methods
-- [ ] Records used for immutable data holders (not mutable POJOs)
-- [ ] Pattern matching used instead of cast-after-instanceof
-- [ ] Section separators (`// ───── Section ─────`) for class organization
-- [ ] Meaningful variable names (not single letters except loop vars)
-
-### Step 4: Performance Review (core, index, storage only)
-
-For changes in hot-path modules:
-
-- [ ] No `new float[]` or boxing in search/similarity paths
-- [ ] `MemorySegment` slices used instead of `.toArray()` copies
-- [ ] SIMD loops use `SPECIES.loopBound()` with scalar tail
-- [ ] `VectorMask` used for tail handling (not branching)
-- [ ] Arena lifecycle correct: `ofShared()` for concurrent, `ofConfined()` for single-thread
-- [ ] JMH benchmark included for performance-sensitive changes
-
-### Step 5: Test Coverage
-
-- [ ] New public API methods have at least 1 test
-- [ ] Tests use `@TempDir` for file operations (never hardcoded paths)
-- [ ] Tests use AssertJ assertions (`assertThat`), not JUnit `assertEquals`
-- [ ] Integration tests suffixed `*IntegrationTest`
-- [ ] No test relies on external services without `@DisabledIfEnvironmentVariable`
-
-**Quick gap check:**
-```bash
-# List production files without corresponding test files
-for file in $(git diff --name-only --diff-filter=A | grep "src/main.*\.java$"); do
-  test_file=$(echo $file | sed 's|src/main|src/test|' | sed 's|\.java$|Test.java|')
-  [ ! -f "$test_file" ] && echo "MISSING TEST: $test_file"
-done
-```
-
-### Step 6: Documentation
-
-- [ ] README.md updated if public API changed
-- [ ] `docs/docs/configuration/parameters.md` updated if config defaults changed
-- [ ] Design docs updated if binary layouts or WAL format changed
-- [ ] `mkdocs build --clean` produces no new warnings
-- [ ] Mermaid diagrams have valid syntax
-
-### Step 7: Git Hygiene
-
-- [ ] Commit messages follow Conventional Commits: `<type>(<scope>): <desc>`
-- [ ] No secrets, API keys, or credentials in diff
-- [ ] No `.spector/` data files committed
-- [ ] No generated files (`.class`, `target/`, `site/`) committed
-- [ ] Commits are logically grouped (not one mega-commit)
-
-### Step 8: Generate Review Summary
-
-After completing all checks, produce a structured summary:
-
-```markdown
-## Code Review Summary
-
-**Scope:** {N} files across {M} modules
-**Risk:** High / Medium / Low
-
-### ✅ Passed
-- Architecture boundaries respected
-- No synchronized/System.out violations
-- Tests added for new APIs
-
-### ⚠️ Warnings
-- Missing Javadoc on `NewClass.process()` (line 42)
-- No JMH benchmark for SIMD optimization
-
-### ❌ Blockers
-- `synchronized` used in MemoryWal.java:156 — must use ReentrantLock
-- Missing test for `ShardedDiskHnswWriter.write()`
-
-### Verdict: APPROVE / REQUEST_CHANGES / NEEDS_DISCUSSION
-```
-
-## Verification
-
-After the review is complete:
-1. All blockers must be resolved before merge
-2. Warnings should be addressed or documented as tech debt
-3. Review summary should be attached to the PR or provided to the user
diff --git a/.agents/skills/coding-standards/SKILL.md b/.agents/skills/coding-standards/SKILL.md
deleted file mode 100644
index c093457..0000000
--- a/.agents/skills/coding-standards/SKILL.md
+++ /dev/null
@@ -1,330 +0,0 @@
-# Skill: Coding Standards Reference
-
-This skill provides the comprehensive coding standards for the Spector project. Agents should reference this document when writing or reviewing Java code in any `spector-*` module.
-
-## Trigger
-
-Reference this document when:
-- Writing new Java classes or methods
-- Reviewing code changes for standards compliance
-- Creating new modules or packages
-- Adding or auditing exception handling
-- Creating new ErrorCode constants or SpectorException subclasses
-- Resolving code style disagreements
-
----
-
-## Java Language (JDK 25)
-
-### Modern Features — Required
-
-| Feature | Usage | Example |
-|---|---|---|
-| **Records** | All immutable data holders | `public record NodeInfo(String id, int port) {}` |
-| **Sealed classes** | Closed type hierarchies | `sealed interface VectorIndex permits HnswIndex, BruteForceIndex` |
-| **Pattern matching** | `instanceof` checks | `if (index instanceof AbstractHnswIndex hnsw && hnsw.size() > 0)` |
-| **Switch expressions** | Exhaustive matching | `return switch (mode) { case SEARCH -> engine; case MEMORY -> memory; };` |
-| **`var`** | Local variables when RHS type is obvious | `var config = SpectorConfig.DEFAULT.withDimensions(384);` |
-| **Text blocks** | Multi-line strings | `"""SELECT * FROM ..."""` |
-
-### Concurrency — Virtual Thread Safety
-
-```java
-// ✅ CORRECT — ReentrantLock (virtual-thread safe)
-private final ReentrantLock lock = new ReentrantLock();
-public void write(byte[] data) {
-    lock.lock();
-    try { /* critical section */ }
-    finally { lock.unlock(); }
-}
-
-// ❌ WRONG — synchronized pins virtual threads to carrier
-public synchronized void write(byte[] data) { /* ... */ }
-```
-
-- Use `ReentrantLock` for all mutual exclusion
-- Use `ReentrantReadWriteLock` when read-heavy
-- Use `AtomicReference`, `AtomicInteger` for simple counters
-- Use `LockSupport.parkNanos()` instead of `Thread.sleep()`
-- Use `ConcurrentHashMap` over `Collections.synchronizedMap()`
-
-### Panama FFM (Foreign Function & Memory)
-
-```java
-// ✅ Shared arena for concurrent access
-try (Arena arena = Arena.ofShared()) {
-    MemorySegment segment = arena.allocate(ValueLayout.JAVA_FLOAT, capacity);
-    segment.set(ValueLayout.JAVA_FLOAT, offset, value);
-}
-
-// ✅ Zero-copy slice
-MemorySegment slice = segment.asSlice(offset, length);
-
-// ❌ WRONG — copying to float[] in hot path
-float[] copy = segment.toArray(ValueLayout.JAVA_FLOAT);  // heap allocation!
-```
-
-- `Arena.ofShared()` for concurrent access across threads
-- `Arena.ofConfined()` for single-thread operations
-- Prefer `MemorySegment` slices over array copies
-- Use `ValueLayout.JAVA_FLOAT` (not `JAVA_FLOAT_UNALIGNED`) when alignment is guaranteed
-
-### SIMD (Vector API)
-
-```java
-// ✅ CORRECT — species-agnostic
-static final VectorSpecies<Float> SPECIES = FloatVector.SPECIES_PREFERRED;
-
-public static float dotProduct(float[] a, float[] b) {
-    int i = 0;
-    FloatVector sum = FloatVector.zero(SPECIES);
-    int bound = SPECIES.loopBound(a.length);
-    for (; i < bound; i += SPECIES.length()) {
-        var va = FloatVector.fromArray(SPECIES, a, i);
-        var vb = FloatVector.fromArray(SPECIES, b, i);
-        sum = va.fma(vb, sum);
-    }
-    float result = sum.reduceLanes(VectorOperators.ADD);
-    for (; i < a.length; i++) result += a[i] * b[i]; // scalar tail
-    return result;
-}
-
-// ❌ WRONG — hardcoded lane width
-static final VectorSpecies<Float> SPECIES = FloatVector.SPECIES_256;
-```
-
----
-
-## Naming Conventions
-
-| Element | Convention | Example |
-|---|---|---|
-| Module directory | `spector-{name}` | `spector-memory` |
-| Package | `com.spectrayan.spector.{name}` | `com.spectrayan.spector.memory.sync` |
-| Class | PascalCase, descriptive | `MemoryWal`, `CognitiveRecordLayout` |
-| Interface | PascalCase, noun/adjective | `VectorIndex`, `IngestionTarget` |
-| Constants | `UPPER_SNAKE_CASE` | `HEADER_MAGIC`, `DEFAULT_CAPACITY` |
-| Methods | camelCase, verb-first | `resolveIndex()`, `ingestChunked()` |
-| Test class | `{ClassName}Test` | `MemoryWalTest` |
-| Integration test | `{Name}IntegrationTest` | `SpectorMemoryIntegrationTest` |
-| Builder | Static inner `Builder` class | `SpectorEngine.builder()` |
-| Factory | `{Name}Factory` | `EngineComponentFactory` |
-
----
-
-## Class Structure Template
-
-```java
-package com.spectrayan.spector.{module};
-
-import ...;
-
-/**
- * Brief description of what this class does.
- *
- * <p>Detailed explanation of design decisions, usage patterns,
- * and relationship to other classes.</p>
- *
- * <h3>Design Patterns</h3>
- * <ul>
- *   <li><b>Pattern</b> — explanation</li>
- * </ul>
- *
- * @see RelatedClass
- */
-public class MyClass implements AutoCloseable {
-
-    private static final Logger log = LoggerFactory.getLogger(MyClass.class);
-
-    // ─────────────── Constants ───────────────
-    private static final int DEFAULT_CAPACITY = 1000;
-
-    // ─────────────── Fields ───────────────
-    private final SpectorConfig config;
-    private final ReentrantLock lock = new ReentrantLock();
-    private volatile boolean closed;
-
-    // ─────────────── Construction ───────────────
-    public MyClass(SpectorConfig config) { ... }
-
-    // ─────────────── Public API ───────────────
-    public void doWork() { ... }
-
-    // ─────────────── Internal ───────────────
-    private void helper() { ... }
-
-    // ─────────────── Lifecycle ───────────────
-    @Override
-    public void close() { ... }
-}
-```
-
-**Section separators:** Use `// ─────────────── Section ───────────────` for visual grouping.
-
----
-
-## Performance Rules (core, index, storage)
-
-| Rule | Detail |
-|---|---|
-| **No allocations in hot paths** | Reuse buffers, use offset+length APIs, avoid boxing |
-| **Zero-copy** | `MemorySegment` slices, never copy to `float[]` in search |
-| **Branchless SIMD** | `VectorMask` for tail handling, minimize scalar fallback |
-| **Benchmark gate** | Performance PRs must include JMH before/after results |
-| **Profile first** | Use JFR/async-profiler before optimizing |
-
----
-
-## Error Handling — SpectorException Framework
-
-Spector uses a structured error framework based on `ErrorCode` + `SpectorException`. **Never throw generic exceptions.** All errors go through this system.
-
-### Core Architecture
-
-```
-ErrorCode (enum)              — Central registry of SPE-XXX-YYY codes with {} message templates
-  ↓
-SpectorException (abstract)   — Base class, stores ErrorCode, formats message via errorCode.format(args)
-  ├── SpectorValidationException   (SPE-100-xxx)
-  ├── SpectorConfigException       (SPE-110-xxx)
-  ├── SpectorIndexException        (SPE-200-xxx)
-  ├── SpectorStorageException      (SPE-210-xxx)
-  ├── SpectorEmbeddingException    (SPE-300-xxx)
-  ├── SpectorMemoryException       (SPE-310-xxx)
-  │   ├── SpectorGraphException           (SPE-310-006..011)
-  │   │   ├── SpectorHebbianException         (SPE-310-006)
-  │   │   ├── SpectorTemporalChainException   (SPE-310-007)
-  │   │   ├── SpectorEntityGraphException     (SPE-310-008)
-  │   │   ├── SpectorCoActivationException    (SPE-310-009)
-  │   │   ├── SpectorGraphPersistenceException(SPE-310-010)
-  │   │   └── SpectorGraphDecayException      (SPE-310-011)
-  │   ├── SpectorMemoryRecallException    (SPE-310-002)
-  │   ├── SpectorMemoryConsolidationException (SPE-310-003)
-  │   └── SpectorMemoryTierFullException  (SPE-310-001)
-  ├── SpectorGpuException             (SPE-400-xxx)
-  ├── SpectorServerException          (SPE-500-xxx)
-  ├── SpectorClientException          (SPE-510-xxx)
-  ├── SpectorIngestionException       (SPE-600-xxx)
-  ├── SpectorClusterException         (SPE-700-xxx)
-  └── SpectorInternalException        (SPE-900-xxx)
-```
-
-**Key files:**
-- `spector-commons/src/main/java/com/spectrayan/spector/commons/error/ErrorCode.java`
-- `spector-commons/src/main/java/com/spectrayan/spector/commons/error/SpectorException.java`
-- Module-specific errors: `spector-{module}/src/main/java/.../error/`
-
-### Adding a New Error Code
-
-1. Add the constant to `ErrorCode.java` under the correct category section:
-
-```java
-// In ErrorCode.java — under the correct category section
-/** Brief description of when this error occurs. */
-MY_OPERATION_FAILED  (310_012, ErrorCategory.MEMORY,
-        "My operation failed for {}: {}"),
-```
-
-- Code format: `{category_prefix}_{sequence}` → e.g., `310_012` → `SPE-310-012`
-- Message template uses `{}` placeholders (SLF4J-style)
-- **Codes are immutable once assigned — never reuse or renumber**
-
-### Creating a Granular Exception
-
-Create a domain-specific exception that binds a default `ErrorCode` and captures typed context:
-
-```java
-// ✅ CORRECT — granular exception with typed constructor
-public class SpectorHebbianException extends SpectorGraphException {
-
-    private final String operation;
-
-    public SpectorHebbianException(String operation) {
-        super(ErrorCode.GRAPH_HEBBIAN_FAILED, operation);   // format via errorCode.format(args)
-        this.operation = operation;
-    }
-
-    public SpectorHebbianException(String operation, Throwable cause) {
-        super(ErrorCode.GRAPH_HEBBIAN_FAILED, cause, operation);
-        this.operation = operation;
-    }
-
-    public String getOperation() { return operation; }
-}
-```
-
-**Rules:**
-- Constructor args map 1:1 to `{}` placeholders in the ErrorCode template
-- **No string concatenation at construction site** — formatting happens inside `SpectorException` via `errorCode.format(args)`
-- Store domain-specific context as fields (e.g., `operation`, `path`, `graphType`)
-- Follow the naming pattern: `Spector{Domain}Exception`
-
-### Throw Sites — Throwing Exceptions
-
-```java
-// ✅ CORRECT — typed exception, no string concatenation
-throw new SpectorGraphPersistenceException("HebbianGraph", filePath, e);
-// getMessage() → "[SPE-310-010] Graph persistence failed for HebbianGraph: /path/to/file"
-
-// ✅ CORRECT — ErrorCode with typed args
-throw new SpectorValidationException(ErrorCode.ARGUMENT_NULL, "listener");
-// getMessage() → "[SPE-100-007] listener must not be null"
-
-// ❌ WRONG — string concatenation at throw site
-throw new SpectorGraphException(ErrorCode.GRAPH_PERSISTENCE_FAILED, e,
-        "HebbianGraph save to " + filePath + " failed: " + e.getMessage());
-
-// ❌ WRONG — generic exception
-throw new RuntimeException("something failed");
-
-// ❌ WRONG — UncheckedIOException (use SpectorException subtypes)
-throw new UncheckedIOException("write failed", e);
-```
-
-### Catch Sites — Graceful Degradation
-
-For enrichment steps that should **not** crash the main pipeline:
-
-```java
-// ✅ CORRECT — create exception for formatted message, log, continue
-} catch (RuntimeException e) {
-    SpectorHebbianException ex = new SpectorHebbianException("edge strengthening", e);
-    log.warn(ex.getMessage());
-}
-
-// ✅ CORRECT — catch and rethrow as domain exception
-} catch (IOException e) {
-    throw new SpectorGraphPersistenceException("EntityGraph", filePath, e);
-}
-
-// ❌ WRONG — catch generic Exception
-} catch (Exception e) { ... }
-
-// ❌ WRONG — ErrorCode.format() with string concatenation at call site
-log.warn(ErrorCode.GRAPH_HEBBIAN_FAILED.format(
-        "edge strengthening for '" + id + "': " + e.getMessage()));
-
-// ❌ WRONG — swallowing exceptions
-} catch (Exception e) { /* ignored */ }
-```
-
-### Pattern Summary
-
-| Scenario | Pattern |
-|---|---|
-| **New domain error** | Add `ErrorCode` constant → create `Spector{Domain}Exception` subclass |
-| **Throw on failure** | `throw new Spector{Domain}Exception(args, cause)` |
-| **Graceful degradation** | `catch(RuntimeException) → new Exception(args, e) → log(ex.getMessage())` |
-| **IO failure** | `catch(IOException) → throw new SpectorGraphPersistenceException(type, path, e)` |
-| **Validation** | `throw new SpectorValidationException(ErrorCode.ARGUMENT_NULL, "paramName")` |
-| **Never** | `catch(Exception)`, `throw new RuntimeException()`, string concat in ErrorCode.format() |
-
----
-
-## Testing Standards
-
-- **Framework:** JUnit 5 + AssertJ only (never JUnit 4 or Hamcrest)
-- **File tests:** Always use `@TempDir`, never hardcode paths
-- **Assertions:** Fluent AssertJ: `assertThat(x).isEqualTo(y)`, never `assertEquals`
-- **Naming:** Test methods describe behavior: `walRecovery_truncatesIncompleteRecord()`
-- **Coverage:** All new public API methods require at least 1 test
diff --git a/.agents/skills/doc-sync/SKILL.md b/.agents/skills/doc-sync/SKILL.md
deleted file mode 100644
index 86fff6d..0000000
--- a/.agents/skills/doc-sync/SKILL.md
+++ /dev/null
@@ -1,92 +0,0 @@
-# Skill: Documentation Sync
-
-This skill ensures MkDocs site, module READMEs, configuration docs, and design documents stay in sync with production code changes.
-
-## Trigger
-
-This skill is triggered when:
-- Production code changes public API, configuration defaults, or directory paths
-- A new module is created or an existing one is renamed/deleted
-- The user requests "update docs", "sync docs", or "fix doc warnings"
-- As part of the Feature Development or Module Lifecycle workflows
-
-## Instructions
-
-### Step 1: Identify What Changed
-
-```bash
-git diff --name-only HEAD~1  # or appropriate range
-```
-
-Map changed files to documentation impact:
-
-| Code Change | Docs to Update |
-|---|---|
-| `SpectorConfig` / `SpectorProperties` | `docs/docs/configuration/parameters.md`, `spector-defaults.yml` |
-| `SpectorConfigFactory` (path defaults) | All docs referencing `.spector/` paths |
-| Public API in any module | `spector-{mod}/README.md` |
-| `MemoryWal`, `CognitiveRecordLayout` | `docs/docs/memory/wal-design.md` |
-| New module created | `docs/mkdocs.yml`, `docs/docs/modules/index.md`, new module page |
-| Module removed | `docs/mkdocs.yml`, `docs/docs/modules/index.md`, delete page |
-| POM dependency changes | `docs/docs/modules/index.md` (dependency graph) |
-
-### Step 2: Update Module Docs
-
-For each module with changed public API:
-
-1. Update `spector-{module}/README.md` (auto-included in docs site via `--8<--`)
-2. Ensure `docs/docs/modules/spector-{module}.md` exists with snippet include:
-   ```markdown
-   --8<-- "spector-{module}/README.md"
-   ```
-3. Ensure nav entry exists in `docs/mkdocs.yml` under `Modules:`
-
-### Step 3: Update Config Docs
-
-If `SpectorConfig`, `SpectorProperties`, or `SpectorConfigFactory` changed:
-
-1. Extract current defaults from `SpectorConfigFactory.java` (source of truth)
-2. Update `spector-config/src/main/resources/spector-defaults.yml`
-3. Update `docs/docs/configuration/parameters.md`
-4. Grep for old path references: `grep -rn "old-path" docs/ scripts/ *.md`
-
-### Step 4: Update Design Docs
-
-If binary layouts, WAL format, or synapse headers changed:
-
-1. Cross-reference with `spector-memory/RnD/wal_design_spec.md` (design source of truth)
-2. Update RFC-style wire format diagrams in `docs/docs/memory/wal-design.md`
-3. Update `docs/docs/memory/panama-design.md` if record layout changed
-
-### Step 5: Fix Nav & Cross-References
-
-1. Check `docs/mkdocs.yml` for:
-   - No duplicate `extra_css` or `extra_javascript` keys (YAML last-key-wins)
-   - All nav entries point to existing files
-   - No stale module entries (deleted modules)
-2. Check for pages not in nav:
-   ```bash
-   python -m mkdocs build --clean 2>&1 | grep "not included in the nav"
-   ```
-
-### Step 6: Verify
-
-```bash
-cd docs
-python -m mkdocs build --clean
-```
-
-**Must have:**
-- Zero "page not in nav" warnings for modules
-- Zero "link target not found" warnings for files we control
-- All `--8<--` snippet includes resolve to existing files
-
-## MkDocs Quick Reference
-
-| Task | Command |
-|---|---|
-| Build site | `cd docs && python -m mkdocs build --clean` |
-| Serve locally | `cd docs && python -m mkdocs serve --dev-addr 127.0.0.1:8085` |
-| Check warnings | `python -m mkdocs build --clean 2>&1 \| grep WARNING` |
-
-**Stack:** MkDocs 1.6.1 + Material for MkDocs 9.7.6
diff --git a/.agents/skills/incremental-commits/SKILL.md b/.agents/skills/incremental-commits/SKILL.md
deleted file mode 100644
index d266a00..0000000
--- a/.agents/skills/incremental-commits/SKILL.md
+++ /dev/null
@@ -1,115 +0,0 @@
-# Skill: Incremental Commits
-
-This skill defines the process for creating clean, logical, component-grouped git commits following the project's Conventional Commits standard.
-
-## Trigger
-
-This skill is triggered when:
-- The user requests "commit", "incremental commit", or "commit all changes"
-- After completing a feature or fix with multiple file changes
-- As the final step in the Feature Development workflow
-
-## Instructions
-
-### Step 1: Inventory Changes
-
-```bash
-git status --short
-git diff --cached --name-only   # check for already-staged files
-```
-
-If there are staged files, decide: unstage with `git reset HEAD -- .` to start clean, or commit staged files first.
-
-### Step 2: Group by Logical Unit
-
-Group changes in this strict dependency order. Each group becomes one commit:
-
-| Priority | Category | Commit Type | Example |
-|---|---|---|---|
-| 1 | **Module deletions** | `refactor:` | `refactor: remove spector-server module` |
-| 2 | **Build/POM changes** | `build:` | `build: remove server/cluster from reactor` |
-| 3 | **Foundation** (core, commons, config, storage) | `feat/refactor({mod}):` | `refactor(config): add PersistenceFiles record` |
-| 4 | **Embedding** (embed-api, embed-ollama) | `feat/refactor({mod}):` | |
-| 5 | **Search** (index, query, gpu) | `feat/refactor({mod}):` | `feat(index): sharded disk HNSW persistence` |
-| 6 | **Intelligence** (engine, memory, rag, ingestion) | `feat/refactor({mod}):` | `feat(memory): WAL corruption recovery` |
-| 7 | **Runtime** (runtime, node, mcp, cli, client) | `feat/refactor({mod}):` | |
-| 8 | **Infrastructure** (metrics, bench, dist, spring) | `feat({mod}):` | `feat(metrics): Prometheus instrumentation` |
-| 9 | **New modules** (whole new `spector-*`) | `feat({mod}):` | `feat(node): spector-node unified server` |
-| 10 | **Documentation** | `docs:` | `docs: update WAL design deep-dive` |
-| 11 | **Scripts/CI/deploy** | `chore:` or `build:` | `chore: update MCP config and scripts` |
-| 12 | **Test files** | `test:` | `test: update engine and memory test suites` |
-| 13 | **Project meta** | `docs:` or `chore:` | `docs: update README and CHANGELOG` |
-
-### Step 3: Commit Each Group
-
-For each group:
-
-```bash
-git add <files-in-group>
-git commit -m "<type>(<scope>): <short description>
-
-- Bullet explaining what changed
-- Bullet explaining why (if non-obvious)"
-```
-
-**Rules:**
-- Production source (`src/main/`) and its tests (`src/test/`) in the same module CAN go in the same commit if they are part of the same logical change
-- However, if changes span many modules, keep tests in a separate final commit
-- Never mix unrelated modules in one commit
-- POM changes go with the module they affect, OR in a separate `build:` commit if they affect multiple modules
-
-### Step 4: Verify
-
-```bash
-git log --oneline -N      # verify clean history
-mvn test -pl <module>     # verify changed modules still build
-```
-
-### Commit Message Format
-
-```
-<type>(<scope>): <imperative short description>
-
-<optional body — explain WHY, not WHAT>
-
-- Bullet point 1
-- Bullet point 2
-```
-
-| Type | When |
-|---|---|
-| `feat` | New functionality, new class, new API |
-| `fix` | Bug fix, test fix, correction |
-| `perf` | Performance improvement (must include numbers) |
-| `refactor` | Code restructuring with no behavior change |
-| `docs` | Documentation only |
-| `test` | Adding or updating tests only |
-| `build` | POM, Maven, CI, dependency changes |
-| `chore` | Scripts, tooling, config, non-code |
-
-**Scope:** Module name without `spector-` prefix. Omit scope for cross-cutting changes.
-
-## Examples
-
-```
-feat(memory): WAL corruption recovery with torn-write detection
-
-- Torn writes at EOF detected via magic/CRC failure, resolved by truncate()
-- Mid-log corruption quarantined to .quarantine/ to prevent data divergence
-- ReentrantLock replaces synchronized for virtual thread safety
-```
-
-```
-refactor: remove spector-cluster module (deferred to V3 roadmap)
-
-Cluster coordination, shard management, and replication are
-planned for V3. Removing premature scaffolding to reduce build
-surface and test noise.
-```
-
-```
-build: remove server/cluster from reactor, update POM dependencies
-
-- Remove spector-server and spector-cluster from root POM modules
-- Update dependency versions and module cross-references
-```
diff --git a/.agents/skills/update-roadmap/SKILL.md b/.agents/skills/update-roadmap/SKILL.md
deleted file mode 100644
index 6fbe4ae..0000000
--- a/.agents/skills/update-roadmap/SKILL.md
+++ /dev/null
@@ -1,99 +0,0 @@
-# Skill: Update Roadmap
-
-This skill enables the agent to dynamically and consistently manage the project roadmap for Spector, ensuring perfect synchronization between the root `README.md` and the detailed documentation in `docs/docs/roadmap.md`.
-
-## Trigger
-
-This skill is automatically triggered when the user requests roadmap modifications, such as:
-- Adding a new feature or research goal.
-- Completing a planned feature or task.
-- Deprioritizing or marking a feature as not planned.
-- Removing a feature completely from the roadmap.
-- Automatically whenever a task inside a plan is completed, to keep the roadmap in sync.
-
-## Workspace Requirements
-
-- The repository root must contain this skill package under `.agents/skills/update-roadmap/`
-- The helper scripts must be located at:
-  - Windows: `.agents/skills/update-roadmap/scripts/update-roadmap.ps1`
-  - Unix/Linux/macOS: `.agents/skills/update-roadmap/scripts/update-roadmap.sh`
-- The root must contain `README.md` with the checklist under `## 📈 Roadmap`
-- The docs folder must contain `docs/docs/roadmap.md` with the Summary Table and categories.
-
-## Instructions for the Agent
-
-When this skill is triggered, you must **never** manually edit the Markdown files (`README.md` or `docs/docs/roadmap.md`). Instead, you must run the PowerShell script `update-roadmap.ps1` or Bash script `update-roadmap.sh` located inside this skill package depending on your operating system environment.
-
-### Action Mapping
-
-Determine the appropriate action verb based on the user's request:
-
-#### 1. Add Action (`-Action Add`)
-Use when introducing a new feature, index, optimization, or research target.
-- **Syntax (Windows)**:
-  ```powershell
-  powershell -ExecutionPolicy Bypass -File .agents/skills/update-roadmap/scripts/update-roadmap.ps1 -Action Add -Name "<Feature Name>" -Description "<One-line description>" -Category <Compression|Agentic|Compute|Runtime|Distributed> -Status <Planned|Exploratory|Research> -Compression "<savings>" -Recall "<impact>" -Effort <Low|Medium|High> -DetailText "<Detailed markdown specifications>"
-  ```
-- **Syntax (Unix/Linux/macOS)**:
-  ```bash
-  .agents/skills/update-roadmap/scripts/update-roadmap.sh -Action Add -Name "<Feature Name>" -Description "<One-line description>" -Category <Compression|Agentic|Compute|Runtime|Distributed> -Status <Planned|Exploratory|Research> -Compression "<savings>" -Recall "<impact>" -Effort <Low|Medium|High> -DetailText "<Detailed markdown specifications>"
-  ```
-- **Arguments**:
-  - `-Name`: The exact name of the feature.
-  - `-Description`: One-line summary (goes to README checklist).
-  - `-Category`: Workspace category (`Compression`, `Agentic`, `Compute`, `Runtime`, `Distributed`).
-  - `-Status`: One of `Planned`, `Exploratory`, `Research` (defaults to `Planned`).
-  - `-Compression`: Projected space savings (e.g. "+25%", "8x", "N/A").
-  - `-Recall`: Projected recall impact (e.g. "None", "-2%").
-  - `-Effort`: Implementation effort (`Low`, `Medium`, `High`).
-  - `-DetailText`: Detailed multi-line markdown block to append under the category details.
-
-#### 2. Complete Action (`-Action Complete`)
-Use when a feature is successfully implemented, verified, and merged.
-- **Syntax (Windows)**:
-  ```powershell
-  powershell -ExecutionPolicy Bypass -File .agents/skills/update-roadmap/scripts/update-roadmap.ps1 -Action Complete -Name "<Feature Name>"
-  ```
-- **Syntax (Unix/Linux/macOS)**:
-  ```bash
-  .agents/skills/update-roadmap/scripts/update-roadmap.sh -Action Complete -Name "<Feature Name>"
-  ```
-- **Behavior**:
-  - Marks the checkbox completed in `README.md` (`- [x] **Feature Name**`).
-  - Moves the detailed block to `## Recently Completed (Archive)` in `docs/docs/roadmap.md`.
-  - Updates the Summary Table row to `✅ Done`.
-
-#### 3. Deprioritize Action (`-Action Deprioritize`)
-Use when a feature is put on hold, marked not planned, or deferred.
-- **Syntax (Windows)**:
-  ```powershell
-  powershell -ExecutionPolicy Bypass -File .agents/skills/update-roadmap/scripts/update-roadmap.ps1 -Action Deprioritize -Name "<Feature Name>"
-  ```
-- **Syntax (Unix/Linux/macOS)**:
-  ```bash
-  .agents/skills/update-roadmap/scripts/update-roadmap.sh -Action Deprioritize -Name "<Feature Name>"
-  ```
-- **Behavior**:
-  - Updates Summary Table status to `🔴 Not planned`.
-  - Updates detailed block status header to `🔴 Not Planned`.
-
-#### 4. Remove Action (`-Action Remove`)
-Use when a feature is entirely excised from the project scope.
-- **Syntax (Windows)**:
-  ```powershell
-  powershell -ExecutionPolicy Bypass -File .agents/skills/update-roadmap/scripts/update-roadmap.ps1 -Action Remove -Name "<Feature Name>"
-  ```
-- **Syntax (Unix/Linux/macOS)**:
-  ```bash
-  .agents/skills/update-roadmap/scripts/update-roadmap.sh -Action Remove -Name "<Feature Name>"
-  ```
-- **Behavior**:
-  - Deletes checkbox from `README.md`.
-  - Deletes detailed description and Summary Table row from `docs/docs/roadmap.md`.
-
-### Verification Steps
-
-After executing the script, the agent must:
-1. Verify the exit code is 0 and output confirms successful modification.
-2. Run `git diff` to review all modified lines across `README.md` and `docs/docs/roadmap.md`.
-3. Confirm that the checkbox states, table rows, and detailed sections align perfectly.
diff --git a/.agents/skills/update-roadmap/scripts/update-roadmap.ps1 b/.agents/skills/update-roadmap/scripts/update-roadmap.ps1
deleted file mode 100644
index 5cfbfd7..0000000
--- a/.agents/skills/update-roadmap/scripts/update-roadmap.ps1
+++ /dev/null
@@ -1,362 +0,0 @@
-#Requires -Version 5.1
-<#
-.SYNOPSIS
-    Automates Spector Search roadmap updates across README.md and docs/docs/roadmap.md.
-.DESCRIPTION
-    This script provides an automated workflow to manage planned, active, completed, and
-    deprioritized features. It automatically updates the checklist in README.md, reorganizes
-    categories and appends archives in docs/docs/roadmap.md, and maintains the summary tables.
-.PARAMETER Action
-    The roadmap operation: Add, Complete, Deprioritize, or Remove.
-.PARAMETER Name
-    The name of the feature (e.g., "gRPC Replication Transport").
-.PARAMETER Description
-    A concise one-line description of the feature.
-.PARAMETER Category
-    The category for the feature: Compression, Agentic, Compute, Runtime, or Distributed.
-.PARAMETER Status
-    The feature status: Planned, Done, Exploratory, or Research.
-.PARAMETER DetailText
-    Optional multi-line detailed markdown description for docs/docs/roadmap.md.
-.PARAMETER Compression
-    The expected compression impact for the Summary Table (e.g. "+25%", "8x", "N/A"). Default: "N/A".
-.PARAMETER Recall
-    The expected recall impact for the Summary Table (e.g. "None", "-2%", "N/A"). Default: "None".
-.PARAMETER Effort
-    The expected implementation effort for the Summary Table (e.g. "Low", "Medium", "High"). Default: "Medium".
-.EXAMPLE
-    .agents\skills\update-roadmap\scripts\update-roadmap.ps1 -Action Add -Name "Hardware Cosine SIMD" -Description "Optimized cosine bounds" -Category Compute -Status Planned -Effort Low
-.EXAMPLE
-    .agents\skills\update-roadmap\scripts\update-roadmap.ps1 -Action Complete -Name "Hardware Cosine SIMD"
-#>
-
-[CmdletBinding()]
-param (
-    [Parameter(Mandatory = $true)]
-    [ValidateSet('Add', 'Complete', 'Deprioritize', 'Remove')]
-    [string]$Action,
-
-    [Parameter(Mandatory = $true)]
-    [string]$Name,
-
-    [Parameter(Mandatory = $false)]
-    [string]$Description = "",
-
-    [Parameter(Mandatory = $false)]
-    [ValidateSet('Compression', 'Agentic', 'Compute', 'Runtime', 'Distributed')]
-    [string]$Category = "Runtime",
-
-    [Parameter(Mandatory = $false)]
-    [ValidateSet('Planned', 'Done', 'Exploratory', 'Research')]
-    [string]$Status = "Planned",
-
-    [Parameter(Mandatory = $false)]
-    [string]$DetailText = "",
-
-    [Parameter(Mandatory = $false)]
-    [string]$Compression = "N/A",
-
-    [Parameter(Mandatory = $false)]
-    [string]$Recall = "None",
-
-    [Parameter(Mandatory = $false)]
-    [string]$Effort = "Medium"
-)
-
-# == Paths ==
-$workspaceRoot = (Get-Item "$PSScriptRoot\..\..\..\..").FullName
-$readmePath = Join-Path $workspaceRoot "README.md"
-$roadmapPath = Join-Path $workspaceRoot "docs\docs\roadmap.md"
-
-if (-not (Test-Path $readmePath)) {
-    Write-Error "README.md not found at $readmePath"
-    return
-}
-if (-not (Test-Path $roadmapPath)) {
-    Write-Error "docs/docs/roadmap.md not found at $roadmapPath"
-    return
-}
-
-# Resolve category headers
-$categoryHeaderMap = @{
-    'Compression' = '## Compression & Quantization'
-    'Agentic'     = '## Agentic AI'
-    'Compute'     = '## Compute & Hardware'
-    'Runtime'     = '## Runtime & Deployment'
-    'Distributed' = '## Distributed Clustering & Replication'
-}
-
-$emojiPlanned     = [char]::ConvertFromUtf32(0x1F51C)
-$emojiDone        = [char]::ConvertFromUtf32(0x2705)
-$emojiResearch    = [char]::ConvertFromUtf32(0x1F52C)
-$emojiNotPlanned   = [char]::ConvertFromUtf32(0x1F534)
-
-$statusIconMap = @{
-    'Planned'     = "$emojiPlanned Planned"
-    'Done'        = "$emojiDone Done"
-    'Exploratory' = "$emojiResearch Exploratory"
-    'Research'    = "$emojiResearch Research"
-}
-
-$statusDetailsIconMap = @{
-    'Planned'     = $emojiPlanned
-    'Done'        = $emojiDone
-    'Exploratory' = $emojiResearch
-    'Research'    = $emojiResearch
-}
-
-$cleanAnchor = $Name.ToLower().Replace(' ', '-').Replace('&', 'and').Replace('(', '').Replace(')', '').Replace('/', '-')
-
-# =============================================================================
-# ACTION: ADD
-# =============================================================================
-if ($Action -eq 'Add') {
-    Write-Host "Adding feature '$Name' to roadmap..."
-
-    # 1. Update README.md
-    $readmeContent = Get-Content $readmePath -Raw
-    $newReadmeLine = "- [ ] $Name ($Description)"
-    
-    # Insert before the closing roadmap link
-    $targetLine = "> See the [detailed Roadmap]"
-    if ($readmeContent -match [regex]::Escape($targetLine)) {
-        $readmeContent = $readmeContent -replace [regex]::Escape($targetLine), "$newReadmeLine`n`n$targetLine"
-        Set-Content $readmePath $readmeContent -NoNewline
-        Write-Host "  [OK] README.md updated."
-    } else {
-        Write-Warning "Could not locate roadmap section in README.md."
-    }
-
-    # 2. Update docs/docs/roadmap.md Detailed Section
-    $roadmapContent = Get-Content $roadmapPath -Raw
-    $targetHeader = $categoryHeaderMap[$Category]
-    
-    $statusText = $statusDetailsIconMap[$Status]
-    
-    # Construct detailed block natively in a multi-line single-quoted string template
-    $template = '### {0} {1} {{#{2}}}
-
-!!! info "Status: {3}"
-    {4}
-
-{5}
-
----'
-    $detailsBlock = $template -f $statusText, $Name, $cleanAnchor, $Status, $Description, $DetailText
-
-    if ($roadmapContent -match [regex]::Escape($targetHeader)) {
-        $roadmapContent = $roadmapContent -replace [regex]::Escape($targetHeader), ($targetHeader + "`r`n`r`n" + $detailsBlock)
-        Write-Host "  [OK] Detailed section in roadmap.md updated."
-    } else {
-        Write-Warning "Could not locate category header '$targetHeader' in docs/docs/roadmap.md."
-    }
-
-    # 3. Update Summary Table in docs/docs/roadmap.md
-    $lines = $roadmapContent -split '\r?\n'
-    $newLines = [System.Collections.Generic.List[string]]::new()
-    $tableIndex = 0
-    $highestIndex = 0
-    $inSummaryTable = $false
-
-    for ($i = 0; $i -lt $lines.Count; $i++) {
-        $line = $lines[$i]
-        $newLines.Add($line)
-
-        if ($line -match '## Summary Table') {
-            $inSummaryTable = $true
-        }
-
-        # Detect index in table rows only inside the summary table section
-        if ($inSummaryTable -and $line -match '^\|\s*(\d+)\s*\|') {
-            $idx = [int]$Matches[1]
-            if ($idx -gt $highestIndex) {
-                $highestIndex = $idx
-            }
-            $tableIndex = $i
-        }
-    }
-
-    # Construct new row
-    $newIdx = $highestIndex + 1
-    $statusIcon = $statusIconMap[$Status]
-    $newRow = '| {0} | **{1}** | {2} | {3} | {4} | {5} |' -f $newIdx, $Name, $Compression, $Recall, $Effort, $statusIcon
-
-    # Insert new row right after the last table line
-    $newLines.Insert($tableIndex + 1, $newRow)
-    Set-Content $roadmapPath ($newLines -join "`r`n")
-    Write-Host "  [OK] Summary Table in roadmap.md updated with row $newIdx."
-} elseif ($Action -eq 'Complete') {
-    # =============================================================================
-    # ACTION: COMPLETE
-    # =============================================================================
-    Write-Host "Completing feature '$Name'..."
-
-    # 1. Update README.md (check checkbox)
-    $readmeContent = Get-Content $readmePath -Raw
-    
-    # Escape target checkbox regex
-    $regexTarget = "- \[\s*\]\s*" + [regex]::Escape($Name)
-    if ($readmeContent -match $regexTarget) {
-        $readmeContent = [regex]::Replace($readmeContent, $regexTarget, "- [x] **$Name**")
-        Set-Content $readmePath $readmeContent -NoNewline
-        Write-Host "  [OK] README.md checklist updated."
-    } else {
-        Write-Warning "Could not locate incomplete checkbox for '$Name' in README.md."
-    }
-
-    # 2. Update docs/docs/roadmap.md Detailed Section & Reorganize Archive
-    $roadmapContent = Get-Content $roadmapPath -Raw
-    
-    # Locate detailed section block via generic status match
-    $escapedName = [regex]::Escape($Name)
-    $sectionRegex = '(?s)###\s+\S+\s+' + $escapedName + '\s+\{#' + $cleanAnchor + '\}.*?---(?:\r?\n|$)'
-
-    if ($roadmapContent -match $sectionRegex) {
-        $capturedBlock = $Matches[0]
-        
-        # Remove from active category
-        $roadmapContent = $roadmapContent -replace [regex]::Escape($capturedBlock), ""
-        
-        # Format the block for Recently Completed archive
-        $capturedBlock = [regex]::Replace($capturedBlock, "^###\s+\S+", "### $emojiDone")
-        $capturedBlock = $capturedBlock -replace "Status:\s*(Planned|Exploratory|Research)", "Status: Done"
-        $capturedBlock = $capturedBlock -replace "!!! info", "!!! success"
-        $capturedBlock = $capturedBlock -replace "Planned|Exploratory|Research", "Completed"
-        
-        # Append to Recently Completed section
-        $archiveHeader = "## Recently Completed (Archive)"
-        if ($roadmapContent -match [regex]::Escape($archiveHeader)) {
-            $roadmapContent = $roadmapContent -replace [regex]::Escape($archiveHeader), ($archiveHeader + "`r`n`r`n" + $capturedBlock)
-            Write-Host "  [OK] Detailed section moved to Recently Completed (Archive)."
-        } else {
-            # Create Recently Completed section if not present
-            $roadmapContent = $roadmapContent + "`r`n`r`n---\r`n\r`n## Recently Completed (Archive)`r`n`r`n" + $capturedBlock
-            Write-Host "  [OK] Recently Completed (Archive) section initialized and updated."
-        }
-    } else {
-        Write-Warning "Could not find detailed roadmap block for '$Name' in docs/docs/roadmap.md."
-    }
-
-    # 3. Update Summary Table Status to Done
-    $lines = $roadmapContent -split '\r?\n'
-    $newLines = [System.Collections.Generic.List[string]]::new()
-    $tableUpdated = $false
-    $inSummaryTable = $false
-
-    foreach ($line in $lines) {
-        if ($line -match '## Summary Table') {
-            $inSummaryTable = $true
-        }
-        if ($inSummaryTable -and $line -match ('^\|\s*(\d+)\s*\|\s*\*\*' + $escapedName + '\*\*')) {
-            # Replace the status column (last column) with completed check
-            $parts = $line -split '\|'
-            $parts[$parts.Length - 2] = " $emojiDone Done "
-            $line = $parts -join '|'
-            $tableUpdated = $true
-        }
-        $newLines.Add($line)
-    }
-
-    Set-Content $roadmapPath ($newLines -join "`r`n")
-    if ($tableUpdated) {
-        Write-Host "  [OK] Summary Table row updated to $emojiDone Done."
-    } else {
-        Write-Warning "Could not find Summary Table row for '$Name'."
-    }
-} elseif ($Action -eq 'Deprioritize') {
-    # =============================================================================
-    # ACTION: DEPRIORITIZE
-    # =============================================================================
-    Write-Host "Deprioritizing feature '$Name'..."
-
-    # 1. Update Summary Table Status in docs/docs/roadmap.md to Not Planned
-    $roadmapContent = Get-Content $roadmapPath -Raw
-    $escapedName = [regex]::Escape($Name)
-    $lines = $roadmapContent -split '\r?\n'
-    $newLines = [System.Collections.Generic.List[string]]::new()
-    $tableUpdated = $false
-    $inSummaryTable = $false
-
-    foreach ($line in $lines) {
-        if ($line -match '## Summary Table') {
-            $inSummaryTable = $true
-        }
-        if ($inSummaryTable -and $line -match ('^\|\s*(\d+)\s*\|\s*\*\*' + $escapedName + '\*\*')) {
-            $parts = $line -split '\|'
-            $parts[$parts.Length - 2] = " $emojiNotPlanned Not planned "
-            $line = $parts -join '|'
-            $tableUpdated = $true
-        }
-        $newLines.Add($line)
-    }
-
-    Set-Content $roadmapPath ($newLines -join "`r`n")
-    if ($tableUpdated) {
-        Write-Host "  [OK] Summary Table row updated to $emojiNotPlanned Not planned."
-    } else {
-        Write-Warning "Could not find Summary Table row for '$Name'."
-    }
-
-    # 2. Update status in detailed description block
-    $roadmapContent = Get-Content $roadmapPath -Raw
-    $sectionRegex = '(?s)###\s+\S+\s+' + $escapedName + '\s+\{#' + $cleanAnchor + '\}.*?---(?:\r?\n|$)'
-    
-    if ($roadmapContent -match $sectionRegex) {
-        $targetBlock = $Matches[0]
-        $replacedBlock = [regex]::Replace($targetBlock, "(?m)^###\s+\S+", "### $emojiNotPlanned")
-        $replacedBlock = $replacedBlock -replace 'Status:\s*[^"\r\n]+', "Status: Not Planned"
-        
-        $roadmapContent = $roadmapContent -replace [regex]::Escape($targetBlock), $replacedBlock
-        Set-Content $roadmapPath $roadmapContent -NoNewline
-        Write-Host "  [OK] Detailed section status updated to $emojiNotPlanned Not Planned."
-    }
-} elseif ($Action -eq 'Remove') {
-    # =============================================================================
-    # ACTION: REMOVE
-    # =============================================================================
-    Write-Host "Removing feature '$Name' completely from roadmap..."
-
-    # 1. Remove from README.md
-    $readmeContent = Get-Content $readmePath -Raw
-    $escapedName = [regex]::Escape($Name)
-    $lineRegex = '(?m)^-\s*\[[\s*x]?\]\s*(?:\*\*)?' + $escapedName + '(?:\*\*)?.*?\r?\n'
-    
-    if ($readmeContent -match $lineRegex) {
-        $readmeContent = [regex]::Replace($readmeContent, $lineRegex, "")
-        Set-Content $readmePath $readmeContent -NoNewline
-        Write-Host "  [OK] Removed from README.md checklist."
-    }
-
-    # 2. Remove detailed description from docs/docs/roadmap.md
-    $roadmapContent = Get-Content $roadmapPath -Raw
-    $sectionRegex = '(?s)###\s+\S+\s+' + $escapedName + '\s+\{#' + $cleanAnchor + '\}.*?---(?:\r?\n|$)'
-    
-    if ($roadmapContent -match $sectionRegex) {
-        $roadmapContent = $roadmapContent -replace $sectionRegex, ""
-        Write-Host "  [OK] Removed detailed description block."
-    }
-
-    # 3. Remove row from Summary Table
-    $lines = $roadmapContent -split '\r?\n'
-    $newLines = [System.Collections.Generic.List[string]]::new()
-    $rowRemoved = $false
-    $inSummaryTable = $false
-
-    foreach ($line in $lines) {
-        if ($line -match '## Summary Table') {
-            $inSummaryTable = $true
-        }
-        if ($inSummaryTable -and $line -match ('^\|\s*(\d+)\s*\|\s*(?:\*\*)?' + $escapedName + '(?:\*\*)?\s*\|')) {
-            $rowRemoved = $true
-            continue; # Skip adding this line to delete the row
-        }
-        $newLines.Add($line)
-    }
-
-    Set-Content $roadmapPath ($newLines -join "`r`n")
-    if ($rowRemoved) {
-        Write-Host "  [OK] Removed row from Summary Table."
-    }
-}
-
-Write-Host "Roadmap update completed successfully!" -ForegroundColor Green
diff --git a/.agents/skills/update-roadmap/scripts/update-roadmap.sh b/.agents/skills/update-roadmap/scripts/update-roadmap.sh
deleted file mode 100644
index 442e7bb..0000000
--- a/.agents/skills/update-roadmap/scripts/update-roadmap.sh
+++ /dev/null
@@ -1,369 +0,0 @@
-#!/usr/bin/env bash
-
-# Automates Spector Search roadmap updates across README.md and docs/docs/roadmap.md on Unix/Linux/macOS.
-
-set -e
-
-# --- Default Arguments ---
-ACTION=""
-NAME=""
-DESCRIPTION=""
-CATEGORY="Runtime"
-STATUS="Planned"
-DETAIL_TEXT=""
-COMPRESSION="N/A"
-RECALL="None"
-EFFORT="Medium"
-
-# --- Parse Arguments ---
-while [[ $# -gt 0 ]]; do
-  case $1 in
-    -Action|-action|--action)
-      ACTION="$2"
-      shift 2
-      ;;
-    -Name|-name|--name)
-      NAME="$2"
-      shift 2
-      ;;
-    -Description|-description|--description)
-      DESCRIPTION="$2"
-      shift 2
-      ;;
-    -Category|-category|--category)
-      CATEGORY="$2"
-      shift 2
-      ;;
-    -Status|-status|--status)
-      STATUS="$2"
-      shift 2
-      ;;
-    -DetailText|-detailtext|--detailtext)
-      DETAIL_TEXT="$2"
-      shift 2
-      ;;
-    -Compression|-compression|--compression)
-      COMPRESSION="$2"
-      shift 2
-      ;;
-    -Recall|-recall|--recall)
-      RECALL="$2"
-      shift 2
-      ;;
-    -Effort|-effort|--effort)
-      EFFORT="$2"
-      shift 2
-      ;;
-    *)
-      echo "Unknown argument: $1"
-      exit 1
-      ;;
-  esac
-done
-
-# --- Validate Required arguments ---
-if [ -z "$ACTION" ] || [ -z "$NAME" ]; then
-  echo "Error: -Action and -Name are required arguments."
-  echo "Usage: ./update-roadmap.sh -Action [Add|Complete|Deprioritize|Remove] -Name \"Feature Name\" [options]"
-  exit 1
-fi
-
-if [[ ! "$ACTION" =~ ^(Add|Complete|Deprioritize|Remove)$ ]]; then
-  echo "Error: Invalid action '$ACTION'. Must be Add, Complete, Deprioritize, or Remove."
-  exit 1
-fi
-
-# --- Resolve Paths ---
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-WORKSPACE_ROOT="$(cd "$SCRIPT_DIR/../../../.." && pwd)"
-README_PATH="$WORKSPACE_ROOT/README.md"
-ROADMAP_PATH="$WORKSPACE_ROOT/docs/docs/roadmap.md"
-
-if [ ! -f "$README_PATH" ]; then
-  echo "Error: README.md not found at $README_PATH"
-  exit 1
-fi
-if [ ! -f "$ROADMAP_PATH" ]; then
-  echo "Error: docs/docs/roadmap.md not found at $ROADMAP_PATH"
-  exit 1
-fi
-
-# --- Resolve Icons & Anchors ---
-EMOJI_PLANNED="🔜"
-EMOJI_DONE="✅"
-EMOJI_RESEARCH="🔬"
-EMOJI_NOT_PLANNED="🔴"
-
-case "$STATUS" in
-  Planned)
-    STATUS_ICON="$EMOJI_PLANNED Planned"
-    STATUS_DETAILS_ICON="$EMOJI_PLANNED"
-    ;;
-  Done)
-    STATUS_ICON="$EMOJI_DONE Done"
-    STATUS_DETAILS_ICON="$EMOJI_DONE"
-    ;;
-  Exploratory|Research)
-    STATUS_ICON="$EMOJI_RESEARCH $STATUS"
-    STATUS_DETAILS_ICON="$EMOJI_RESEARCH"
-    ;;
-  *)
-    STATUS_ICON="$STATUS"
-    STATUS_DETAILS_ICON=""
-    ;;
-esac
-
-# Clean anchor (e.g. "Hardware Cosine SIMD" -> "hardware-cosine-simd")
-CLEAN_ANCHOR=$(echo "$NAME" | tr '[:upper:]' '[:lower:]' | sed 's/ /-/g; s/\&/and/g; s/(//g; s/)//g; s/\///g')
-
-# =============================================================================
-# ACTION: ADD
-# =============================================================================
-if [ "$ACTION" = "Add" ]; then
-  echo "Adding feature '$NAME' to roadmap..."
-
-  # 1. Update README.md
-  export TARGET_LINE="> See the [detailed Roadmap]"
-  export NEW_README_LINE="- [ ] $NAME ($DESCRIPTION)"
-  
-  if grep -F -q "$TARGET_LINE" "$README_PATH"; then
-    # Use Perl for clean multi-line injection without BSD/GNU sed incompatibilities
-    perl -i -pe 's/\Q$ENV{TARGET_LINE}\E/$ENV{NEW_README_LINE}\n\n$ENV{TARGET_LINE}/g' "$README_PATH"
-    echo "  [OK] README.md updated."
-  else
-    echo "Warning: Could not locate roadmap section in README.md."
-  fi
-
-  # 2. Update docs/docs/roadmap.md Detailed Section
-  CATEGORY_HEADER=""
-  case "$CATEGORY" in
-    Compression) CATEGORY_HEADER="## Compression & Quantization" ;;
-    Agentic)     CATEGORY_HEADER="## Agentic AI" ;;
-    Compute)     CATEGORY_HEADER="## Compute & Hardware" ;;
-    Runtime)     CATEGORY_HEADER="## Runtime & Deployment" ;;
-    Distributed) CATEGORY_HEADER="## Distributed Clustering & Replication" ;;
-  esac
-
-  DETAILS_BLOCK="### $STATUS_DETAILS_ICON $NAME {#$CLEAN_ANCHOR}
-
-!!! info \"Status: $STATUS\"
-    $DESCRIPTION
-
-$DETAIL_TEXT
-
----"
-
-  if grep -F -q "$CATEGORY_HEADER" "$ROADMAP_PATH"; then
-    export CATEGORY_HEADER
-    export DETAILS_BLOCK
-    perl -i -pe 's/\Q$ENV{CATEGORY_HEADER}\E/$ENV{CATEGORY_HEADER}\n\n$ENV{DETAILS_BLOCK}/g' "$ROADMAP_PATH"
-    echo "  [OK] Detailed section in roadmap.md updated."
-  else
-    echo "Warning: Could not locate category header '$CATEGORY_HEADER' in docs/docs/roadmap.md."
-  fi
-
-  # 3. Update Summary Table in docs/docs/roadmap.md
-  export NEW_ROW="| {IDX} | **$NAME** | $COMPRESSION | $RECALL | $EFFORT | $STATUS_ICON |"
-  perl -i -0777 -pe '
-    my ($doc, $table) = split(/## Summary Table/, $_, 2);
-    if ($table) {
-      my $highest = 0;
-      my $last_row = "";
-      while ($table =~ /^\|\s*(\d+)\s*\|.*$/mg) {
-        my $val = $1;
-        if ($val > $highest) {
-          $highest = $val;
-        }
-        $last_row = $&;
-      }
-      my $new_idx = $highest + 1;
-      my $row_template = $ENV{NEW_ROW};
-      $row_template =~ s/\{IDX\}/$new_idx/g;
-      my $eol = $table =~ /\r\n/ ? "\r\n" : "\n";
-      if ($last_row) {
-        $last_row =~ s/\r$//;
-        $table =~ s/\Q$last_row\E\r?\n/$last_row$eol$row_template$eol/m;
-      }
-      $_ = $doc . "## Summary Table" . $table;
-    }
-  ' "$ROADMAP_PATH"
-  echo "  [OK] Summary Table in roadmap.md updated."
-
-# =============================================================================
-# ACTION: COMPLETE
-# =============================================================================
-elif [ "$ACTION" = "Complete" ]; then
-  echo "Completing feature '$NAME'..."
-
-  # 1. Update README.md (check checkbox)
-  export NAME
-  perl -i -pe 's/-\s*\[\s*\]\s*\Q$ENV{NAME}\E/- [x] **$ENV{NAME}**/g' "$README_PATH"
-  echo "  [OK] README.md checklist updated."
-
-  # 2. Update docs/docs/roadmap.md Detailed Section & Reorganize Archive
-  export NAME
-  export CLEAN_ANCHOR
-  export EMOJI_DONE
-  perl -i -0777 -pe '
-    my $name = $ENV{NAME};
-    my $anchor = $ENV{CLEAN_ANCHOR};
-    my $emoji_done = $ENV{EMOJI_DONE};
-    my $escaped_name = quotemeta($name);
-    my $escaped_anchor = quotemeta($anchor);
-    
-    # Regex to find the detailed block
-    my $section_regex = qr/(?s)###\s+\S+\s+$escaped_name\s+\{#$escaped_anchor\}.*?---(?:\r?\n|$)/;
-    
-    if ($_ =~ /$section_regex/) {
-      my $captured_block = $&;
-      
-      # Remove from active category
-      $_ =~ s/\Q$captured_block\E//;
-      
-      # Format detailed block for Recently Completed archive
-      $captured_block =~ s/^###\s+\S+/### $emoji_done/;
-      $captured_block =~ s/Status:\s*(Planned|Exploratory|Research)/Status: Done/;
-      $captured_block =~ s/!!! info/!!! success/;
-      $captured_block =~ s/Planned|Exploratory|Research/Completed/g;
-      
-      # Check line endings of the file to preserve them
-      my $eol = $_ =~ /\r\n/ ? "\r\n" : "\n";
-      
-      # Append to Recently Completed section
-      my $archive_header = "## Recently Completed (Archive)";
-      if ($_ =~ /\Q$archive_header\E/) {
-        $_ =~ s/(\Q$archive_header\E)/$1$eol$eol$captured_block/;
-      } else {
-        $_ = $_ . $eol . $eol . "---" . $eol . $eol . "## Recently Completed (Archive)" . $eol . $eol . $captured_block;
-      }
-    }
-  ' "$ROADMAP_PATH"
-  echo "  [OK] Detailed section moved to Recently Completed (Archive)."
-
-  # 3. Update Summary Table Status to Done
-  export NAME
-  export EMOJI_DONE
-  perl -i -0777 -pe '
-    my ($doc, $table) = split(/## Summary Table/, $_, 2);
-    if ($table) {
-      my $name = $ENV{NAME};
-      my $escaped_name = quotemeta($name);
-      my @lines = split(/\r?\n/, $table);
-      for my $line (@lines) {
-        if ($line =~ /^\|\s*(\d+)\s*\|\s*\*\*$escaped_name\*\*/) {
-          my @parts = split(/\|/, $line, -1);
-          $parts[$#parts - 1] = " $ENV{EMOJI_DONE} Done ";
-          $line = join("|", @parts);
-        }
-      }
-      $table = join("\n", @lines);
-      if ($_ =~ /\r\n/) {
-        $table =~ s/\n/\r\n/g;
-      }
-      $_ = $doc . "## Summary Table" . $table;
-    }
-  ' "$ROADMAP_PATH"
-  echo "  [OK] Summary Table row updated to $EMOJI_DONE Done."
-
-# =============================================================================
-# ACTION: DEPRIORITIZE
-# =============================================================================
-elif [ "$ACTION" = "Deprioritize" ]; then
-  echo "Deprioritizing feature '$NAME'..."
-
-  # 1. Update Summary Table Status in docs/docs/roadmap.md to Not Planned
-  export NAME
-  export EMOJI_NOT_PLANNED
-  perl -i -0777 -pe '
-    my ($doc, $table) = split(/## Summary Table/, $_, 2);
-    if ($table) {
-      my $name = $ENV{NAME};
-      my $escaped_name = quotemeta($name);
-      my @lines = split(/\r?\n/, $table);
-      for my $line (@lines) {
-        if ($line =~ /^\|\s*(\d+)\s*\|\s*\*\*$escaped_name\*\*/) {
-          my @parts = split(/\|/, $line, -1);
-          $parts[$#parts - 1] = " $ENV{EMOJI_NOT_PLANNED} Not planned ";
-          $line = join("|", @parts);
-        }
-      }
-      $table = join("\n", @lines);
-      if ($_ =~ /\r\n/) {
-        $table =~ s/\n/\r\n/g;
-      }
-      $_ = $doc . "## Summary Table" . $table;
-    }
-  ' "$ROADMAP_PATH"
-  echo "  [OK] Summary Table row updated to $EMOJI_NOT_PLANNED Not planned."
-
-  # 2. Update status in detailed description block
-  export NAME
-  export CLEAN_ANCHOR
-  export EMOJI_NOT_PLANNED
-  perl -i -0777 -pe '
-    my $name = $ENV{NAME};
-    my $anchor = $ENV{CLEAN_ANCHOR};
-    my $emoji_not_planned = $ENV{EMOJI_NOT_PLANNED};
-    my $escaped_name = quotemeta($name);
-    my $escaped_anchor = quotemeta($anchor);
-    
-    # Regex to find the detailed block
-    my $section_regex = qr/(?s)###\s+\S+\s+$escaped_name\s+\{#$escaped_anchor\}.*?---(?:\r?\n|$)/;
-    
-    if ($_ =~ /$section_regex/) {
-      my $target_block = $&;
-      my $replaced_block = $target_block;
-      $replaced_block =~ s/^###\s+\S+/### $emoji_not_planned/m;
-      $replaced_block =~ s/Status:\s*[^"\n\r]+/Status: Not Planned/;
-      
-      $_ =~ s/\Q$target_block\E/$replaced_block/;
-    }
-  ' "$ROADMAP_PATH"
-  echo "  [OK] Detailed section status updated to $EMOJI_NOT_PLANNED Not Planned."
-
-# =============================================================================
-# ACTION: REMOVE
-# =============================================================================
-elif [ "$ACTION" = "Remove" ]; then
-  echo "Removing feature '$NAME' completely from roadmap..."
-
-  # 1. Remove from README.md
-  export NAME
-  perl -i -ne 'print unless /-\s*\[[\s*x]?\]\s*(?:\*\*)?\Q$ENV{NAME}\E/' "$README_PATH"
-  echo "  [OK] Removed from README.md checklist."
-
-  # 2. Remove detailed description from docs/docs/roadmap.md
-  export NAME
-  export CLEAN_ANCHOR
-  perl -i -0777 -pe '
-    my $name = $ENV{NAME};
-    my $anchor = $ENV{CLEAN_ANCHOR};
-    my $escaped_name = quotemeta($name);
-    my $escaped_anchor = quotemeta($anchor);
-    
-    my $section_regex = qr/(?s)###\s+\S+\s+$escaped_name\s+\{#$escaped_anchor\}.*?---(?:\r?\n|$)/;
-    $_ =~ s/$section_regex//;
-  ' "$ROADMAP_PATH"
-  echo "  [OK] Removed detailed description block."
-
-  # 3. Remove row from Summary Table
-  export NAME
-  perl -i -0777 -pe '
-    my ($doc, $table) = split(/## Summary Table/, $_, 2);
-    if ($table) {
-      my $name = $ENV{NAME};
-      my $escaped_name = quotemeta($name);
-      my @lines = split(/\r?\n/, $table);
-      @lines = grep { !/^\|\s*\d+\s*\|\s*(?:\*\*)?\Q$name\E/ } @lines;
-      $table = join("\n", @lines);
-      if ($_ =~ /\r\n/) {
-        $table =~ s/\n/\r\n/g;
-      }
-      $_ = $doc . "## Summary Table" . $table;
-    }
-  ' "$ROADMAP_PATH"
-  echo "  [OK] Removed row from Summary Table."
-
-fi
-
-echo "Roadmap update completed successfully!"
diff --git a/.agents/workflows/documentation-update.md b/.agents/workflows/documentation-update.md
deleted file mode 100644
index daedb83..0000000
--- a/.agents/workflows/documentation-update.md
+++ /dev/null
@@ -1,72 +0,0 @@
-# Workflow: Documentation Update
-
-Process for creating or updating documentation in the MkDocs Material site.
-
-## Trigger
-
-When creating new design docs, architecture pages, deep-dives, or the user requests documentation changes.
-
-## Steps
-
-### 1. Identify Scope
-
-Determine the documentation type:
-
-| Type | Location | Style |
-|---|---|---|
-| Architecture overview | `docs/docs/architecture/` | Mermaid diagrams, component descriptions |
-| Design deep-dive | `docs/docs/deep-dives/` | Technical analysis, benchmarks, trade-offs |
-| Memory subsystem | `docs/docs/memory/` | RFC wire format diagrams, neuroscience analogies |
-| API reference | `docs/docs/api-reference/` | Request/response examples, endpoint tables |
-| Module docs | `docs/docs/modules/` | Auto-included from `spector-*/README.md` via `--8<--` |
-| Configuration | `docs/docs/configuration/` | Parameter tables, YAML examples |
-| Getting started | `docs/docs/getting-started/` | Step-by-step tutorials |
-
-### 2. Check Source of Truth
-
-- Memory subsystem: `spector-memory/RnD/` specs are the design source of truth
-- Engine/Index: code + test behavior is source of truth
-- Configuration: `SpectorConfigFactory.java` defaults are source of truth
-
-### 3. Write Content
-
-Follow documentation standards:
-- **Binary layouts:** RFC-style wire format diagrams (see `wal-design.md`)
-- **Architecture:** Mermaid diagrams for component relationships
-- **Code examples:** Real, working snippets from the codebase
-- **Tables:** For configuration parameters, comparison matrices
-- **Admonitions:** Use MkDocs Material admonitions (`!!! note`, `!!! warning`)
-
-### 4. Update Navigation
-
-If this is a new page, add to `docs/mkdocs.yml` nav section:
-```yaml
-nav:
-  - Section:
-    - Page Title: path/to/page.md
-```
-
-### 5. Verify Build
-
-```bash
-cd docs
-python -m mkdocs build --clean
-```
-
-Fix any warnings about:
-- Pages not in nav
-- Broken cross-references
-- Invalid Mermaid syntax
-
-### 6. Preview (Optional)
-
-```bash
-cd docs
-python -m mkdocs serve --dev-addr 127.0.0.1:8085
-```
-
-### 7. Commit
-
-```
-docs: <description of what was documented>
-```
diff --git a/.agents/workflows/exception-hardening.md b/.agents/workflows/exception-hardening.md
deleted file mode 100644
index b08ca98..0000000
--- a/.agents/workflows/exception-hardening.md
+++ /dev/null
@@ -1,182 +0,0 @@
----
-description: Audit and harden exception handling for a feature or module, aligning all catch/throw sites with the SpectorException framework.
----
-
-## Trigger
-
-When the user asks to:
-- "Add exception handling" for a newly implemented feature
-- "Harden exceptions" in a module
-- "Audit error handling" for recent changes
-- "Align with the error framework" after building a new feature
-
-## Prerequisites
-
-Read the exception handling section of the coding standards skill:
-`.agents/skills/coding-standards/SKILL.md` → **Error Handling — SpectorException Framework**
-
-## Steps
-
-### 1. Identify Target Scope
-
-Determine what needs hardening:
-- A specific feature (e.g., "exception handling for the entity graph")
-- A module (e.g., "audit spector-memory")
-- Recent changes (e.g., "harden exceptions for the feature we just built")
-
-List all files involved. Focus on:
-- New classes added for the feature
-- Pipeline integration points (ingestion, recall, consolidation)
-- Persistence layers (save/load methods)
-- Public API methods
-
-### 2. Audit Existing Catch Sites
-
-Search for anti-patterns in the target files:
-
-```bash
-# Find generic Exception catches
-grep -rn "catch (Exception " spector-{module}/src/main/java/
-
-# Find UncheckedIOException throws
-grep -rn "UncheckedIOException" spector-{module}/src/main/java/
-
-# Find generic RuntimeException throws
-grep -rn "throw new RuntimeException" spector-{module}/src/main/java/
-
-# Find string concatenation in ErrorCode.format()
-grep -rn "ErrorCode\.\w*\.format(" spector-{module}/src/main/java/ | grep "+"
-
-# Find swallowed exceptions
-grep -rn "catch.*{" spector-{module}/src/main/java/ -A1 | grep -B1 "// ignored\|/\* \*/"
-```
-
-### 3. Determine Required Error Codes
-
-For each error condition identified:
-
-1. Check if an existing `ErrorCode` covers it (search `ErrorCode.java`)
-2. If not, add a new code under the correct category section:
-   - Validation: `SPE-100-xxx`
-   - Config: `SPE-110-xxx`
-   - Index: `SPE-200-xxx`
-   - Storage: `SPE-210-xxx`
-   - Embedding: `SPE-300-xxx`
-   - Memory: `SPE-310-xxx`
-   - GPU: `SPE-400-xxx`
-   - Server: `SPE-500-xxx`
-   - Client: `SPE-510-xxx`
-   - Ingestion: `SPE-600-xxx`
-   - Cluster: `SPE-700-xxx`
-   - Internal: `SPE-900-xxx`
-
-**Template:**
-```java
-/** Brief javadoc of when this error occurs. */
-FEATURE_OPERATION_FAILED  (310_0XX, ErrorCategory.MEMORY,
-        "Feature operation failed for {}: {}"),
-```
-
-### 4. Create Granular Exception Classes
-
-For each distinct error domain, create a `Spector{Domain}Exception`:
-
-**Location:** `spector-{module}/src/main/java/.../error/`
-
-**Template:**
-```java
-public class Spector{Domain}Exception extends Spector{Parent}Exception {
-    private final String operation;
-
-    public Spector{Domain}Exception(String operation) {
-        super(ErrorCode.FEATURE_OPERATION_FAILED, operation);
-        this.operation = operation;
-    }
-
-    public Spector{Domain}Exception(String operation, Throwable cause) {
-        super(ErrorCode.FEATURE_OPERATION_FAILED, cause, operation);
-        this.operation = operation;
-    }
-
-    public String getOperation() { return operation; }
-}
-```
-
-**Rules:**
-- Constructor args map 1:1 to `{}` placeholders in the ErrorCode template
-- No string concatenation — `errorCode.format(args)` handles formatting
-- Add typed context fields (operation, path, etc.)
-- Follow naming: `Spector{Domain}Exception`
-
-### 5. Fix Throw Sites
-
-Replace all anti-patterns with proper throws:
-
-| Before (❌) | After (✅) |
-|---|---|
-| `throw new UncheckedIOException(msg, e)` | `throw new Spector{Domain}Exception(args, e)` |
-| `throw new RuntimeException(msg)` | `throw new Spector{Domain}Exception(args)` |
-| `throw new SpectorException(ErrorCode.X, e, "concat" + var)` | `throw new Spector{Domain}Exception(arg1, arg2, e)` |
-
-### 6. Fix Catch Sites
-
-Apply the correct pattern based on context:
-
-**Graceful degradation** (enrichment steps that should NOT crash the pipeline):
-```java
-} catch (RuntimeException e) {
-    Spector{Domain}Exception ex = new Spector{Domain}Exception("operation", e);
-    log.warn(ex.getMessage());
-}
-```
-
-**IO failures** (persistence methods):
-```java
-} catch (IOException e) {
-    throw new Spector{Domain}PersistenceException("GraphType", path, e);
-}
-```
-
-**Validation** (public API entry points):
-```java
-if (param == null) {
-    throw new SpectorValidationException(ErrorCode.ARGUMENT_NULL, "paramName");
-}
-```
-
-**Never:**
-- `catch (Exception e)` — always catch the narrowest type (`RuntimeException`, `IOException`)
-- `catch (Exception e) { /* ignored */ }` — never swallow exceptions
-- String concatenation inside `ErrorCode.format()` or exception constructors
-
-### 7. Update Exception Hierarchy Documentation
-
-If new exception classes were added, update the hierarchy tree in:
-- `SpectorException.java` javadoc (lines 26-49)
-
-### 8. Verify
-
-```bash
-# Compile
-mvn compile -q
-
-# Run tests for the affected module
-mvn test -pl spector-{module}
-
-# Verify no remaining anti-patterns
-grep -rn "catch (Exception " spector-{module}/src/main/java/ | grep -v "// justified"
-grep -rn "throw new RuntimeException" spector-{module}/src/main/java/
-grep -rn "UncheckedIOException" spector-{module}/src/main/java/
-```
-
-### 9. Commit
-
-Follow the incremental-commits skill (`.agents/skills/incremental-commits/SKILL.md`):
-
-```
-feat(error): add {domain} exception hierarchy with ErrorCode integration
-
-New error codes: SPE-XXX-YYY through SPE-XXX-ZZZ
-New exceptions: Spector{A}Exception, Spector{B}Exception
-Hardened catch sites in: {list of files}
-```
diff --git a/.agents/workflows/feature-development.md b/.agents/workflows/feature-development.md
deleted file mode 100644
index 7d9c1b2..0000000
--- a/.agents/workflows/feature-development.md
+++ /dev/null
@@ -1,67 +0,0 @@
----
-description: End-to-end process for implementing a new feature in Spector, from understanding requirements to committing clean code.
----
-
-## Trigger
-
-When implementing a new feature, capability, or significant enhancement in any `spector-*` module.
-
-## Steps
-
-### 1. Understand Requirements
-
-- Read RnD specs if available (`spector-memory/RnD/` for memory subsystem)
-- Check the roadmap (`docs/docs/roadmap.md`) for planned features
-- Identify which module(s) the feature belongs in
-
-### 2. Verify Module Boundaries
-
-Before writing code, confirm the target module is correct:
-
-- Foundation (core, commons, config, storage) — shared abstractions
-- Search (index, query, gpu) — search algorithms
-- Intelligence (engine, memory, rag, ingestion) — orchestration
-- Runtime (runtime, node, mcp, cli) — entry points
-
-**Rule:** `spector-memory` and `spector-engine` never depend on each other.
-
-### 3. Implement
-
-- Follow coding standards (`.agents/skills/coding-standards/SKILL.md`)
-- Use `ReentrantLock` not `synchronized`
-- Use records for immutable data
-- Use section separators for class organization
-- Add SLF4J logging at appropriate levels
-
-### 4. Write Tests
-
-- JUnit 5 + AssertJ, `@TempDir` for file tests
-- At least 1 test per new public API method
-- Integration tests suffixed `*IntegrationTest`
-- Run: `mvn test -pl spector-{module}`
-
-### 5. Update Documentation
-
-Run the doc-sync skill (`.agents/skills/doc-sync/SKILL.md`):
-- Update module README if public API changed
-- Update config docs if defaults changed
-- Update design docs if binary layouts changed
-
-### 6. Build & Verify
-
-```bash
-mvn test -pl spector-{module}     # module tests
-mvn clean install                  # full reactor
-cd docs && python -m mkdocs build --clean  # docs build
-```
-
-### 7. Commit
-
-Run the incremental-commits skill (`.agents/skills/incremental-commits/SKILL.md`):
-- Group by component in dependency order
-- Conventional Commits format
-
-### 8. Update Roadmap (if applicable)
-
-Run the update-roadmap skill (`.agents/skills/update-roadmap/SKILL.md`):
-- Mark feature as completed if it was on the roadmap
diff --git a/.agents/workflows/module-lifecycle.md b/.agents/workflows/module-lifecycle.md
deleted file mode 100644
index e548c92..0000000
--- a/.agents/workflows/module-lifecycle.md
+++ /dev/null
@@ -1,129 +0,0 @@
----
-description: Process for adding, removing, or renaming Maven modules in the Spector reactor.
----
-
-# Workflow: Module Lifecycle
-
-Process for adding, removing, or renaming Maven modules in the Spector reactor.
-
-## Trigger
-
-When creating a new `spector-*` module, removing an obsolete module, or renaming/merging modules.
-
----
-
-## Adding a New Module
-
-### 1. Create Directory Structure
-
-```
-spector-{name}/
-├── pom.xml
-├── README.md
-└── src/
-    ├── main/java/com/spectrayan/spector/{name}/
-    └── test/java/com/spectrayan/spector/{name}/
-```
-
-### 2. Create POM
-
-- Parent: `com.spectrayan:spector:0.1.0-SNAPSHOT`
-- Add dependencies from the correct architecture layer
-- Include `--add-modules jdk.incubator.vector` in compiler args if needed
-
-### 3. Add to Root POM
-
-Add `<module>spector-{name}</module>` to root `pom.xml` in the correct layer position.
-
-### 4. Create README
-
-Include: purpose, architecture, usage examples, API summary.
-
-### 5. Create Docs Page
-
-Create `docs/docs/modules/spector-{name}.md`:
-```markdown
---8<-- "spector-{name}/README.md"
-```
-
-### 6. Update Nav
-
-Add to `docs/mkdocs.yml` under `Modules:` in correct position.
-
-### 7. Update Module Index
-
-Edit `docs/docs/modules/index.md`:
-- Add to correct layer table
-- Add to Mermaid architecture diagram
-- Add to dependency graph diagram
-
-### 8. Verify
-
-```bash
-mvn compile -pl spector-{name}
-cd docs && python -m mkdocs build --clean
-```
-
-### 9. Commit
-
-```
-feat({name}): add spector-{name} module
-```
-
----
-
-## Removing a Module
-
-### 1. Delete Module
-
-```bash
-rm -rf spector-{name}/
-```
-
-### 2. Remove from Root POM
-
-Delete `<module>spector-{name}</module>` from root `pom.xml`.
-
-### 3. Remove Dependencies
-
-Grep for references in other module POMs:
-```bash
-grep -rn "spector-{name}" spector-*/pom.xml
-```
-
-### 4. Clean Docs
-
-- Delete `docs/docs/modules/spector-{name}.md`
-- Remove nav entry from `docs/mkdocs.yml`
-- Remove from `docs/docs/modules/index.md` tables and diagrams
-
-### 5. Grep for Stale References
-
-```bash
-grep -rn "spector-{name}" docs/ scripts/ *.md
-```
-
-### 6. Verify
-
-```bash
-mvn clean compile
-cd docs && python -m mkdocs build --clean
-```
-
-### 7. Commit
-
-```
-refactor: remove spector-{name} module
-
-<reason for removal>
-```
-
----
-
-## Renaming / Merging Modules
-
-Follow "Adding" for the new name, then "Removing" for the old name. Commit separately:
-
-1. `feat({new}): add spector-{new} module`
-2. Migration commit (move code, update imports)
-3. `refactor: remove spector-{old} module (merged into spector-{new})`
diff --git a/.agents/workflows/perf-investigation.md b/.agents/workflows/perf-investigation.md
deleted file mode 100644
index 05d5e67..0000000
--- a/.agents/workflows/perf-investigation.md
+++ /dev/null
@@ -1,85 +0,0 @@
-# Workflow: Performance Investigation
-
-Process for investigating performance regressions or optimizing hot paths in Spector.
-
-## Trigger
-
-When investigating slow queries, memory regressions, SIMD inefficiencies, or the user requests performance analysis.
-
-## Steps
-
-### 1. Identify the Hot Path
-
-Determine which component is slow:
-- **Search latency** → `spector-index` (HNSW traversal, SIMD similarity)
-- **Ingestion throughput** → `spector-engine` / `spector-ingestion` pipeline
-- **Memory operations** → `spector-memory` (WAL writes, synapse lookup)
-- **Startup time** → `spector-runtime` / `spector-engine` (index loading)
-
-### 2. Baseline Benchmark
-
-```bash
-mvn package -pl spector-bench -DskipTests
-java --add-modules jdk.incubator.vector \
-  -jar spector-bench/target/benchmarks.jar \
-  {BenchmarkClass} -f 1 -wi 3 -i 5
-```
-
-Record baseline numbers before any changes.
-
-### 3. Profile
-
-Use JFR (Java Flight Recorder):
-```bash
-java -XX:StartFlightRecording=filename=profile.jfr,duration=60s ...
-```
-
-Look for:
-- Heap allocations in hot path (`new float[]`, `toArray()`, boxing)
-- Lock contention (`ReentrantLock` wait time)
-- Virtual thread pinning (should not happen if no `synchronized`)
-- Unnecessary `MemorySegment` copies
-
-### 4. Analyze Code
-
-Check against performance rules:
-
-- [ ] No heap allocations in similarity/search loops
-- [ ] `MemorySegment` slices used (not `.toArray()`)
-- [ ] SIMD uses `FloatVector.SPECIES_PREFERRED`
-- [ ] SIMD loop bound via `SPECIES.loopBound()` with scalar tail
-- [ ] `VectorMask` for partial-lane handling (not branching)
-- [ ] Arena lifecycle correct (`ofShared` vs `ofConfined`)
-- [ ] Buffers reused, not allocated per-call
-- [ ] No `String.format()` in hot loops (use SLF4J parameterized logging)
-
-### 5. Optimize
-
-Apply the fix following coding standards. Common optimizations:
-
-| Problem | Fix |
-|---|---|
-| `float[]` allocation in loop | Pre-allocate and reuse buffer |
-| `segment.toArray()` | Use `segment.asSlice()` |
-| Scalar similarity | Replace with SIMD `FloatVector` |
-| `String.format` in loop | Move outside or use SLF4J `{}` |
-| Synchronized lock | Replace with `ReentrantLock` |
-
-### 6. Benchmark After
-
-Run the same benchmark from Step 2. Compare:
-- Throughput (ops/sec)
-- Latency (avg, p99)
-- Allocation rate (bytes/op)
-
-### 7. Commit
-
-```
-perf({module}): <description>
-
-Before: {N} ops/sec, p99={X}ms
-After:  {M} ops/sec, p99={Y}ms
-Improvement: {Z}%
-```
-
-Include JMH numbers in commit body. This is mandatory for `perf:` commits.
diff --git a/.agents/workflows/pr-review.md b/.agents/workflows/pr-review.md
deleted file mode 100644
index 17742c0..0000000
--- a/.agents/workflows/pr-review.md
+++ /dev/null
@@ -1,57 +0,0 @@
----
-description: Structured pull request review process ensuring code quality, architecture compliance, and test coverage before merge.
----
-
-# Workflow: PR Review
-
-Structured pull request review process ensuring code quality, architecture compliance, and test coverage before merge.
-
-## Trigger
-
-When reviewing a pull request, inspecting a diff before push, or the user requests a code review.
-
-## Steps
-
-### 1. Scope the Diff
-
-```bash
-git diff main...HEAD --stat
-```
-
-Count changed files, identify affected modules, classify risk:
-- **High risk:** core, index, storage (SIMD, Panama, hot paths)
-- **Medium risk:** engine, memory, query (business logic)
-- **Low risk:** docs, bench, scripts
-
-### 2. Run Code Review Skill
-
-Execute the full 8-step code review (`.agents/skills/code-review/SKILL.md`):
-1. Scope → 2. Architecture → 3. Java Standards → 4. Performance → 5. Tests → 6. Docs → 7. Git Hygiene → 8. Summary
-
-### 3. Run Tests
-
-```bash
-mvn test                            # full suite
-mvn test -pl spector-{module}       # changed modules only
-```
-
-### 4. Verify Docs
-
-If documentation changed:
-```bash
-cd docs && python -m mkdocs build --clean 2>&1 | grep WARNING
-```
-
-### 5. Generate Verdict
-
-Produce a structured review summary with:
-- ✅ Passed checks
-- ⚠️ Warnings (non-blocking)
-- ❌ Blockers (must fix)
-- Verdict: `APPROVE` / `REQUEST_CHANGES` / `NEEDS_DISCUSSION`
-
-### 6. Follow Up
-
-- All blockers must be resolved before merge
-- PRs are squash-merged to keep history clean
-- Commit message for squash should follow Conventional Commits
diff --git a/.agents/workflows/release-prep.md b/.agents/workflows/release-prep.md
deleted file mode 100644
index a7b89d6..0000000
--- a/.agents/workflows/release-prep.md
+++ /dev/null
@@ -1,88 +0,0 @@
----
-description: End-to-end process for preparing a Spector release — test verification, changelog, version bump, docs, and tagging.
----
-
-# Workflow: Release Preparation
-
-End-to-end process for preparing a Spector release — test verification, changelog, version bump, docs, and tagging.
-
-## Trigger
-
-When preparing for a tagged release or the user requests release preparation.
-
-## Steps
-
-### 1. Test Gap Analysis
-
-Identify modules with missing test coverage:
-
-```bash
-# Count production vs test files per module
-for dir in spector-*/; do
-  main=$(find "$dir/src/main" -name "*.java" 2>/dev/null | wc -l)
-  test=$(find "$dir/src/test" -name "*.java" 2>/dev/null | wc -l)
-  echo "$dir main=$main test=$test"
-done
-```
-
-Flag critical gaps (0 tests in production modules).
-
-### 2. Full Build
-
-```bash
-mvn clean install
-```
-
-All tests must pass. Zero tolerance for failures.
-
-### 3. Dependency Audit
-
-```bash
-# Check for circular dependencies
-grep -rn "import com.spectrayan.spector.engine" spector-memory/src/
-grep -rn "import com.spectrayan.spector.memory" spector-engine/src/
-
-# Verify no SNAPSHOT dependencies in release
-grep -rn "SNAPSHOT" spector-*/pom.xml
-```
-
-### 4. Generate Changelog
-
-From commit history since last tag:
-
-```bash
-git log --oneline $(git describe --tags --abbrev=0)..HEAD
-```
-
-Group entries by type:
-- **Added** — `feat:` commits
-- **Changed** — `refactor:` commits
-- **Fixed** — `fix:` commits
-- **Performance** — `perf:` commits
-- **Removed** — deletion commits
-
-Prepend to `CHANGELOG.md` with version header and date.
-
-### 5. Version Bump
-
-Update version in root `pom.xml` (child POMs inherit via parent).
-
-### 6. Update Roadmap
-
-Use update-roadmap skill to mark completed features as done.
-
-### 7. Docs Verification
-
-```bash
-cd docs && python -m mkdocs build --clean
-```
-
-Zero warnings for controlled files.
-
-### 8. Tag & Commit
-
-```bash
-git add -A
-git commit -m "chore: prepare release v{version}"
-git tag -a v{version} -m "Release v{version}"
-```
diff --git a/.github/ISSUE_TEMPLATE/bug_report.md b/.github/ISSUE_TEMPLATE/bug_report.md
index 56deff4..34698c8 100644
--- a/.github/ISSUE_TEMPLATE/bug_report.md
+++ b/.github/ISSUE_TEMPLATE/bug_report.md
@@ -1,6 +1,6 @@
 ---
 name: Bug report
-about: Create a report to help us improve Spector
+about: Create a report to help us improve Spector-Search
 title: ''
 labels: 'bug'
 assignees: ''
@@ -24,7 +24,7 @@ A clear and concise description of what you expected to happen.
 - OS: [e.g. Ubuntu 22.04, Windows 11, macOS 14]
 - JDK version: [e.g. OpenJDK 25]
 - SIMD capability: [e.g. S_256_BIT / AVX2]
-- Spector version: [e.g. 0.1.0]
+- Spector-Search version: [e.g. 0.1.0]
 
 **Logs / Stack Traces**
 If applicable, add relevant log output or stack traces.
diff --git a/.github/ISSUE_TEMPLATE/feature_request.md b/.github/ISSUE_TEMPLATE/feature_request.md
index f920a7d..7a7e8a9 100644
--- a/.github/ISSUE_TEMPLATE/feature_request.md
+++ b/.github/ISSUE_TEMPLATE/feature_request.md
@@ -1,6 +1,6 @@
 ---
 name: Feature request
-about: Suggest an idea for Spector
+about: Suggest an idea for Spector-Search
 title: ''
 labels: 'enhancement'
 assignees: ''
@@ -17,7 +17,7 @@ A clear and concise description of what you want to happen.
 A clear and concise description of any alternative solutions or features you've considered.
 
 **Module(s) affected**
-Which module(s) would this feature impact? (e.g. spector-core, spector-index, spector-node)
+Which module(s) would this feature impact? (e.g. spector-core, spector-index, spector-server)
 
 **Additional context**
 Add any other context, benchmarks, or research papers about the feature request here.
diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md
index 68e8b72..c04d83a 100644
--- a/.github/pull_request_template.md
+++ b/.github/pull_request_template.md
@@ -20,7 +20,7 @@
 - [ ] `spector-index` (HNSW / BM25)
 - [ ] `spector-query` (query orchestration)
 - [ ] `spector-engine` (engine facade)
-- [ ] `spector-node` (REST API)
+- [ ] `spector-server` (REST API)
 - [ ] `spector-bench` (benchmarks)
 
 ## Checklist
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 5ae1c5a..ac576fd 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -33,11 +33,6 @@ jobs:
           distribution: ${{ env.JAVA_DISTRIBUTION }}
           cache: 'maven'
 
-      # ─── License Header Check ────────────────────────────────────────
-      - name: Check license headers
-        run: |
-          mvn -B license:check --no-transfer-progress
-
       # ─── Reproducible Build ───────────────────────────────────────────
       - name: Build with reproducible output
         run: |
@@ -58,9 +53,8 @@ jobs:
       # ─── Dependency Pinning Verification ─────────────────────────────
       - name: Verify no dynamic version ranges
         run: |
-          # Fail if any external dependency uses dynamic ranges like [1.0,2.0) or LATEST/RELEASE/SNAPSHOT
-          # Exclude internal modules (com.spectrayan) and Maven reactor build lines
-          if mvn -B dependency:tree --no-transfer-progress | grep -E '\[(.*,.*)\]|\[.*,\)|\(.*,.*\]|LATEST|RELEASE|SNAPSHOT' | grep -v 'com.spectrayan' | grep -v 'Building ' | grep -v 'Reactor Summary'; then
+          # Fail if any dependency uses dynamic ranges like [1.0,2.0) or LATEST/RELEASE
+          if mvn -B dependency:tree --no-transfer-progress | grep -E '\[(.*,.*)\]|\[.*,\)|\(.*,.*\]|LATEST|RELEASE|SNAPSHOT' | grep -v 'spector-search'; then
             echo "::error::Dynamic version ranges detected in dependencies. All versions must be pinned."
             exit 1
           fi
@@ -69,7 +63,7 @@ jobs:
       # ─── Test Results ────────────────────────────────────────────────
       - name: Upload test results
         if: always()
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v7
         with:
           name: test-results
           path: '**/target/surefire-reports/*.xml'
@@ -136,7 +130,7 @@ jobs:
 
       - name: Upload build provenance
         if: success()
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v7
         with:
           name: build-provenance
           path: build-provenance.json
@@ -145,7 +139,7 @@ jobs:
       # ─── Upload JARs ─────────────────────────────────────────────────
       - name: Upload build artifacts
         if: success() && github.event_name == 'push'
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v7
         with:
           name: jars
           path: '**/target/*.jar'
diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml
index e3923c9..fbb23f3 100644
--- a/.github/workflows/docs.yml
+++ b/.github/workflows/docs.yml
@@ -2,26 +2,13 @@ name: Deploy Documentation
 
 on:
   push:
-    branches:
-      - main
-      - 'labs/**'
+    branches: [ main ]
     paths:
       - 'docs/**'
-      - 'scripts/collect-labs.sh'
-      - 'LABS.md'
   workflow_dispatch:
-    inputs:
-      wiki_only:
-        description: 'Sync wiki only (skip pages deploy)'
-        required: false
-        default: 'false'
-        type: choice
-        options:
-          - 'false'
-          - 'true'
 
 permissions:
-  contents: write
+  contents: read
   pages: write
   id-token: write
 
@@ -32,12 +19,9 @@ concurrency:
 jobs:
   build:
     runs-on: ubuntu-latest
-    if: ${{ !(github.event_name == 'workflow_dispatch' && inputs.wiki_only == 'true') }}
     steps:
       - name: Checkout
         uses: actions/checkout@v4
-        with:
-          fetch-depth: 0    # Full history — needed to access labs/* branches
 
       - name: Set up Python
         uses: actions/setup-python@v5
@@ -46,10 +30,7 @@ jobs:
 
       - name: Install MkDocs and dependencies
         run: |
-          pip install mkdocs-material pymdown-extensions mkdocs-callouts
-
-      - name: Collect Labs branches
-        run: ./scripts/collect-labs.sh
+          pip install mkdocs-material pymdown-extensions
 
       - name: Build documentation
         run: mkdocs build
@@ -66,212 +47,7 @@ jobs:
       url: ${{ steps.deployment.outputs.page_url }}
     runs-on: ubuntu-latest
     needs: build
-    if: ${{ !(github.event_name == 'workflow_dispatch' && inputs.wiki_only == 'true') }}
     steps:
       - name: Deploy to GitHub Pages
         id: deployment
         uses: actions/deploy-pages@v4
-
-  sync-wiki:
-    runs-on: ubuntu-latest
-    needs: [deploy]
-    if: ${{ always() && (needs.deploy.result == 'success' || needs.deploy.result == 'skipped') }}
-    steps:
-      - name: Checkout main repo
-        uses: actions/checkout@v4
-        with:
-          path: main
-
-      - name: Checkout wiki
-        uses: actions/checkout@v4
-        with:
-          repository: ${{ github.repository }}.wiki
-          path: wiki
-          token: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Sync docs to wiki
-        run: |
-          python3 << 'PYSCRIPT'
-          import yaml, os, shutil, glob, re
-
-          DOCS_DIR = 'main/docs/docs'
-          WIKI_DIR = 'wiki'
-          MKDOCS_YML = 'main/docs/mkdocs.yml'
-          SCREENSHOTS_DIR = 'main/docs/screenshots'
-
-          # ── MkDocs YAML loader (ignores !!python/name: tags) ────────
-          class MkDocsLoader(yaml.SafeLoader):
-              pass
-
-          def _ignore_python_tags(loader, tag_suffix, node):
-              return None
-
-          MkDocsLoader.add_multi_constructor(
-              'tag:yaml.org,2002:python/', _ignore_python_tags
-          )
-
-          # ── Single source of truth: path → wiki page name ──────────
-          SPECIAL_NAMES = {
-              'index.md': 'Home',
-              'about.md': 'About',
-              'faq.md': 'FAQ',
-              'roadmap.md': 'Roadmap',
-          }
-
-          def path_to_wiki_name(rel_path):
-              """Convert a docs-relative path to a wiki page name.
-              
-              Examples:
-                index.md                        → Home
-                about.md                        → About
-                getting-started/quickstart.md   → Getting-Started--Quickstart
-                architecture/overview.md        → Architecture--Overview
-                memory/index.md                 → Memory
-                cortex/index.md                 → Cortex
-              """
-              if rel_path in SPECIAL_NAMES:
-                  return SPECIAL_NAMES[rel_path]
-
-              path = rel_path.replace('.md', '')
-              parts = path.split('/')
-
-              # index.md in a subdirectory → use directory name only
-              if parts[-1] == 'index':
-                  parts = parts[:-1]
-
-              if not parts:
-                  return 'Home'
-
-              # Title-case each segment, join with '--' (double hyphen)
-              # to separate directory from filename.
-              # Within each segment, hyphens become spaces for title-casing,
-              # then go back to hyphens.
-              def title_case_segment(seg):
-                  return '-'.join(
-                      word.capitalize()
-                      for word in seg.replace('-', ' ').split()
-                  )
-
-              return '--'.join(title_case_segment(s) for s in parts)
-
-          # ── 1. Clean wiki directory ─────────────────────────────────
-          for f in glob.glob(os.path.join(WIKI_DIR, '*.md')):
-              basename = os.path.basename(f)
-              if basename != '_Footer.md':
-                  os.remove(f)
-
-          for d in ['images', 'screenshots']:
-              p = os.path.join(WIKI_DIR, d)
-              if os.path.isdir(p):
-                  shutil.rmtree(p)
-
-          # ── 2. Copy all .md files with wiki names ───────────────────
-          page_map = {}  # rel_path → wiki_name (for link fixing)
-
-          for root, dirs, files in os.walk(DOCS_DIR):
-              for fname in files:
-                  full_path = os.path.join(root, fname)
-                  rel_path = os.path.relpath(full_path, DOCS_DIR)
-
-                  if fname.endswith('.md'):
-                      wiki_name = path_to_wiki_name(rel_path)
-                      page_map[rel_path] = wiki_name
-                      dest = os.path.join(WIKI_DIR, f'{wiki_name}.md')
-                      shutil.copy2(full_path, dest)
-                      print(f'  📄 {rel_path} → {wiki_name}.md')
-
-                  elif fname.lower().endswith(('.png', '.jpg', '.jpeg', '.gif', '.svg', '.webp')):
-                      dest_dir = os.path.join(WIKI_DIR, 'images', os.path.dirname(rel_path))
-                      os.makedirs(dest_dir, exist_ok=True)
-                      shutil.copy2(full_path, os.path.join(dest_dir, fname))
-
-          # Copy top-level screenshots
-          if os.path.isdir(SCREENSHOTS_DIR):
-              dest = os.path.join(WIKI_DIR, 'screenshots')
-              shutil.copytree(SCREENSHOTS_DIR, dest, dirs_exist_ok=True)
-
-          print(f'\n✅ Copied {len(page_map)} pages')
-
-          # ── 3. Fix content in wiki pages ────────────────────────────
-          for wiki_file in glob.glob(os.path.join(WIKI_DIR, '*.md')):
-              basename = os.path.basename(wiki_file)
-              if basename.startswith('_'):
-                  continue
-
-              with open(wiki_file, 'r', encoding='utf-8') as f:
-                  content = f.read()
-
-              # Remove YAML frontmatter
-              content = re.sub(r'^---\n.*?\n---\n', '', content, count=1, flags=re.DOTALL)
-
-              # Fix image paths
-              content = content.replace('](../screenshots/', '](screenshots/')
-              content = content.replace('](../../screenshots/', '](screenshots/')
-
-              # Convert MkDocs admonitions to blockquotes
-              content = re.sub(
-                  r'^!!! (\w+) "([^"]*)"',
-                  r'> **\1:** \2',
-                  content, flags=re.MULTILINE
-              )
-              content = re.sub(
-                  r'^!!! quote "([^"]*)"',
-                  r'> **\1**',
-                  content, flags=re.MULTILINE
-              )
-
-              # Convert tabs to headings
-              content = re.sub(r'^=== "([^"]*)"', r'### \1', content, flags=re.MULTILINE)
-
-              # Convert snippets
-              content = re.sub(r'^--8<-- "([^"]*)"', r'> *See: \1*', content, flags=re.MULTILINE)
-
-              with open(wiki_file, 'w', encoding='utf-8') as f:
-                  f.write(content)
-
-          # ── 4. Generate _Sidebar.md from mkdocs nav ─────────────────
-          with open(MKDOCS_YML, 'r') as f:
-              config = yaml.load(f, Loader=MkDocsLoader)
-
-          nav = config.get('nav', [])
-
-          def write_nav(items, depth, out):
-              indent = '  ' * depth
-              for item in items:
-                  if isinstance(item, str):
-                      wiki_name = path_to_wiki_name(item)
-                      out.append(f'{indent}- [[{wiki_name}]]')
-                  elif isinstance(item, dict):
-                      for title, value in item.items():
-                          if isinstance(value, str):
-                              wiki_name = path_to_wiki_name(value)
-                              out.append(f'{indent}- [[{wiki_name}|{title}]]')
-                          elif isinstance(value, list):
-                              out.append(f'{indent}- **{title}**')
-                              write_nav(value, depth + 1, out)
-
-          sidebar_lines = [
-              '**[🏠 Home](Home)**',
-              '',
-              '---',
-              '',
-          ]
-          write_nav(nav, 0, sidebar_lines)
-
-          sidebar_path = os.path.join(WIKI_DIR, '_Sidebar.md')
-          with open(sidebar_path, 'w', encoding='utf-8') as f:
-              f.write('\n'.join(sidebar_lines) + '\n')
-
-          print(f'✅ Generated _Sidebar.md with {len(sidebar_lines)} lines')
-          PYSCRIPT
-
-          echo "✅ Wiki sync complete: $(ls -1 wiki/*.md | wc -l) pages"
-
-      - name: Push wiki changes
-        run: |
-          cd wiki
-          git config user.name "github-actions[bot]"
-          git config user.email "github-actions[bot]@users.noreply.github.com"
-          git add -A
-          git diff --cached --quiet || git commit -m "docs: sync from main repo docs [skip ci]"
-          git push
diff --git a/.gitignore b/.gitignore
index 2db387f..fe0daf2 100644
--- a/.gitignore
+++ b/.gitignore
@@ -29,9 +29,7 @@ Desktop.ini
 dependency-reduced-pom.xml
 buildNumber.properties
 .mvn/timing.properties
-.mvn/maven.config
 .mvn/wrapper/maven-wrapper.jar
-.mvn
 
 # ──────────── Logs ────────────
 *.log
@@ -41,19 +39,3 @@ logs/
 *.mmap
 *.vec
 *.dat
-embedding-cache/
-.spector/
-
-# ──────────── User config ────────────
-spector-local.yml
-!spector.yml.example
-!**/src/main/resources/spector-defaults.yml
-!**/src/test/resources/spector-defaults.yml
-
-# ──────────── Documentation build ────────────
-docs/site/
-docs/docs/labs/*
-!docs/docs/labs/roadmap.md
-RnD
-
-.scratch/
\ No newline at end of file
diff --git a/CHANGELOG.md b/CHANGELOG.md
index a63bd91..98eed4e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -51,35 +51,23 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **spector-engine:** Document deletion support (`delete()` method)
 - **spector-engine:** Auto-embed ingestion, chunked ingestion, and streaming file ingestion
 - **spector-engine:** IVF-PQ auto-training with buffered vector accumulation
-- **spector-node:** Armeria REST API with virtual threads
-- **spector-node:** CORS support via bundled plugin
-- **spector-node:** Optional API key authentication (`X-API-Key` header)
-- **spector-node:** Auto-embed ingest endpoint (`/api/v1/ingest/auto`)
-- **spector-node:** Bulk ingest endpoint (`/api/v1/ingest/bulk`)
-- **spector-node:** Document deletion endpoint (`DELETE /api/v1/documents/{id}`)
-- **spector-node:** Metrics endpoint (`/api/v1/metrics`)
-- **spector-node:** Vector dimension validation on ingest
-- **spector-node:** gRPC-based distributed search with coordinator/shard fan-out
-- **spector-node:** `ClusterCoordinator` with parallel shard queries and result merging
-- **spector-node:** `RemoteShardClient` with TLS support (mutual TLS optional)
-- **spector-node:** `ShardNode` gRPC server wrapping a local SpectorEngine
-- **spector-node:** `ClusterConfig` with consistent hash and range partitioning
+- **spector-server:** Javalin REST API with virtual threads
+- **spector-server:** CORS support via bundled plugin
+- **spector-server:** Optional API key authentication (`X-API-Key` header)
+- **spector-server:** Auto-embed ingest endpoint (`/api/v1/ingest/auto`)
+- **spector-server:** Bulk ingest endpoint (`/api/v1/ingest/bulk`)
+- **spector-server:** Document deletion endpoint (`DELETE /api/v1/documents/{id}`)
+- **spector-server:** Metrics endpoint (`/api/v1/metrics`)
+- **spector-server:** Vector dimension validation on ingest
+- **spector-cluster:** gRPC-based distributed search with coordinator/shard fan-out
+- **spector-cluster:** `ClusterCoordinator` with parallel shard queries and result merging
+- **spector-cluster:** `RemoteShardClient` with TLS support (mutual TLS optional)
+- **spector-cluster:** `ShardNode` gRPC server wrapping a local SpectorEngine
+- **spector-cluster:** `ClusterConfig` with consistent hash and range partitioning
 - **spector-bench:** JMH benchmarks for SIMD kernels, HNSW, BM25, ingestion, IVF-PQ, concurrency
 - **spector-bench:** `PerformanceTestRunner` for comprehensive latency/throughput reporting
 - 316+ tests across all modules, all passing
 
-### Added — spector-mcp (Agent-Native MCP Server)
-- **spector-mcp:** Built-in Model Context Protocol (MCP) server for AI agent integration (Claude Desktop, Cursor, autonomous agents)
-- **spector-mcp:** 6 MCP tools: `semantic_search`, `hybrid_search`, `rag_query`, `ingest_document`, `delete_document`, `engine_status`
-- **spector-mcp:** `McpToolHandler` abstract base class with template method pattern (timing, error handling, arg parsing)
-- **spector-mcp:** `ToolSchemaBuilder` — type-safe fluent builder for JSON schemas (replaces error-prone `Map.of()` literals)
-- **spector-mcp:** `SpectorToolRegistry` — tool discovery and registration with Open/Closed Principle
-- **spector-mcp:** `SpectorResourceProvider` and `SpectorPromptProvider` — MCP resource/prompt definitions
-- **spector-mcp:** `ResultFormatter` — shared formatting utilities for search results, RAG context, engine status
-- **spector-mcp:** `SpectorMcpMain` CLI entry point with Ollama embedding provider auto-detection
-- **spector-mcp:** In-process MCP execution with zero network overhead (50–200µs per tool call)
-- **spector-mcp:** 15 unit tests covering tool registry, all tool handlers, schema builder, and argument validation
-
 ### Technical Decisions
 - Java 25 with `jdk.incubator.vector` for SIMD
 - `FloatVector.SPECIES_PREFERRED` for ISA-agnostic code
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 0f24d29..c185962 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -1,11 +1,10 @@
-# Contributing to Spector
+# Contributing to Spector-Search
 
-Thank you for your interest in contributing to Spector! This document provides guidelines and instructions for contributing.
+Thank you for your interest in contributing to Spector-Search! This document provides guidelines and instructions for contributing.
 
 ## Table of Contents
 
 - [Code of Conduct](#code-of-conduct)
-- [Contributor License Agreement](#contributor-license-agreement)
 - [Getting Started](#getting-started)
 - [Development Setup](#development-setup)
 - [Making Changes](#making-changes)
@@ -17,34 +16,6 @@ Thank you for your interest in contributing to Spector! This document provides g
 
 This project adheres to the [Contributor Covenant Code of Conduct](CODE_OF_CONDUCT.md). By participating, you are expected to uphold this code. Please report unacceptable behavior to [support@spectrayan.com](mailto:support@spectrayan.com).
 
-## Contributor License Agreement
-
-By contributing to Spector, you agree that:
-
-1. **You have the right** to submit the contribution. The code is your original work, or you have permission to submit it under the project's license terms.
-
-2. **You grant Spectrayan** a perpetual, worldwide, non-exclusive, royalty-free, irrevocable license to use, reproduce, modify, distribute, and sublicense your contribution under:
-   - The **Apache License 2.0** for all modules except `spector-memory`.
-   - The **Business Source License 1.1** for the `spector-memory` module (which transitions to Apache 2.0 on the Change Date specified in its LICENSE file).
-
-3. **You understand** that your contribution becomes part of the project and may be distributed under the project's current or future license terms as described above.
-
-### How to Sign Off
-
-All commits must include a `Signed-off-by` line certifying this agreement. Use the `-s` flag when committing:
-
-```bash
-git commit -s -m "feat(core): add new SIMD kernel"
-```
-
-This adds a line like:
-
-```
-Signed-off-by: Your Name <your.email@example.com>
-```
-
-> **Note:** Pull requests without signed-off commits will not be merged.
-
 ## Getting Started
 
 1. **Fork** the repository on GitHub
@@ -67,8 +38,8 @@ Signed-off-by: Your Name <your.email@example.com>
 
 ```bash
 # Clone your fork
-git clone https://github.com/<your-username>/spector.git
-cd spector
+git clone https://github.com/<your-username>/spector-search.git
+cd spector-search
 
 # Verify JDK 25+ is installed
 java -version
@@ -80,12 +51,12 @@ mvn clean compile
 mvn test
 
 # Run the server (optional)
-mvn exec:java -pl spector-node -Dexec.mainClass="com.spectrayan.spector.server.SpectorNode"
+mvn exec:java -pl spector-server -Dexec.mainClass="com.spectrayan.spector.server.SpectorServer"
 ```
 
 ### SIMD Verification
 
-Spector uses the Java Vector API for SIMD acceleration. Verify your system supports it:
+Spector-Search uses the Java Vector API for SIMD acceleration. Verify your system supports it:
 
 ```bash
 # Check SIMD capability
@@ -191,7 +162,7 @@ docs: add benchmark results to README
 
 ### Bug Reports
 
-Use the [Bug Report template](https://github.com/spectrayan/spector/issues/new?template=bug_report.md) and include:
+Use the [Bug Report template](https://github.com/spectrayan/spector-search/issues/new?template=bug_report.md) and include:
 
 - Steps to reproduce
 - Expected vs actual behavior
@@ -200,7 +171,7 @@ Use the [Bug Report template](https://github.com/spectrayan/spector/issues/new?t
 
 ### Feature Requests
 
-Use the [Feature Request template](https://github.com/spectrayan/spector/issues/new?template=feature_request.md) and describe:
+Use the [Feature Request template](https://github.com/spectrayan/spector-search/issues/new?template=feature_request.md) and describe:
 
 - The problem you're trying to solve
 - Your proposed solution
@@ -208,11 +179,11 @@ Use the [Feature Request template](https://github.com/spectrayan/spector/issues/
 
 ## Questions?
 
-- **General questions:** Open a [Discussion](https://github.com/spectrayan/spector/discussions)
-- **Bug reports:** Open an [Issue](https://github.com/spectrayan/spector/issues)
+- **General questions:** Open a [Discussion](https://github.com/spectrayan/spector-search/discussions)
+- **Bug reports:** Open an [Issue](https://github.com/spectrayan/spector-search/issues)
 - **Security vulnerabilities:** See [SECURITY.md](SECURITY.md)
 - **Email:** [developer@spectrayan.com](mailto:developer@spectrayan.com)
 
 ---
 
-Thank you for contributing to Spector! ⚡
+Thank you for contributing to Spector-Search! ⚡
diff --git a/NOTICE b/NOTICE
index d3079a8..76e5fa2 100644
--- a/NOTICE
+++ b/NOTICE
@@ -1,61 +1,42 @@
-Spector
+Spector-Search
 Copyright 2026 Spectrayan
 
 This product includes software developed by
 Spectrayan (https://www.spectrayan.com/).
 
-================================================================================
-LICENSE STRUCTURE
-================================================================================
-
-This repository utilizes a split licensing model:
-
-  1. The "spector-memory" module (located under the spector-memory/ directory)
-     is licensed under the Business Source License 1.1 (BSL 1.1). Under the
-     terms of the BSL 1.1, you are granted non-production use rights, with
-     an Additional Use Grant permitting production use except for offering
-     the module as a managed service or embedding it in a competing AI
-     cognitive memory product. On the Change Date (May 27, 2030), this module
-     automatically transitions to the Apache License 2.0.
-     Please see spector-memory/LICENSE for details.
-
-  2. All other directories, modules, and core infrastructure in this repository
-     are licensed under the Apache License 2.0.
-     Please see the root LICENSE file for details.
-
 ================================================================================
 ATTRIBUTION NOTICE
 ================================================================================
 
 This software is the original work of the Spectrayan team. If you use
-Spector in your own projects, deployments, or services, you MUST
+Spector-Search in your own projects, deployments, or services, you MUST
 provide visible attribution to the Spectrayan team. This attribution must
 include:
 
-  1. The text "Powered by Spector" or "Built with Spector" in
+  1. The text "Powered by Spector-Search" or "Built with Spector-Search" in
      your application's documentation, about page, or equivalent visible
      location.
 
-  2. A link to the Spector GitHub repository:
-     https://github.com/spectrayan/spector
+  2. A link to the Spector-Search GitHub repository:
+     https://github.com/spectrayan/spector-search
 
 ================================================================================
 TRADEMARK POLICY
 ================================================================================
 
-"Spector", "Spectrayan", the Spectrayan logo, and associated branding
+"Spector-Search", "Spectrayan", the Spectrayan logo, and associated branding
 are trademarks of Spectrayan. This license does NOT grant you permission to:
 
-  - Use the names "Spector" or "Spectrayan" as your product name
+  - Use the names "Spector-Search" or "Spectrayan" as your product name
   - Present this software as your own original creation
   - Remove or obscure the Spectrayan attribution notices
   - Use the Spectrayan logos or branding in your own marketing materials
   - Offer this software as a commercial SaaS product under a different brand
     without prior written agreement from Spectrayan
 
-You MAY use the names "Spector" and "Spectrayan" solely to:
+You MAY use the names "Spector-Search" and "Spectrayan" solely to:
 
-  - Describe that your software is based on or derived from Spector
+  - Describe that your software is based on or derived from Spector-Search
   - Give credit to the original authors as required by this NOTICE file
   - Link back to the official repository
 
@@ -65,64 +46,13 @@ For trademark licensing inquiries: legal@spectrayan.com
 THIRD-PARTY NOTICES
 ================================================================================
 
-This product includes software developed by the following open-source projects.
-Dependency versions are managed in the root pom.xml.
+This product includes software developed by the following open-source projects:
 
-NOTE: The core engine modules (spector-core, spector-storage, spector-index,
-spector-query, spector-engine, spector-memory) have ZERO external dependencies
-beyond the JDK itself. All SIMD acceleration, off-heap storage, and vector
-indexing use only standard JDK APIs (Vector API, Panama FFM, Virtual Threads).
-
-The third-party libraries listed below are used only by the server, CLI,
-MCP, and integration modules:
-
-Runtime (all distribution modes):
-
-  - Jackson 3.x (https://github.com/FasterXML/jackson) — Apache 2.0
-  - Jackson 2.x (https://github.com/FasterXML/jackson) — Apache 2.0
-    Used by MCP SDK and Javalin for JSON serialization.
+  - Javalin (https://javalin.io) — Apache 2.0
+  - Jackson (https://github.com/FasterXML/jackson) — Apache 2.0
   - SLF4J (https://www.slf4j.org/) — MIT
   - Logback (https://logback.qos.ch/) — EPL 1.0 / LGPL 2.1
-  - SnakeYAML (https://bitbucket.org/snakeyaml/snakeyaml/) — Apache 2.0
-  - Apache Commons Configuration 2 (https://commons.apache.org/configuration/) — Apache 2.0
-  - Apache Commons BeanUtils (https://commons.apache.org/beanutils/) — Apache 2.0
-
-Server/Node mode only (spector-node):
-
-  - Armeria (https://armeria.dev/) — Apache 2.0
-    HTTP/gRPC server framework built on Netty.
-  - Netty (https://netty.io/) — Apache 2.0
-    Transitive dependency via Armeria.
-  - gRPC Java (https://grpc.io/) — Apache 2.0
-  - Protocol Buffers (https://protobuf.dev/) — BSD 3-Clause
-  - Javalin (https://javalin.io/) — Apache 2.0
-
-Metrics & Observability (spector-metrics, spector-node):
-
-  - Micrometer Core (https://micrometer.io/) — Apache 2.0
-  - Micrometer Prometheus Registry (https://micrometer.io/) — Apache 2.0
-
-MCP Agent Integration (spector-mcp):
-
-  - MCP SDK (https://github.com/modelcontextprotocol/java-sdk) — MIT
-    Official Anthropic Model Context Protocol Java SDK.
-
-Spring Integration (spector-spring module):
-
-  - Spring Framework (https://spring.io/projects/spring-framework) — Apache 2.0
-  - Spring Boot (https://spring.io/projects/spring-boot) — Apache 2.0
-  - Spring AI (https://spring.io/projects/spring-ai) — Apache 2.0
-
-Test Dependencies (not distributed):
-
   - JUnit 5 (https://junit.org/junit5/) — EPL 2.0
   - AssertJ (https://assertj.github.io/doc/) — Apache 2.0
-  - JMH (https://openjdk.org/projects/code-tools/jmh/) — GPL 2.0 + CE
-
-JDK APIs (bundled with OpenJDK, not separately distributed):
-
-  - Java Vector API (JEP 489) — incubator module (jdk.incubator.vector)
-  - Panama Foreign Function & Memory API (JEP 454) — finalized
-  - Virtual Threads (JEP 444) — finalized
-  - Structured Concurrency (JEP 505) — preview
-
+  - JMH (https://openjdk.java.net/projects/code-tools/jmh/) — GPL 2.0 + CE
+  - OpenJDK Vector API (https://openjdk.java.net/jeps/338) — GPL 2.0 + CE
diff --git a/README.md b/README.md
index 5425f29..d881c8a 100644
--- a/README.md
+++ b/README.md
@@ -1,322 +1,61 @@
-# ⚡ Spector
+# Spector-Search ⚡
 
-> **The Zero-Overhead, Agent-Ready AI Memory Backbone.**
->
-> Legacy search engines bolted vectors onto text databases. Spector is designed from the ground up for modern AI — leveraging Java Project Panama to achieve C++ bare-metal SIMD speeds natively, with a built-in Model Context Protocol (MCP) server that turns any AI agent into a search-powered reasoning machine.
+> Ultra-fast, SIMD-accelerated semantic search engine built on Java Vector API + modern JVM technologies.
 
 [![License](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](LICENSE)
 [![Java](https://img.shields.io/badge/Java-25-orange.svg)](https://openjdk.org/)
-[![Build](https://img.shields.io/github/actions/workflow/status/spectrayan/spector/ci.yml?branch=main)](https://github.com/spectrayan/spector/actions)
-[![MCP](https://img.shields.io/badge/MCP-Agent_Ready-blueviolet.svg)](spector-mcp/)
-[![Docs](https://img.shields.io/badge/Docs-MkDocs-blue?logo=materialformkdocs)](https://spectrayan.github.io/spector/)
-
-## 🧠 Why Spector?
-
-### 1. 🤖 Agent-Native (MCP Protocol)
-
-Includes a built-in [Model Context Protocol](https://modelcontextprotocol.io/) server. Plug Claude Desktop, Cursor, or autonomous agents directly into Spector for native RAG memory. **Zero Python glue-code required.**
-
-```mermaid
-graph LR
-    A["🤖 AI Agent"] -->|"JSON-RPC (stdio)"| B["⚡ SpectorMcpServer"]
-    B -->|"Virtual Thread"| C["SpectorEngine.search()"]
-    C -->|"Direct method call"| D["Off-heap MemorySegment + SIMD"]
-    D -->|"88µs p50"| E["✅ Results"]
-
-    style A fill:#6c5ce7,color:white
-    style B fill:#00b894,color:white
-    style E fill:#00b894,color:white
-```
-
-> **23–113× faster** than Python MCP servers — zero network overhead, zero GC pressure. [Benchmarked ↓](#-benchmarks)
-
-### 2. ⚡ SpectorQuant — SVASQ (Spector Vector-Aligned Scalar Quantization)
-
-A proprietary SIMD-first quantization engine that mathematically smears dimensional outliers via the Fast Walsh-Hadamard Transform (FWHT) and executes Asymmetric Distance Computation inside the IVF residual space. **Float32 recall at INT8 memory sizes.**
-
-- SVASQ-8: 4× compression, 99.5%+ recall
-- SVASQ-4: 6–8× compression, 97–99% recall (with 3× rescore)
-- IVF-PQ: 32× compression for billion-scale datasets
-
-### 3. 🧊 100% Off-Heap Panama Execution
-
-Bypasses the JVM Garbage Collector entirely. Maps raw disk bytes directly into hardware SIMD registers for sub-millisecond, Zero-Copy latency.
-
-- **Zero Network Tax** — runs in-process, no gRPC/HTTP roundtrip
-- **Zero Serialization Tax** — bytes → AVX-512 registers directly, no JSON, no Protobuf
-- **Zero GC Pressure** — all vector data lives off-heap via Panama `MemorySegment`
-
-### 4. 📦 Embedded or Standalone
-
-Deploy as a lightweight embedded library (the **"DuckDB of Vector DBs"**) inside your application, or scale it horizontally as a standalone server with REST API, gRPC clustering, and Spring AI integration.
-
----
-
-## 🤖 MCP Integration (Agent-Native)
-
-Give any AI agent instant access to Spector's SIMD-accelerated search engine — with zero network overhead.
-
-### MCP Tools
-
-**Search Tools (always available):**
-
-| Tool | Description |
-|:---|:---|
-| `semantic_search` | Semantic similarity search with auto-embedding |
-| `hybrid_search` | Combined keyword (BM25) + vector search with RRF |
-| `rag_query` | Retrieval-Augmented Generation with source citations |
-| `ingest_document` | Document ingestion with auto-embedding + chunking |
-| `delete_document` | Document deletion by ID |
-| `engine_status` | Engine metadata, SIMD capabilities, GPU status |
-
-**Cognitive Memory Tools (enabled via `spector.memory.enabled: true`):**
-
-| Tool | Description |
-|:---|:---|
-| `core_memory_append` | Store a semantic memory with tags and source |
-| `recall_context` | Cognitive recall with fused scoring across tiers |
-| `memory_status` | Memory tier counts and persistence info |
-| `memory_reinforce` | Report positive/negative outcome for a memory |
-| `memory_forget` | Tombstone a memory by ID |
-| `memory_introspect` | Metamemory self-analysis on a topic |
-| `working_memory_scratchpad` | Quick-write to working memory |
-
-### Claude Desktop Configuration
-
-Add to your `claude_desktop_config.json`:
-
-```json
-{
-  "mcpServers": {
-    "spector": {
-      "command": "java",
-      "args": [
-        "--add-modules", "jdk.incubator.vector",
-        "--enable-native-access=ALL-UNNAMED",
-        "--enable-preview",
-        "-jar", "/path/to/spector-dist/target/spector.jar",
-        "--config", "/path/to/spector.yml"
-      ]
-    }
-  }
-}
-```
-
-### Why Spector MCP is Different
-
-| Feature | Python Vector DB MCP | **Spector MCP** |
-|:---|:---|:---|
-| Search latency | 2–10ms (network + Python GIL) | **88µs p50** (in-process SIMD) † |
-| Network overhead | HTTP/gRPC round-trip | **Zero** (direct method call) |
-| GC pauses | Python/JVM heap pressure | **≤0.01%** (100% off-heap Panama) † |
-| Concurrent queries | Limited by Python GIL | **61,000 QPS** (Virtual Threads) † |
-| Dependencies | Python framework stack | **Single JAR** (zero Python) |
-
-† *Measured on Intel Core Ultra 9 285K, Java 25, AVX2. See [Benchmarks](#-benchmarks).*
-
-> See the full [spector-mcp documentation](spector-mcp/README.md) for CLI options, Cursor IDE config, and troubleshooting.
-
----
-
-## 🧠 Cognitive Memory (`spector-memory`)
-
-Spector Memory is a biologically-inspired cognitive memory engine that gives AI agents the ability to **remember**, **forget**, **consolidate**, and **associate** — with microsecond latency and zero garbage collection pressure.
-
-| Brain Region | Package | Function |
-|---|---|---|
-| 🧠 Cerebral Cortex | `cortex/` | 4-tier memory (Working → Episodic → Semantic → Procedural) |
-| 🔗 Synapses | `synapse/` | 32-byte header, 6-phase SIMD scoring, Bloom filter gating |
-| ⚡ Dopamine | `dopamine/` | Surprise detection, auto-importance, flashbulb pinning |
-| 😱 Amygdala | `amygdala/` | Emotional valence (positive/negative/neutral) |
-| 🔄 Hebbian | `hebbian/` | "Neurons that fire together wire together" |
-| 🛏️ Hippocampus | `hippocampus/` | Sleep consolidation, synaptic pruning, partition rebuild |
-| 😴 Habituation | `habituation/` | Anti-filter bubble — penalizes repetitive recall |
-| 🚫 Inhibition | `inhibition/` | Explicit memory suppression |
-
-**Key differentiators vs. Mem0, Letta, Zep:**
-- **0.13ms** recall latency at 1M memories (vs. 50–200ms) †
-- **Zero GC** — 100% off-heap Panama storage (≤0.01% GC overhead measured) †
-- **Fused scoring** — similarity × importance × decay in a single SIMD pass (no truncation trap)
-- **Synaptic tag gating** — 64-bit Bloom filter eliminates 99% of candidates in 1 CPU cycle
-
-† *Measured. See [Benchmarks](#-benchmarks).*
-
-> 📖 See the full [Cognitive Memory documentation](docs/docs/memory/index.md) and the [module README](spector-memory/README.md).
-
----
+[![Build](https://img.shields.io/github/actions/workflow/status/spectrayan/spector-search/ci.yml?branch=main)](https://github.com/spectrayan/spector-search/actions)
 
 ## ✨ Features
 
 - **🔥 SIMD-Accelerated** — Hardware-accelerated vector math via Java Vector API (AVX2/AVX-512/NEON)
-- **🧠 Cognitive Memory** — Biologically-inspired 4-tier memory with fused SIMD scoring, synaptic tags, temporal decay, surprise detection, and sleep consolidation
 - **🧠 Hybrid Search** — Combines semantic vector search (HNSW) with keyword search (BM25) via Reciprocal Rank Fusion
 - **💾 Zero-Copy Storage** — Off-heap vector storage using Panama Foreign Function & Memory API
 - **🧵 Virtual Thread Native** — Designed for Project Loom's virtual threads, no `synchronized` blocks
 - **🎯 High Recall** — HNSW approximate nearest-neighbor search with configurable recall@K ≥ 80%
 - **⚡ Sub-Millisecond Queries** — Branchless SIMD kernels with masked tail handling
 - **🗜️ Multi-Level Quantization** — INT8 (4×), INT4 (8×), and INT2 (16×) scalar quantization with non-uniform calibration and configurable rescore
-- **🗜️ SVASQ Quantization** — FWHT-rotated affine INT8 quantization with exact-norm header for high-accuracy zero-copy compression (retaining 99.5%+ recall)
-- **🗜️ SVASQ-4 Quantization** — INT4 nibble-packed variant of SVASQ achieving 6–8× compression vs float32 with 97–99% recall (with 3× rescore)
-- **🎯 SpectorIndex (IVF-HNSW-SVASQ)** — Multi-level adaptive vector index yielding 99.5%–100% recall on real text embeddings at aggressive 3% partition scanning rates
 - **🗜️ IVF-PQ Index** — Inverted file with product quantization for 32× memory compression at billion scale
 - **🤖 LLM Re-ranking** — Listwise relevance scoring via Ollama for precision-critical retrieval
 - **🖥️ GPU Acceleration** — CUDA kernel loader + SIMD batch similarity via Panama FFM
-- **🌐 Distributed Search** — gRPC-based coordinator/shard fan-out with consistent hash partitioning (unified in `spector-node`)
+- **🌐 Distributed Search** — gRPC-based coordinator/shard fan-out with consistent hash partitioning
 - **🧬 Embedding SPI** — Pluggable embedding providers (Ollama included out-of-the-box)
 - **📄 Chunked Ingestion** — Text, token-level, and streaming chunkers for large document support
-- **🤖 MCP Server** — Built-in Model Context Protocol server for AI agent integration
-
----
-
-## 📊 Benchmarks
-
-All numbers measured on **Intel Core Ultra 9 285K** (24 cores), **Java 25.0.1**, AVX2 256-bit SIMD, 30GB heap.
-
-### Core Engine (in-process, 128-dim vectors)
-
-| Benchmark | Result | Notes |
-|:---|:---|:---|
-| Vector search p50 | **88–143µs** | 10K–100K docs, HNSW M=16 |
-| In-process vs Python MCP | **23–113× faster** | 88µs vs 2–10ms |
-| GC overhead | **0.01%** | 1 pause / 100K searches |
-| Peak QPS (16 threads) | **61,011** | Concurrent vectorSearch |
-| Search at 1M memories | **p50=0.13ms** | 15× better than 2ms target |
-| Truncation trap recall loss | **100%** | Top-K-then-rerank loses all correct results |
-
-### Disk Persistence (4096-dim vectors, real Ollama embeddings)
-
-| Benchmark | Result | Notes |
-|:---|:---|:---|
-| DISK vs IN_MEMORY overhead | **2.3%** | mmap’d sharded store, near-zero cost |
-| Cold-start latency | **11.3ms** | First search after JVM restart |
-| Warm search p50 | **2.2ms** | OS page cache populated (4096-dim) |
-| WAL fsync append | **1,203 ops/s** | Crash-durable, per-write fsync |
-| WAL buffered append | **339,416 ops/s** | 2.9µs/op, no fsync |
-| WAL concurrent (8 threads) | **222,586 ops/s** | Multi-agent write scenario |
-| Cognitive recall (Ollama) | **64ms** | End-to-end: embed + score + rank |
-
-### Run Benchmarks
-
-```bash
-# Core performance (no external dependencies)
-mvn exec:exec -pl spector-bench \
-  -Dexec.mainClass=com.spectrayan.spector.bench.CorePerformanceBenchmark
-
-# Disk + Memory + WAL (requires Ollama with an embedding model)
-mvn exec:exec -pl spector-bench \
-  -Dexec.mainClass=com.spectrayan.spector.bench.DiskPersistenceBenchmark
-```
-
----
 
 ## 🏗 Architecture
 
-```mermaid
-graph LR
-    subgraph "🔬 Foundation"
-        core["spector-core<br/><i>SIMD kernels</i>"]
-        commons["spector-commons<br/><i>Chunkers, tokenizer</i>"]
-        config["spector-config<br/><i>SpectorConfig + YAML</i>"]
-        storage["spector-storage<br/><i>Panama MemorySegment</i>"]
-    end
-
-    subgraph "🧠 Intelligence"
-        embedApi["spector-embed-api<br/><i>Embedding SPI</i>"]
-        embedOllama["spector-embed-ollama<br/><i>Ollama provider</i>"]
-        index["spector-index<br/><i>HNSW + IVF-PQ + BM25</i>"]
-        query["spector-query<br/><i>Hybrid + RRF + rerank</i>"]
-        gpu["spector-gpu<br/><i>CUDA via Panama FFM</i>"]
-    end
-
-    subgraph "⚡ Engine"
-        rag["spector-rag<br/><i>RAG pipeline</i>"]
-        engine["spector-engine<br/><i>Search facade</i>"]
-        ingestion["spector-ingestion<br/><i>File ingest pipeline</i>"]
-        memory["spector-memory<br/><i>Cognitive memory 🧠</i>"]
-    end
-
-    subgraph "🌐 Runtime & Interfaces"
-        runtime["spector-runtime<br/><i>Composition root</i>"]
-        node["spector-node<br/><i>Armeria: REST + gRPC + SSE</i>"]
-        mcp["spector-mcp<br/><i>MCP Server (stdio)</i>"]
-        cli["spector-cli<br/><i>spectorctl</i>"]
-        client["spector-client<br/><i>Java SDK</i>"]
-        spring["spector-spring<br/><i>Spring AI</i>"]
-    end
-
-    subgraph "📦 Distribution"
-        metrics["spector-metrics<br/><i>Prometheus + JVM</i>"]
-        bench["spector-bench<br/><i>JMH benchmarks</i>"]
-        dist["spector-dist<br/><i>Fat JAR</i>"]
-    end
+```
+spector-search/
+├── spector-core/         # SIMD kernels (DotProduct, Cosine, Euclidean, VectorOps)
+├── spector-commons/      # Text chunkers, tokenizer, content extractor
+├── spector-storage/      # Panama MemorySegment stores (InMemory + Mmap + Quantized)
+├── spector-index/        # HNSW + IVF-PQ vector indexes + BM25 keyword index
+│   ├── hnsw/             # HNSW graph-based ANN index (standard + quantized INT8/INT4/INT2)
+│   ├── ivf/              # IVF inverted file index + quantized IVF-PQ
+│   ├── pq/               # Product quantizer (K-Means++, ADC)
+│   ├── text/             # BM25 keyword scoring + analyzers
+│   └── fuzz/             # Index fuzz testing framework
+├── spector-query/        # Hybrid orchestrator + RRF fusion + LLM re-ranking
+├── spector-embed-api/    # EmbeddingProvider SPI
+├── spector-embed-ollama/ # Ollama embedding provider implementation
+├── spector-gpu/          # GPU acceleration (Panama FFM + CUDA)
+├── spector-engine/       # Unified engine facade + lifecycle
+├── spector-server/       # REST API (Javalin + virtual threads)
+├── spector-cluster/      # Distributed gRPC search (coordinator + shards)
+└── spector-bench/        # JMH benchmarks
 ```
 
 ### Module Dependency Graph
 
-```mermaid
-graph TD
-    node["🌐 node"] --> runtime["⚡ runtime"]
-    node --> mcp["🤖 mcp"]
-    node --> metrics["📈 metrics"]
-    mcp --> runtime
-    mcp --> ingestion["📥 ingestion"]
-    cli["🖥️ cli"] --> runtime
-    cli --> client["📦 client"]
-
-    runtime --> engine["⚡ engine"]
-    runtime --> memory["🧠 memory"]
-    runtime --> ingestion
-
-    engine --> query["🔍 query"]
-    engine --> rag["🤖 rag"]
-    engine --> ingestion
-    engine --> index["📊 index"]
-    engine --> storage["💾 storage"]
-    engine --> embedapi["🧬 embed-api"]
-    engine -.-> gpu["🎮 gpu"]
-
-    memory --> index
-    memory --> storage
-    memory --> ingestion
-    memory --> embedapi
-    memory --> core["🔬 core"]
-
-    metrics --> engine
-    metrics --> memory
-
-    ingestion --> config["⚙️ config"]
-    ingestion --> embedapi
-
-    rag --> query
-    rag --> index
-    rag --> storage
-    rag --> embedapi
-
-    query --> index
-    index --> storage
-    index --> config
-    storage --> config
-    storage --> core
-    config --> core
-
-    embedapi --> commons["📄 commons"]
-    gpu --> core
-    gpu --> storage
-
-    dist["📦 dist"] --> mcp
-    dist --> cli
-    dist --> runtime
-
-    spring["🌱 spring"] --> engine
-    spring --> memory
-    spring --> metrics
-    bench["🧪 bench"] --> engine
-    bench --> memory
 ```
-
-> **Legend:** Solid arrows = compile dependency. Dotted arrow (`gpu`) = optional dependency.
-
----
+cluster → engine → query → index → core
+                        → index → storage → core
+server  → engine
+engine  → gpu (optional)
+engine  → commons
+engine  → embed-api
+gpu     → core, storage
+```
 
 ## 🚀 Quick Start
 
@@ -325,39 +64,24 @@ graph TD
 - **JDK 25+** (OpenJDK with Vector API incubator)
 - **Maven 3.9+**
 
-> **⚠️ JDK API Note:** Spector leverages two JDK APIs that are not yet finalized — the **Vector API** (incubator, for SIMD acceleration) and **Structured Concurrency** (preview, for safe parallel tasks). Both require JVM flags (`--add-modules jdk.incubator.vector`, `--enable-preview`). The remaining core technologies — **Panama FFM** (off-heap memory) and **Virtual Threads** — are fully finalized. The Vector API has been stable across 10 incubation rounds and carries low practical risk. See our [JDK API Status & Compatibility](docs/docs/getting-started/jdk-api-status.md) page for details, migration paths, and FAQ.
-
 ### Build & Test
 
 ```bash
 # Clone the repository
-git clone https://github.com/spectrayan/spector.git
-cd spector
+git clone https://github.com/spectrayan/spector-search.git
+cd spector-search
 
-# Build and run all tests
+# Build and run all tests (316+ tests)
 mvn clean test
 
-# Build the distribution JAR (single JAR, all modules)
-mvn package -pl spector-dist -am -DskipTests
-```
-
-### Run with Configuration
+# Start the REST server
+mvn exec:java -pl spector-server \
+  -Dexec.mainClass="com.spectrayan.spector.server.SpectorServer"
 
-All settings are read from `spector.yml` (see [Configuration Guide](docs/docs/configuration/parameters.md)):
-
-```bash
-# Start the MCP server (for AI agents)
-java --add-modules jdk.incubator.vector \
-  --enable-native-access=ALL-UNNAMED --enable-preview \
-  -jar spector-dist/target/spector.jar \
-  --config spector.yml
-
-# Start the file ingestion pipeline
-java --add-modules jdk.incubator.vector \
-  --enable-native-access=ALL-UNNAMED --enable-preview \
-  -cp spector-dist/target/spector.jar \
-  com.spectrayan.spector.ingestion.FileIngestionMain \
-  --config spector.yml --root .
+# Start with API key authentication
+mvn exec:java -pl spector-server \
+  -Dexec.mainClass="com.spectrayan.spector.server.SpectorServer" \
+  -Dexec.args="7070 384 my-secret-key"
 ```
 
 ### REST API
@@ -414,8 +138,6 @@ curl -X DELETE http://localhost:7070/api/v1/documents/doc-1
 curl http://localhost:7070/api/v1/metrics
 ```
 
----
-
 ## 🧩 Programmatic API
 
 ```java
@@ -443,24 +165,6 @@ try (var engine = new SpectorEngine(config)) {
 }
 ```
 
-### SVASQ-4 Quantization (6–8× Compression)
-
-```java
-// Fluent builder with SVASQ-4 quantization
-var engine = SpectorEngine.builder()
-    .dimensions(4096)           // e.g., qwen3-embedding
-    .capacity(500_000)
-    .svasq4()                    // INT4 FWHT-rotated, 3× rescore default
-    .build();
-
-// Or with explicit oversampling
-var config = SpectorConfig.DEFAULT
-    .withDimensions(768)
-    .withSvasq4(5);              // 5× oversampling for higher recall
-```
-
----
-
 ## ⚙️ Configuration
 
 | Parameter | Default | Description |
@@ -475,14 +179,12 @@ var config = SpectorConfig.DEFAULT
 | `b` | 0.75 | BM25 document length normalization |
 | `RRF k` | 60 | Reciprocal Rank Fusion constant |
 | `gpuEnabled` | false | Enable CUDA GPU acceleration |
-| `quantization` | NONE | Quantization type: NONE, SCALAR_INT8, SCALAR_INT4, SCALAR_INT2, SVASQ, SVASQ_4 |
+| `quantization` | NONE | Quantization type: NONE, SCALAR_INT8, SCALAR_INT4, SCALAR_INT2 |
 | `oversamplingFactor` | auto | Rescore oversampling (INT4→3, INT2→5, INT8→1). Higher = better recall |
 | `rerankerEnabled` | false | Enable LLM re-ranking via Ollama |
 | `rerankerModel` | — | Ollama model name (e.g., "llama3.2") |
 | `rerankerMaxCandidates` | 20 | Max docs sent to LLM for re-ranking |
 
----
-
 ## 🏎 Performance
 
 SIMD auto-detection adapts to your hardware:
@@ -504,46 +206,43 @@ Sub-microsecond vector math at every dimension:
 | 384       | ~100 ns   | 100 ns    | ~100 ns         | 100 ns          |
 | 768       | ~100 ns   | 100 ns    | ~100 ns         | 100 ns          |
 
-> Measured on 24-core Intel Core Ultra 9 285K x86, AVX2 256-bit (8 lanes), Java 25, ZGC. Values at 384+ dimensions are at `System.nanoTime()` resolution floor — real throughput confirmed at millions of ops/sec via JMH.
+> Measured on 24-core x86, AVX2 256-bit (8 lanes), Java 25, ZGC. Values at 384+ dimensions are at `System.nanoTime()` resolution floor — real throughput confirmed at millions of ops/sec via JMH.
 
 ### Search Latency (128-dim, top-10)
 
 | Scale | Keyword (BM25) | Vector (HNSW) | Hybrid (RRF) |
 |-------|---------------|---------------|--------------| 
-| **10K docs** | **0.18 ms** avg / 0.33 ms p99 | **0.04 ms** avg / 0.07 ms p99 | **0.17 ms** avg / 0.26 ms p99 |
-| **50K docs** | **0.44 ms** avg / 0.59 ms p99 | **0.08 ms** avg / 0.11 ms p99 | **0.51 ms** avg / 0.84 ms p99 |
-| **100K docs** | **1.53 ms** avg / 1.94 ms p99 | **0.10 ms** avg / 0.22 ms p99 | **1.76 ms** avg / 2.81 ms p99 |
+| **10K docs** | **0.15 ms** avg / 0.43 ms p99 | **0.05 ms** avg / 0.16 ms p99 | **0.14 ms** avg / 0.24 ms p99 |
+| **50K docs** | **0.35 ms** avg / 0.55 ms p99 | **0.04 ms** avg / 0.05 ms p99 | **0.25 ms** avg / 0.44 ms p99 |
+| **100K docs** | **0.60 ms** avg / 1.12 ms p99 | **0.05 ms** avg / 0.06 ms p99 | **0.47 ms** avg / 0.64 ms p99 |
 
 ### Search Throughput (queries/sec)
 
-| Scale | Keyword | Vector | Hybrid |
-|-------|---------|--------|--------|
-| **10K docs** | **5,490** | **23,726** | **5,993** |
-| **50K docs** | **2,264** | **13,287** | **1,958** |
-| **100K docs** | **653** | **9,925** | **569** |
+| Scale | Keyword | Vector | Hybrid | Vector top-100 |
+|-------|---------|--------|--------|----------------|
+| **10K docs** | **6,806** | **22,152** | **7,318** | 17,573 |
+| **50K docs** | **2,854** | **22,808** | **4,038** | 12,271 |
+| **100K docs** | **1,679** | **20,246** | **2,143** | 10,174 |
 
 ### Ingestion Throughput
 
 | Dataset Size | Time | Rate | Memory |
 |-------------|------|------|--------|
-| 10,000 | 2.1s | **4,679 docs/s** | +48 MB |
-| 50,000 | 20.5s | **2,430 docs/s** | +86 MB |
-| 100,000 | 1m 2s | **1,597 docs/s** | +202 MB |
+| 10,000 | 2.1s | **4,589 docs/s** | +20 MB |
+| 50,000 | 16.2s | **3,079 docs/s** | +94 MB |
+| 100,000 | 45.5s | **2,194 docs/s** | +188 MB |
 
-### Concurrency Scaling (50K docs, 128-dim, Hybrid Search)
+### Concurrency Scaling (50K docs, Hybrid Search)
 
 | Threads | Throughput | Avg Latency | Scaling Factor |
 |---------|-----------|-------------|----------------|
-| 1 | 1,231 ops/s | 0.81 ms | 1.0× |
-| 4 | 2,894 ops/s | 1.38 ms | **2.3×** |
-| 8 | 5,466 ops/s | 1.46 ms | **4.4×** |
-| 16 | 7,635 ops/s | 1.99 ms | **6.2×** |
+| 1 | 4,108 ops/s | 0.24 ms | 1.0× |
+| 4 | 12,344 ops/s | 0.32 ms | **3.0×** |
+| 8 | 17,628 ops/s | 0.44 ms | **4.3×** |
+| 16 | 18,324 ops/s | 0.79 ms | **4.5×** |
 
 > Run the full benchmark suite: `mvn -pl spector-bench exec:java`
 > HTML report generated at `spector-bench/target/performance-report.html`
->
-> [!TIP]
-> For the comprehensive, empirical sweeps across multiple partition configurations ($C \in \{32, 64, 128, 256\}$) and detailed HNSW shard promotion benchmarks on real text embeddings (using Qwen3-embedding 4096-dim), see our dedicated [Large-Scale Real-Embedding Benchmarks page](docs/docs/deep-dives/real-embedding-benchmarks.md).
 
 ---
 
@@ -555,7 +254,7 @@ All comparisons below use **100K documents, 128 dimensions, top-10 retrieval** a
 
 | Engine | Language | Avg Latency | P99 Latency | Notes |
 |--------|----------|------------|------------|-------|
-| **Spector** | Java 25 | **0.10 ms** | **0.22 ms** | SIMD via Vector API, pure in-process, 100K docs |
+| **Spector Search** | Java 25 | **0.05 ms** | **0.06 ms** | SIMD via Vector API, pure in-process |
 | hnswlib | C++ | ~0.1–0.5 ms | ~1 ms | Fastest native HNSW; single-threaded |
 | FAISS (HNSW) | C++/Python | ~0.2–0.8 ms | ~1–2 ms | Versatile; GPU support available |
 | Apache Lucene 9+ | Java | ~1–5 ms | ~5–10 ms | Segment-based; force-merge helps |
@@ -564,14 +263,11 @@ All comparisons below use **100K documents, 128 dimensions, top-10 retrieval** a
 | Milvus | Go/C++ | ~3–10 ms | ~10–35 ms | Scales to billions; DiskANN support |
 | Weaviate | Go | ~5–15 ms | ~25–40 ms | Built-in vectorization modules |
 
-> [!NOTE]
-> Spector's vector search latency is competitive with native C++ hnswlib for in-process workloads at 100K scale. External system numbers are from published benchmarks and ann-benchmarks.com. Hardware/configuration differences apply.
-
 ### Keyword Search (BM25, 100K docs)
 
 | Engine | Avg Latency | Notes |
 |--------|------------|-------|
-| **Spector** | **1.53 ms** | float[] scoring, min-heap top-K, virtual-thread parallel terms |
+| **Spector Search** | **0.51 ms** | float[] scoring, min-heap top-K, virtual-thread parallel terms |
 | Elasticsearch | <1–5 ms | Inverted index + skip lists, highly optimized |
 | Apache Lucene | <1–3 ms | Raw engine, no network overhead |
 | Weaviate (BM25) | ~10–30 ms | Go-based BM25 for hybrid search |
@@ -580,7 +276,7 @@ All comparisons below use **100K documents, 128 dimensions, top-10 retrieval** a
 
 | Engine | Approach | Avg Latency | Notes |
 |--------|----------|------------|-------|
-| **Spector** | RRF (parallel virtual threads) | **1.76 ms** | Both legs sub-ms at 10K; parallel via virtual threads |
+| **Spector Search** | RRF (parallel virtual threads) | **0.47 ms** | Both legs sub-ms; shared vthread executor |
 | Elasticsearch | RRF / linear combination | ~10–30 ms | Mature query planner, skip-list BM25 |
 | Qdrant | Sparse+Dense fusion | ~15–30 ms | Rust-based sparse vectors |
 | Weaviate | Hybrid BM25+HNSW | ~25–40 ms | Unified API, built-in vectorization |
@@ -589,7 +285,7 @@ All comparisons below use **100K documents, 128 dimensions, top-10 retrieval** a
 
 | Engine | Rate (100K docs) | Notes |
 |--------|-----------------|-------|
-| **Spector** | **1,597 docs/s** | In-process, HNSW graph build included |
+| **Spector Search** | **2,194 docs/s** | In-process, HNSW graph build included |
 | Elasticsearch | ~2,000–5,000 docs/s | Bulk API, depends on mapping & replicas |
 | Milvus | ~3,000–8,000 docs/s | Batch insert optimized |
 | Qdrant | ~2,000–5,000 docs/s | Payload indexing included |
@@ -605,25 +301,22 @@ All comparisons below use **100K documents, 128 dimensions, top-10 retrieval** a
 | **Off-Heap Vectors** | ✅ Panama MemorySegment | ✅ Lucene MMapDir | ✅ MMapDir | ❌ Heap-only | ✅ Mmap | ✅ Mmap |
 | **Virtual Threads** | ✅ Native Loom | ❌ Platform threads | N/A | N/A | N/A | N/A |
 | **Zero Dependencies** | ✅ JDK only | ❌ Heavy stack | ✅ Standalone | ✅ Header-only | ❌ Tokio runtime | ❌ etcd, MinIO, Pulsar |
-| **Quantization** | ✅ Scalar INT8/INT4/INT2 + SVASQ/SVASQ-4 + PQ | ✅ BBQ/Scalar | ✅ Scalar | ❌ None | ✅ Scalar/Binary | ✅ PQ/SQ |
+| **Quantization** | ✅ Scalar INT8/INT4/INT2 + PQ | ✅ BBQ/Scalar | ✅ Scalar | ❌ None | ✅ Scalar/Binary | ✅ PQ/SQ |
 | **Disk-based Index** | ✅ HNSW serialization | ✅ Segment merge | ✅ MMap | ❌ In-memory | ✅ On-disk HNSW | ✅ DiskANN |
 | **IVF-PQ** | ✅ 32× compression | ❌ None | ❌ None | ❌ None | ❌ None | ✅ IVF_PQ |
 | **GPU Acceleration** | ✅ CUDA (Panama FFM) | ❌ None | ❌ None | ❌ None | ❌ None | ✅ GPU |
 | **LLM Re-ranking** | ✅ Ollama | ❌ None | ❌ None | ❌ None | ❌ None | ❌ None |
 | **Distributed Search** | ✅ gRPC fan-out | ✅ Built-in | ❌ None | ❌ None | ✅ Raft | ✅ gRPC |
-| **MCP Server** | ✅ Built-in | ❌ None | ❌ None | ❌ None | ❌ None | ❌ None |
 
 ### Where Spector Excels
 
-- **🚀 Sub-millisecond vector search**: 0.04ms at 10K, 0.10ms at 100K (128-dim), competitive with native C++ implementations
-- **🔥 Fast BM25**: Sub-millisecond keyword search at 10K/50K scale — comparable to raw inverted index engines
+- **🚀 Sub-millisecond everything**: Vector (0.05ms), keyword (0.60ms), AND hybrid (0.47ms) at 100K docs
+- **🔥 Faster BM25 than Elasticsearch**: 0.60ms vs 1–5ms — float[] scoring + min-heap top-K + virtual-thread parallelism
 - **🧵 Modern JVM**: Only search engine built on Java 25 virtual threads + Vector API
 - **📦 Zero-dependency embedded**: Drop-in JAR, no external infrastructure needed
-- **⚡ 7.6K+ ops/sec concurrent**: 7,635 hybrid searches/sec at 16 threads (128-dim)
-- **🎯 23K+ vector QPS**: 23,726 vector queries/sec at 10K docs
-- **🗜️ IVF-PQ + SVASQ + SVASQ-4 + TurboQuant**: 6–32× memory reduction for large-scale datasets with high-accuracy calibration
-- **🔬 99.5%+ Recall**: IVF-HNSW-SVASQ (`SpectorIndex`) achieves near-perfect recall on real semantic embeddings scanning just 3% of the clusters
-- **🤖 Agent-Native**: Built-in MCP server — the only search engine with native AI agent integration
+- **⚡ 18K+ ops/sec concurrent**: 18,324 hybrid searches/sec at 16 threads
+- **🎯 20K+ vector QPS**: 20,246 vector queries/sec at 100K docs — outperforms native C++ hnswlib
+- **🗜️ IVF-PQ compression**: 32× memory reduction for billion-scale datasets
 - **🤖 LLM re-ranking**: Listwise Ollama-powered relevance scoring
 - **🖥️ GPU acceleration**: CUDA kernel launcher + SIMD batch similarity via Panama FFM
 - **🌐 Distributed search**: gRPC-based fan-out/merge with consistent hash sharding
@@ -634,21 +327,18 @@ All comparisons below use **100K documents, 128 dimensions, top-10 retrieval** a
 
 | Module | Tests | Coverage |
 |--------|-------|----------|
-| spector-core | 276 | SIMD kernels, similarity functions, scalar/SVASQ quantization, SIMD Euclidean |
+| spector-core | 117 | SIMD kernels, similarity functions, scalar quantization |
 | spector-commons | 28 | Text chunkers, token chunker, streaming chunker, content extractor |
 | spector-storage | 38 | Off-heap stores, mmap persistence, quantized vector store |
 | spector-index | 79 | HNSW recall, BM25 scoring, IVF-PQ, PQ encode/decode |
 | spector-query | 29 | RRF fusion, hybrid orchestration, LLM re-ranking |
-| spector-memory | 167 | Cognitive scoring, tier stores, mmap persistence, synapse, Bloom filters, reverse index, performance benchmarks + 10 Ollama E2E tests |
 | spector-embed-api | 9 | Embedding SPI contracts |
 | spector-embed-ollama | 7 | Ollama provider, fallback behavior |
 | spector-gpu | 14 | GPU detection, SIMD batch similarity, CUDA launcher |
 | spector-engine | 12 | End-to-end ingestion, IVF-PQ auto-training |
-| spector-node | 11 | REST endpoints, shard routing, hash consistency |
-| spector-mcp | 15 | MCP tool registry, tool handlers, schema builder |
-| **Total** | **685+** | **All passing ✅** |
-
----
+| spector-server | 6 | REST API endpoints |
+| spector-cluster | 5 | Shard routing, hash consistency |
+| **Total** | **316+** | **All passing ✅** |
 
 ## 📈 Roadmap
 
@@ -656,66 +346,25 @@ All comparisons below use **100K documents, 128 dimensions, top-10 retrieval** a
 - [x] BM25 keyword search
 - [x] Hybrid search with RRF fusion
 - [x] Scalar quantization (INT8, INT4, INT2) with non-uniform calibration and configurable rescore
-- [x] TurboQuant quantization (rotation + optimal scalar, 8× compression)
 - [x] Disk-based HNSW persistence
 - [x] Embedding provider SPI (Ollama)
 - [x] IVF-PQ vector index (32× compression)
 - [x] LLM-powered re-ranking
-- [x] GPU infrastructure (CUDA context, memory management via Panama FFM)
+- [x] GPU acceleration (CUDA via Panama FFM)
 - [x] Distributed search (gRPC coordinator/shards)
-- [x] REST API with CORS, auth, metrics, SSE streaming
-- [x] Standalone ingestion pipeline (`spector-ingestion`)
-- [x] Standalone RAG pipeline (`spector-rag`)
+- [x] REST API with CORS, auth, metrics
 - [x] Document deletion
 - [x] Auto-embed + bulk ingest endpoints
 - [x] gRPC TLS support
-- [x] SVASQ-4 quantization (FWHT-rotated INT4, nibble-packed — 6–8× compression vs float32)
-- [x] Structured concurrency (JEP 505) — `ConcurrentTasks` with dual-mode + feature flag
-- [x] **Native MCP Server** (`spector-mcp` — 13 tools: 6 search + 7 cognitive memory, stdio transport)
-- [x] **SpectorRuntime** — Unified application context (engine + memory), config-driven via `spector.yml`
-- [x] **Distribution JAR** (`spector-dist` — single fat JAR for all modules)
-- [ ] Streamable HTTP transport (MCP over HTTP for cloud/remote deployments)
-- [ ] Padding-aware storage (skip zero-padded dims — 25% savings for non-pow2 dimensions)
-- [ ] Norm header compression (float32 → float16 — 2 bytes/vector savings)
-- [ ] LoRA adapter routing (multi-tenant query projection via SIMD matrix multiply)
-- [ ] ColBERT late interaction reranking (native MaxSim via Panama FMA loops)
-- [ ] SVASQ-PQ hybrid (FWHT rotation + product quantization — 16–32× compression)
-- [ ] Flat-mode SVASQ (SVASQ compression of flat-shard residuals — 3× on flat shards)
-- [ ] GPU kernel dispatch (CUDA compute for batch similarity — requires CUDA Toolkit)
-- [ ] NPU acceleration (Intel/AMD NPU for INT8 batch operations via OpenVINO or DirectML)
 - [ ] WASM runtime for edge deployment
 
-> See the [detailed Roadmap](docs/docs/roadmap.md) for in-depth descriptions, projected savings, and implementation plans.
-
-## 📖 Documentation
-
-| Resource | Link |
-|:---------|:-----|
-| **Full Documentation** | [spectrayan.github.io/spector](https://spectrayan.github.io/spector/) |
-| **GitHub Wiki** | [Wiki](https://github.com/spectrayan/spector/wiki) |
-| **Cognitive Memory** | [Memory Docs](https://spectrayan.github.io/spector/memory/) |
-| **Neural Dashboard** | [Cortex Dashboard](https://spectrayan.github.io/spector/cortex/) |
-| **API Reference** | [REST API](https://spectrayan.github.io/spector/api-reference/rest-endpoints/) |
-| **MCP Server** | [MCP Docs](https://spectrayan.github.io/spector/sdk-usage/mcp-server/) |
-
 ## 🤝 Contributing
 
 We welcome contributions! Please see [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.
 
 ## 📄 License
 
-This repository is licensed under a **split licensing model**:
-
-1. **`spector-memory` Module**: Licensed under the **Business Source License 1.1 (BSL 1.1)**.
-   - Permits free use for non-production purposes.
-   - Permits production use for all purposes **except** offering it as a managed service or embedding/integrating it in a competing AI cognitive memory product or service.
-   - Automatically transitions to the **Apache License 2.0** on **May 27, 2030** (4 years from release).
-   - See [spector-memory/LICENSE](spector-memory/LICENSE) for details.
-
-2. **Core Infrastructure & All Other Modules**: Licensed under the **Apache License 2.0**.
-   - See [LICENSE](LICENSE) for details.
-
-For branding and trademark guidelines, please consult the [NOTICE](NOTICE) file.
+This project is licensed under the Apache License 2.0 — see [LICENSE](LICENSE) for details.
 
 ## 🔒 Security
 
diff --git a/deploy/k8s-statefulset.yaml b/deploy/k8s-statefulset.yaml
deleted file mode 100644
index 7d93c7a..0000000
--- a/deploy/k8s-statefulset.yaml
+++ /dev/null
@@ -1,116 +0,0 @@
-apiVersion: storage.k8s.io/v1
-kind: StorageClass
-metadata:
-  name: spector-nvme-local
-provisioner: kubernetes.io/no-provisioner
-volumeBindingMode: WaitForFirstConsumer
-allowVolumeExpansion: false
-description: "High-performance StorageClass for Spector cognitive off-heap data using local NVMe drives mapped via Local Volumes"
----
-apiVersion: v1
-kind: Service
-metadata:
-  name: spector
-  labels:
-    app: spector
-spec:
-  ports:
-    - port: 8080
-      name: http-api
-    - port: 9090
-      name: internal-sync
-  clusterIP: None
-  selector:
-    app: spector
----
-apiVersion: apps/v1
-kind: StatefulSet
-metadata:
-  name: spector-node
-  labels:
-    app: spector
-spec:
-  serviceName: "spector"
-  replicas: 3
-  selector:
-    matchLabels:
-      app: spector
-  template:
-    metadata:
-      labels:
-        app: spector
-      annotations:
-        # Inform container runtimes of low/high memory boundaries in cgroups v2
-        # resources.requests.memory sets memory.min/low, and limits.memory sets memory.max.
-        # This keeps the container's physical RAM consumption bounded while giving full headroom for page cache.
-        cgroups.kubernetes.io/memory-high: "15Gi"
-    spec:
-      # Pod Anti-Affinity: Prevent scheduling multiple Spector pods on the same physical bare-metal host.
-      # This ensures parallel off-heap page cache scans do not saturate host memory buses or NVMe IOPS.
-      affinity:
-        podAntiAffinity:
-          requiredDuringSchedulingIgnoredDuringExecution:
-            - labelSelector:
-                matchExpressions:
-                  - key: app
-                    operator: In
-                    values:
-                      - spector
-              topologyKey: "kubernetes.io/hostname"
-      containers:
-        - name: spector
-          image: spectrayan/spector:latest
-          imagePullPolicy: IfNotPresent
-          ports:
-            - containerPort: 8080
-              name: http-api
-            - containerPort: 9090
-              name: internal-sync
-          env:
-            - name: JAVA_OPTS
-              # PRODUCTION JVM tuning for Panama FFM off-heap cognitive engine:
-              # - Keep heap small (-Xmx2G) to leave the remaining 14GB of the 16GB container limit
-              #   fully free for OS page-cache (madvise prefetching and zero-copy mmap mapped regions).
-              # - Enable vector API, preview features, and compiler optimizations.
-              value: "-Xms2G -Xmx2G -XX:+UseG1GC -XX:MaxGCPauseMillis=20 -XX:+UnlockDiagnosticVMOptions -XX:+UnlockExperimentalVMOptions --add-modules=jdk.incubator.vector --enable-preview -Djava.lang.foreign.restricted=permit"
-            - name: SPECTOR_MEMORY_DIR
-              value: "/var/lib/spector/data"
-          resources:
-            requests:
-              cpu: "4"
-              memory: "16Gi"
-            limits:
-              cpu: "8"
-              # Under cgroups v2:
-              # - limits.memory translates to memory.max = 16Gi
-              # - requests.memory translates to memory.low/min = 16Gi
-              # Since the JVM heap is restricted to 2Gi, the Linux kernel can comfortably allocate
-              # up to 14Gi for system page cache. This guarantees zero JVM heap OOMs, while
-              # preventing the Kubernetes OOM killer from terminating the pod when the page cache is hot.
-              memory: "16Gi"
-          volumeMounts:
-            - name: spector-offheap-store
-              mountPath: /var/lib/spector/data
-          livenessProbe:
-            httpGet:
-              path: /api/v2/memory/status
-              port: 8080
-            initialDelaySeconds: 30
-            periodSeconds: 10
-            timeoutSeconds: 3
-          readinessProbe:
-            httpGet:
-              path: /api/v2/memory/status
-              port: 8080
-            initialDelaySeconds: 15
-            periodSeconds: 5
-            timeoutSeconds: 2
-  volumeClaimTemplates:
-    - metadata:
-        name: spector-offheap-store
-      spec:
-        accessModes: [ "ReadWriteOnce" ]
-        storageClassName: "spector-nvme-local"
-        resources:
-          requests:
-            storage: 100Gi
diff --git a/docs/docs/about.md b/docs/docs/about.md
deleted file mode 100644
index eae1844..0000000
--- a/docs/docs/about.md
+++ /dev/null
@@ -1,220 +0,0 @@
-# 🌟 What is Spector?
-
-> **The Zero-Overhead, Agent-Ready AI Memory Backbone.**
->
-> Legacy search engines bolted vectors onto text databases. Spector is designed from the ground up for modern AI — combining vector similarity, keyword search, and hybrid ranking in a single embeddable library with zero external dependencies. Connect any AI agent via the built-in MCP server, or embed directly in your application.
-
-Spector is an open-source, high-performance search engine built entirely on modern Java 25. It's designed for developers who want sub-millisecond search, native AI agent integration, and zero infrastructure complexity. Drop in a JAR, write a few lines of code, and you have production-grade hybrid search with built-in agent support.
-
----
-
-## 🎯 What It Does
-
-Spector indexes documents with their vector embeddings and text content, then retrieves them using multiple strategies — directly from AI agents or your application code:
-
-```mermaid
-graph LR
-    subgraph Clients
-        MCP["🤖 AI Agent (MCP)"]
-        REST["🌐 REST API"]
-        SDK["📦 Java SDK"]
-    end
-    
-    subgraph Search Modes
-        A[Vector Search] --> D[Results]
-        B[Keyword Search] --> D
-        C[Hybrid Search] --> D
-    end
-    
-    subgraph Engines
-        A --> E[HNSW ANN]
-        B --> F[BM25 Scoring]
-        C --> E
-        C --> F
-        C --> G[RRF Fusion]
-    end
-    
-    MCP --> A & B & C
-    REST --> A & B & C
-    SDK --> A & B & C
-```
-
-| Mode | How It Works | Best For |
-|------|-------------|----------|
-| **🧠 Vector Search** | HNSW approximate nearest neighbor graphs | Semantic similarity |
-| **📝 Keyword Search** | BM25 scoring with term frequency saturation | Exact term matching |
-| **🧬 Hybrid Search** | Combines both via Reciprocal Rank Fusion | Best-of-both-worlds |
-| **🤖 RAG Pipeline** | Ingest → chunk → embed → retrieve → context assembly | LLM applications |
-| **🏛️ SpectorIndex** | IVF-HNSW-SVASQ adaptive hybrid index | Scale + recall |
-
----
-
-## 💎 Key Differentiators
-
-### 🤖 Agent-Native (MCP Protocol)
-
-Includes a built-in [Model Context Protocol](https://modelcontextprotocol.io/) server with 6 tools. AI agents connect directly via JSON-RPC — no Python frameworks, no network round-trips.
-
-| Feature | Python Vector DB MCP | **Spector MCP** |
-|:---|:---|:---|
-| Search latency | 2–10ms | **88µs p50** (23–113× faster) † |
-| Network overhead | HTTP/gRPC round-trip | **Zero** (in-process) |
-| Concurrent queries | Limited by Python GIL | **61,000 QPS** † |
-| Dependencies | Python framework stack | **Single JAR** |
-
-† *Measured. See [Benchmarks](../#-benchmarks).*
-
-> [!TIP]
-> See the [MCP Server Guide](../sdk-usage/mcp-server.md) to connect Claude Desktop, Cursor, or any MCP client in minutes.
-
-### 📦 Pure Java, Zero Dependencies
-
-Unlike most vector databases that rely on C++, Rust, or Python bindings, Spector is 100% Java. It uses the JDK's own Vector API for SIMD acceleration — no JNI, no native libraries, no external infrastructure.
-
-> [!TIP]
-> Add the JAR to your classpath and you're done. No Docker, no clusters, no ops.
-
-### 🚀 Modern JVM Technologies
-
-| Technology | Purpose |
-|-----------|---------| 
-| Java Vector API | SIMD-accelerated math (AVX2/AVX-512/NEON) |
-| Panama FFM | Zero-copy memory-mapped storage, GPU interop |
-| Virtual Threads | Millions of concurrent operations without thread pools |
-| Structured Concurrency | Safe parallel task management |
-
-### ⚡ Sub-Millisecond at Scale
-
-**HNSW** at 100K documents (128 dimensions, top-10, M=16, efSearch=64):
-
-| Search Type | Average Latency | Throughput |
-|-------------|----------------|------------|
-| Vector | **0.13 ms** | 7,556 QPS |
-| Keyword | **0.98 ms** | 1,019 QPS |
-| Hybrid | **1.01 ms** | 994 QPS |
-
-**SpectorIndex (IVF-HNSW-SVASQ)** at 10K documents (4096-dim real Qwen3 embeddings):
-
-| Config | Average Latency | Throughput | Recall@10 |
-|--------|----------------|------------|----------|
-| nCentroids=128, nProbe=4 | **0.46 ms** | **2,173 QPS** | **1.0000** |
-| nCentroids=64, nProbe=4 | **0.62 ms** | 1,601 QPS | **1.0000** |
-| nCentroids=128, nProbe=16 | **1.26 ms** | 792 QPS | **1.0000** |
-
-> [!NOTE]
-> SpectorIndex achieves **perfect recall while searching only 3.1% of the data** (nProbe=4 out of 128 centroids). Ingestion is 28–160× faster than standalone HNSW. Numbers measured on 24-core x86, AVX2, Java 25, ZGC with Qwen3-embedding real vectors. For comprehensive, multi-centroid sweeps and adaptive HNSW shard promotion benchmarks, see the dedicated [Large-Scale Real-Embedding Benchmarks page](deep-dives/real-embedding-benchmarks.md).
-
-### 🏠 Dual Deployment Modes
-
-| Mode | Description | Best For |
-|------|-------------|----------|
-| **Embedded** | In-process library, zero network overhead | Microservices, desktop apps, edge |
-| **Server** | REST API with CORS, auth, and metrics | Teams, multi-language clients |
-
-### 🗜️ Advanced Quantization (SVASQ + IVF-PQ)
-
-Spector offers two quantization paths:
-
-- **SVASQ (Vectorized Affine Scalar Quantization):** Uses the Fast Walsh-Hadamard Transform to spread variance before INT8 quantization, achieving **4× compression with near-lossless recall** (~97–99.5%). Used inside SpectorIndex shards.
-- **IVF-PQ (Product Quantization):** Provides **32× memory compression** for billion-scale datasets.
-
-> [!IMPORTANT]
-> SVASQ gives INT8 the precision of INT12–16 by rotating vectors before quantization. See the [SVASQ Deep Dive](deep-dives/svasq-deep-dive.md) for the full theory.
-
----
-
-## 📊 How Spector Compares
-
-### Latency Comparison (100K docs, 128-dim, top-10)
-
-| Engine | Language | Vector Avg | Vector P99 |
-|--------|----------|-----------|-----------| 
-| **⚡ Spector** | **Java 25** | **0.13 ms** | **0.26 ms** |
-| hnswlib | C++ | 0.1–0.5 ms | ~1 ms |
-| FAISS | C++ | 0.2–0.8 ms | 1–2 ms |
-| Lucene 9+ | Java | 1–5 ms | 5–10 ms |
-| Elasticsearch 8+ | Java | 2–10 ms | 10–25 ms |
-| Qdrant | Rust | 2–5 ms | 10–25 ms |
-| Milvus | Go/C++ | 3–10 ms | 10–35 ms |
-
-> [!NOTE]
-> Spector's vector search latency is competitive with native C++ implementations (hnswlib, FAISS) for in-process workloads. Numbers for external systems are from published benchmarks and ann-benchmarks.com. Hardware and configuration differences apply — these are directional comparisons, not controlled A/B tests.
-
-### Feature Comparison
-
-| Feature | Spector | Elasticsearch | Qdrant | Milvus | hnswlib |
-|---------|---------|--------------|--------|--------|---------| 
-| **Deployment** | Embedded + Server | Cluster only | Server only | Cluster only | Embedded only |
-| **MCP Server** | ✅ Built-in (6 tools) | ❌ | ❌ | ❌ | ❌ |
-| **Hybrid Search** | ✅ RRF built-in | ✅ RRF | ✅ Sparse+Dense | ✅ RRF | ❌ |
-| **Zero Dependencies** | ✅ JDK only | ❌ Heavy stack | ❌ Tokio runtime | ❌ etcd, MinIO, Pulsar | ✅ Header-only |
-| **Virtual Threads** | ✅ Project Loom | ❌ Platform threads | N/A (Rust async) | N/A (Go goroutines) | N/A |
-| **GPU Acceleration** | ✅ CUDA (Panama FFM) | ❌ | ✅ Vulkan (indexing) | ✅ CUDA (search + indexing) | ❌ |
-| **Quantization** | ✅ Scalar INT8 + IVF-PQ | ✅ BBQ + Scalar + DiskBBQ (IVF) | ✅ Scalar + Binary | ✅ IVF-PQ + IVF-SQ | ❌ |
-| **Re-ranking** | ✅ LLM via Ollama | ✅ Elastic Rerank + Inference API | ✅ FastEmbed / ColBERT | ✅ vLLM Ranker + Cross-encoder | ❌ |
-| **Distributed** | ✅ gRPC fan-out | ✅ Built-in sharding | ✅ Raft consensus | ✅ gRPC + etcd | ❌ |
-| **SIMD Acceleration** | ✅ Java Vector API | ✅ simdvec (Panama) | ✅ Native SIMD | ✅ AVX/NEON | ✅ AVX/SSE |
-
-> [!NOTE]
-> This comparison reflects publicly available information as of May 2025. Feature availability may vary by version and deployment mode. All products are actively evolving.
-
----
-
-## 🛠️ Use Cases
-
-### 🤖 Agentic AI Memory
-
-Connect AI agents (Claude, Cursor, custom) directly to Spector via the built-in MCP server. The agent autonomously ingests documents, searches for relevant context, and retrieves information — all with zero Python glue-code. *"Point your LLM at Spector's MCP port, and it instantly has mathematically-perfect long-term memory."*
-
-### 🤖 Retrieval-Augmented Generation (RAG)
-
-Ingest documents (PDF, HTML, Markdown), chunk them with token awareness, generate embeddings, and retrieve relevant context for LLM prompting — all through a single `/api/v1/rag` endpoint or the `rag_query` MCP tool.
-
-### 🔍 Semantic Search Applications
-
-Power product search, documentation search, code search, or any application where meaning matters more than exact keywords.
-
-### 💡 Recommendation Systems
-
-Use vector similarity to find items similar to what users have engaged with. Sub-millisecond latency makes real-time recommendations practical.
-
-### 🏢 Hybrid Enterprise Search
-
-Combine keyword precision (finding exact product SKUs, error codes) with semantic understanding (finding conceptually related documents).
-
-### 📱 Embedded Analytics
-
-Drop Spector into existing Java applications without infrastructure changes. Perfect for desktop applications, microservices, or edge deployments.
-
----
-
-## ✅ When to Choose Spector
-
-> [!NOTE]
-> **Choose Spector when:**
-> - You want AI agents to autonomously search your data (MCP integration)
-> - You want sub-millisecond hybrid search without infrastructure complexity
-> - Your stack is Java/JVM and you want native integration
-> - You need an embedded search library with server-mode option
-> - You want GPU acceleration without leaving the JVM
-> - Zero external dependencies matters to your deployment
-
-> [!WARNING]
-> **Consider alternatives when:**
-> - You need a managed cloud service with zero ops
-> - Your team primarily works in Python/Rust/Go
-> - You need built-in ML model serving
-
----
-
-## 🚀 Next Steps
-
-- [Getting Started](getting-started/quickstart.md) — Build and run your first search in 5 minutes
-
-- [MCP Server Guide](sdk-usage/mcp-server.md) — Connect an AI agent in 3 steps
-
-- [Architecture Overview](architecture/overview.md) — Understand how it works under the hood
-
-- [REST API Reference](api-reference/rest-endpoints.md) — Full API documentation
-
-- [Core Concepts](architecture/core-concepts.md) — Deep dive into the algorithms
\ No newline at end of file
diff --git a/docs/docs/api-reference/error-codes.md b/docs/docs/api-reference/error-codes.md
deleted file mode 100644
index 3a4bc2a..0000000
--- a/docs/docs/api-reference/error-codes.md
+++ /dev/null
@@ -1,238 +0,0 @@
-# Spector Error Code Reference
-
-All Spector errors follow the `SPE-XXX-YYY` schema where `XXX` identifies the
-error category and `YYY` identifies the specific error within that category.
-
-**Stability guarantee:** Error codes are immutable once assigned. They will never
-be reassigned or removed, even if deprecated.
-
----
-
-## How to Read Error Codes
-
-```
-SPE-100-001
-│   │    │
-│   │    └── Specific error (001–999)
-│   └─────── Category (100–900)
-└─────────── Spector prefix
-```
-
-| Category Range | Subsystem |
-|---|---|
-| `SPE-100-xxx` | Input Validation |
-| `SPE-110-xxx` | Configuration |
-| `SPE-200-xxx` | Index |
-| `SPE-210-xxx` | Storage |
-| `SPE-300-xxx` | Embedding |
-| `SPE-310-xxx` | Memory |
-| `SPE-400-xxx` | GPU |
-| `SPE-500-xxx` | Server (REST/gRPC/MCP) |
-| `SPE-510-xxx` | Client SDK |
-| `SPE-600-xxx` | Ingestion |
-| `SPE-700-xxx` | Cluster |
-| `SPE-900-xxx` | Internal |
-
----
-
-## Validation Errors (SPE-100)
-
-These errors indicate invalid input provided by the caller.
-
-| Code | Message | Common Cause |
-|---|---|---|
-| `SPE-100-001` | Vector dimensions must be positive | Dimensions set to 0 or negative in config |
-| `SPE-100-002` | Expected {n} dimensions but received {m} | Query vector has different dimensionality than the index |
-| `SPE-100-003` | Vector must not be null | Null vector passed to ingest or search |
-| `SPE-100-004` | Vector length does not match expected dimensions | Float array length ≠ configured dimensions |
-| `SPE-100-005` | top_k must be between 1 and max | top_k set to 0, negative, or exceeding index capacity |
-| `SPE-100-006` | Document ID must not be null or empty | Empty string or null passed as document ID |
-| `SPE-100-007` | Required argument must not be null | A required method parameter was null |
-| `SPE-100-008` | Argument out of range | A numeric parameter is outside valid bounds |
-| `SPE-100-009` | Unsupported quantization type | Quantization type not recognized |
-| `SPE-100-010` | Capacity exceeded | Collection or buffer exceeds maximum size |
-| `SPE-100-011` | SimilarityFunction must not be null | Null similarity function in config |
-| `SPE-100-012` | Collection must not be empty | Empty list/array passed where non-empty required |
-| `SPE-100-013` | Invalid value for parameter | General argument validation failure |
-| `SPE-100-014` | Argument must be non-negative | Negative value for a non-negative parameter |
-| `SPE-100-015` | Length mismatch | Two arrays that must be same length differ |
-| `SPE-100-016` | Bit width invalid | Quantization bit width not 2, 4, or 8 |
-
----
-
-## Configuration Errors (SPE-110)
-
-These errors indicate problems with Spector configuration files or values.
-
-| Code | Message | Resolution |
-|---|---|---|
-| `SPE-110-001` | Configuration file not found | Verify the config file path. Check `spector.yml` or `spector.properties` exists. |
-| `SPE-110-002` | Failed to parse configuration | Check YAML/properties syntax. Validate with a YAML linter. |
-| `SPE-110-003` | Invalid configuration value | Verify the reported field value is within documented bounds. |
-| `SPE-110-004` | Configuration profile not found | Check available profiles in your config file. |
-| `SPE-110-005` | Required configuration key missing | Add the missing key to your config file. |
-
----
-
-## Index Errors (SPE-200)
-
-These errors relate to vector index operations.
-
-| Code | Message | Resolution |
-|---|---|---|
-| `SPE-200-001` | HNSW index construction failed | Check available memory. Reduce `capacity` or `dimensions`. |
-| `SPE-200-002` | HNSW graph integrity check failed | Index file may be corrupted. Re-build from source data. |
-| `SPE-200-003` | Index has reached maximum capacity | Increase `capacity` in config, or delete old documents. |
-| `SPE-200-004` | Index is read-only | Index was opened in read-only mode. |
-| `SPE-200-005` | IVF centroid training failed | Provide more training vectors or reduce `nlist`. |
-| `SPE-200-006` | BM25 text tokenization failed | Check text encoding. Ensure input is valid UTF-8. |
-| `SPE-200-007` | Index serialization to disk failed | Check disk space and write permissions. |
-| `SPE-200-008` | Index deserialization from disk failed | Index file may be corrupted or incompatible version. |
-| `SPE-200-009` | Index not trained | Call `train()` before searching an IVF-PQ index. |
-| `SPE-200-010` | Centroid count must be positive | Set `nlist` to a positive integer. |
-| `SPE-200-011` | HNSW graph connectivity below threshold | Index quality degraded. Rebuild with higher `efConstruction`. |
-
----
-
-## Storage Errors (SPE-210)
-
-These errors relate to vector storage and disk I/O.
-
-| Code | Message | Resolution |
-|---|---|---|
-| `SPE-210-001` | Memory segment is closed | Don't use the store after calling `close()`. |
-| `SPE-210-002` | Memory-mapped file creation failed | Check disk space, file permissions, and OS mmap limits. |
-| `SPE-210-003` | Vector store has reached capacity | Increase `capacity` or delete old vectors. |
-| `SPE-210-004` | Disk I/O operation failed | Check disk health, space, and permissions. |
-| `SPE-210-005` | Write-ahead log write failed | Check disk space. WAL directory may be full. |
-| `SPE-210-006` | Write-ahead log replay failed | WAL file may be corrupted. Check logs for details. |
-| `SPE-210-007` | Vector store not initialized | Ensure the store is opened before operations. |
-| `SPE-210-008` | Invalid index file format | File was created by an incompatible version. |
-
----
-
-## Embedding Errors (SPE-300)
-
-These errors relate to embedding provider connectivity.
-
-| Code | Message | Resolution |
-|---|---|---|
-| `SPE-300-001` | Embedding provider is unavailable | Check that Ollama (or your provider) is running. Verify the URL. |
-| `SPE-300-002` | Embedding request failed | Check provider logs for details. |
-| `SPE-300-003` | Embedding request timed out | Increase timeout or check provider load. |
-| `SPE-300-004` | Embedding model not found | Pull the model: `ollama pull <model-name>`. |
-| `SPE-300-005` | Embedding dimension mismatch | Model returns different dimensions than index expects. Change model or recreate index. |
-
----
-
-## Memory Errors (SPE-310)
-
-These errors relate to the cognitive memory subsystem.
-
-| Code | Message | Resolution |
-|---|---|---|
-| `SPE-310-001` | Memory tier has reached capacity | Configure higher capacity or enable consolidation. |
-| `SPE-310-002` | Cognitive recall pipeline failed | Check logs for underlying cause. |
-| `SPE-310-003` | Memory consolidation failed | Check disk space and WAL integrity. |
-| `SPE-310-004` | Memory ID not found | The specified memory ID does not exist in any tier. |
-| `SPE-310-005` | Memory WAL file corrupted | WAL file is unreadable. Recovery may require reinitialization. |
-
----
-
-## GPU Errors (SPE-400)
-
-These errors relate to GPU acceleration via CUDA/Panama FFM.
-
-| Code | Message | Resolution |
-|---|---|---|
-| `SPE-400-001` | CUDA driver not found | Install NVIDIA CUDA drivers. GPU features will fall back to CPU. |
-| `SPE-400-002` | GPU memory allocation failed | Reduce batch size or free GPU memory from other processes. |
-| `SPE-400-003` | GPU kernel launch failed | Check CUDA compatibility. Update GPU drivers. |
-| `SPE-400-004` | GPU device error | Hardware issue or driver crash. Restart and check `nvidia-smi`. |
-| `SPE-400-005` | GPU memory budget exceeded | Reduce `gpuMemoryBudget` or free GPU memory. |
-
----
-
-## Server Errors (SPE-500)
-
-These errors are returned by the Spector REST API, gRPC, or MCP server.
-
-| Code | HTTP Status | Message | Resolution |
-|---|---|---|---|
-| `SPE-500-001` | 400 | Bad request | Fix the request body or parameters. |
-| `SPE-500-002` | 404 | Resource not found | Verify the document/collection ID exists. |
-| `SPE-500-003` | 409 | Resource conflict | Document with this ID already exists. |
-| `SPE-500-004` | 401 | Unauthorized | Provide a valid API key. |
-| `SPE-500-005` | 503 | Service unavailable | Backend service is down. Retry after delay. |
-| `SPE-500-006` | 500 | MCP tool execution failed | Check MCP tool logs for details. |
-| `SPE-500-007` | 500 | gRPC transport error | Check network connectivity between nodes. |
-
----
-
-## Client SDK Errors (SPE-510)
-
-These errors are raised by the Spector client SDK.
-
-| Code | Message | Resolution |
-|---|---|---|
-| `SPE-510-001` | Failed to connect to Spector server | Verify server URL and that the server is running. |
-| `SPE-510-002` | Client request timed out | Increase timeout or check server load. |
-| `SPE-510-003` | Invalid server response | Server may be returning unexpected format. Check version compatibility. |
-
----
-
-## Ingestion Errors (SPE-600)
-
-These errors relate to the document ingestion pipeline.
-
-| Code | Message | Resolution |
-|---|---|---|
-| `SPE-600-001` | Unsupported document format | Use a supported format (PDF, TXT, MD, HTML, DOCX). |
-| `SPE-600-002` | Document chunking failed | Check document encoding and content. |
-| `SPE-600-003` | Ingestion pipeline failed | Check logs for the underlying cause. |
-| `SPE-600-004` | Failed to read document | Check file path, read permissions, or ensure the file is not corrupted. |
-
----
-
-## Cluster Errors (SPE-700)
-
-These errors relate to distributed mode operations.
-
-| Code | Message | Resolution |
-|---|---|---|
-| `SPE-700-001` | Shard is unavailable | Check that all cluster nodes are running. |
-| `SPE-700-002` | Cluster membership operation failed | Check network connectivity between nodes. |
-| `SPE-700-003` | Request routing failed | Shard map may be stale. Wait for rebalance. |
-
----
-
-## Internal Errors (SPE-900)
-
-These errors indicate a bug in Spector itself. **If you encounter a 900-series
-error, please report it** with the full error code and any available log context.
-
-| Code | Message | What It Means |
-|---|---|---|
-| `SPE-900-001` | Internal error | An unexpected condition occurred. This is a bug. |
-| `SPE-900-002` | Internal invariant violated | A data structure is in an invalid state. This is a bug. |
-| `SPE-900-003` | Reached unreachable code path | A switch/if exhaustiveness gap. This is a bug. |
-| `SPE-900-004` | Concurrent execution failed | A virtual thread subtask failed unexpectedly. |
-
----
-
-## JSON Error Response Format
-
-All REST API errors return a structured JSON response:
-
-```json
-{
-  "code": "SPE-100-002",
-  "category": "Validation",
-  "message": "[SPE-100-002] Expected 384 dimensions but received 768",
-  "status": 400,
-  "path": "/api/v1/ingest",
-  "timestamp": "2026-05-30T12:00:00Z"
-}
-```
-
-Legacy errors (without error codes) omit the `code` and `category` fields.
diff --git a/docs/docs/api-reference/overview.md b/docs/docs/api-reference/overview.md
new file mode 100644
index 0000000..1e8fc5a
--- /dev/null
+++ b/docs/docs/api-reference/overview.md
@@ -0,0 +1,37 @@
+# API Reference
+
+Spector Search exposes a REST API via Javalin on port 7070 (configurable).
+
+## Base URL
+
+```
+http://localhost:7070
+```
+
+## Authentication
+
+When an API key is configured, include it as a header:
+
+```
+X-API-Key: your-secret-key
+```
+
+## Endpoints Summary
+
+| Method | Path | Description |
+|--------|------|-------------|
+| GET | `/health` | Health check |
+| GET | `/api/v1/status` | Engine status |
+| POST | `/api/v1/search` | Hybrid search (auto-detects mode) |
+| POST | `/api/v1/vector-search` | Vector-only search |
+| POST | `/api/v1/bm25` | Keyword-only BM25 search |
+| POST | `/api/v1/hybrid` | Explicit hybrid search |
+| POST | `/api/v1/rag` | RAG retrieval with context assembly |
+| POST | `/api/v1/ingest` | Ingest a single document |
+| POST | `/api/v1/ingest/auto` | Ingest with auto-embedding |
+| POST | `/api/v1/ingest/bulk` | Bulk ingest documents |
+| POST | `/api/v1/index` | Create/manage indexes |
+| DELETE | `/api/v1/documents/{id}` | Delete a document |
+| GET | `/api/v1/metrics` | Request metrics |
+
+See [REST Endpoints](rest-endpoints.md) for detailed request/response schemas.
diff --git a/docs/docs/api-reference/rest-endpoints.md b/docs/docs/api-reference/rest-endpoints.md
index bd96a5b..57a2c87 100644
--- a/docs/docs/api-reference/rest-endpoints.md
+++ b/docs/docs/api-reference/rest-endpoints.md
@@ -1,205 +1,66 @@
-# 🌐 REST API Reference
+# REST Endpoints
 
-> **Complete reference for all Spector REST endpoints.** The API runs on an embedded Armeria server with virtual threads, accepting and returning JSON. Every request gets its own virtual thread — no connection limits to worry about.
+## Ingest
 
----
-
-## 🔧 Base Configuration
-
-| Setting | Default | Description |
-|---------|---------|-------------|
-| Base URL | `http://localhost:7070` | Configurable port |
-| Content-Type | `application/json` | All requests and responses |
-| Auth Header | `X-API-Key: <key>` | Optional, configured at startup |
-| CORS | Enabled | All origins by default |
-
-> [!NOTE]
-> When an API key is configured, requests without a valid key receive `401 Unauthorized`.
-
----
-
-## 💚 Health & Status
-
-### `GET /health`
+### POST /api/v1/ingest
 
-Quick health check for load balancers and monitoring.
+Ingest a single document with a pre-computed vector.
 
-```bash
-curl http://localhost:7070/health
-```
+**Request:**
 
-**Response `200`:**
-```json
-{"status": "UP"}
-```
-
----
-
-### `GET /api/v1/status`
-
-Engine status including SIMD capabilities, GPU availability, and configuration.
-
-```bash
-curl http://localhost:7070/api/v1/status
-```
-
-**Response `200`:**
 ```json
 {
-  "status": "RUNNING",
-  "simd": "AVX2 (256-bit, 8 lanes)",
-  "gpuAvailable": false,
-  "rerankerEnabled": false,
-  "documentCount": 1250,
-  "dimensions": 384,
-  "capacity": 100000
+  "id": "doc-1",
+  "title": "Java Vector API",
+  "content": "SIMD-accelerated search engine on modern JVM",
+  "vector": [0.1, 0.2, 0.3, 0.4, 0.5]
 }
 ```
 
----
-
-### `GET /api/v1/metrics`
-
-Request metrics including query counts, latencies, and throughput.
+**Response (200):**
 
-```bash
-curl http://localhost:7070/api/v1/metrics
-```
-
-**Response `200`:**
 ```json
 {
-  "totalQueries": 4521,
-  "totalIngestions": 1250,
-  "avgLatencyMs": 0.34,
-  "p99LatencyMs": 1.12,
-  "queriesPerSecond": 8432.5
+  "id": "doc-1",
+  "status": "indexed"
 }
 ```
 
----
-
-## 📥 Ingest Endpoints
-
-### `POST /api/v1/ingest`
-
-Ingest a single document with a pre-computed vector embedding.
-
-```bash
-curl -X POST http://localhost:7070/api/v1/ingest \
-  -H "Content-Type: application/json" \
-  -H "X-API-Key: my-secret-key" \
-  -d '{
-    "id": "doc-1",
-    "title": "Java Vector API",
-    "content": "SIMD-accelerated search engine on modern JVM",
-    "vector": [0.1, 0.2, 0.3, 0.4, 0.5]
-  }'
-```
-
-**Request Schema:**
-
-| Field | Type | Required | Description |
-|-------|------|----------|-------------|
-| `id` | string | ✅ | Unique document identifier |
-| `title` | string | ❌ | Document title |
-| `content` | string | ✅ | Text content for BM25 indexing |
-| `vector` | float[] | ✅ | Embedding vector (must match configured dimensions) |
-| `metadata` | object | ❌ | Arbitrary key-value metadata |
-
-**Response `200`:**
-```json
-{"id": "doc-1", "status": "indexed"}
-```
-
----
-
-### `POST /api/v1/ingest/auto`
-
-Ingest with automatic embedding generation. Requires a configured embedding provider (e.g., Ollama).
-
-```bash
-curl -X POST http://localhost:7070/api/v1/ingest/auto \
-  -H "Content-Type: application/json" \
-  -d '{
-    "id": "doc-2",
-    "title": "Panama FFM",
-    "content": "Foreign Function and Memory API for zero-copy storage"
-  }'
-```
-
-| Field | Type | Required | Description |
-|-------|------|----------|-------------|
-| `id` | string | ✅ | Unique document identifier |
-| `title` | string | ❌ | Document title |
-| `content` | string | ✅ | Text content (used for both BM25 and embedding) |
-| `metadata` | object | ❌ | Arbitrary key-value metadata |
-
----
-
-### `POST /api/v1/ingest/bulk`
+### POST /api/v1/ingest/bulk
 
 Ingest multiple documents in a single request.
 
-```bash
-curl -X POST http://localhost:7070/api/v1/ingest/bulk \
-  -H "Content-Type: application/json" \
-  -d '{
-    "documents": [
-      {"id": "d1", "content": "first document", "vector": [0.1, 0.2, 0.3]},
-      {"id": "d2", "content": "second document", "vector": [0.4, 0.5, 0.6]}
-    ]
-  }'
-```
+**Request:**
 
-**Response `200`:**
 ```json
 {
-  "indexed": 2,
-  "failed": 0,
-  "results": [
-    {"id": "d1", "status": "indexed"},
-    {"id": "d2", "status": "indexed"}
+  "documents": [
+    {"id": "d1", "content": "first document", "vector": [0.1, 0.2, 0.3]},
+    {"id": "d2", "content": "second document", "vector": [0.4, 0.5, 0.6]}
   ]
 }
 ```
 
 ---
 
-## 🔍 Search Endpoints
+## Search
 
-### `POST /api/v1/search`
+### POST /api/v1/search
 
-Auto-detecting search endpoint. The mode is determined by which fields you provide:
+Auto-detecting search. Provide `text` for keyword, `vector` for vector, or both for hybrid.
 
-| Fields Provided | Mode | Engine Used |
-|-----------------|------|-------------|
-| `text` only | 📝 KEYWORD | BM25 |
-| `vector` only | 🧠 VECTOR | HNSW |
-| `text` + `vector` | 🧬 HYBRID | RRF Fusion |
+**Request:**
 
-```bash
-curl -X POST http://localhost:7070/api/v1/search \
-  -H "Content-Type: application/json" \
-  -d '{
-    "text": "vector search engine",
-    "vector": [0.1, 0.2, 0.3, 0.4, 0.5],
-    "topK": 10
-  }'
+```json
+{
+  "text": "vector search engine",
+  "vector": [0.1, 0.2, 0.3],
+  "topK": 10
+}
 ```
 
-**Request Schema:**
-
-| Field | Type | Required | Description |
-|-------|------|----------|-------------|
-| `text` | string | ❌* | Query text for keyword search |
-| `vector` | float[] | ❌* | Query vector for similarity search |
-| `topK` | int | ❌ | Number of results (default: 10, max: 10000) |
-
-> [!IMPORTANT]
-> *At least one of `text` or `vector` must be provided.
+**Response (200):**
 
-**Response `200`:**
 ```json
 {
   "results": [
@@ -207,203 +68,135 @@ curl -X POST http://localhost:7070/api/v1/search \
       "id": "doc-1",
       "score": 0.9523,
       "title": "Java Vector API",
-      "content": "SIMD-accelerated search engine on modern JVM"
+      "content": "SIMD-accelerated search engine..."
     }
   ],
   "searchMode": "HYBRID",
-  "latencyMs": 0.47,
-  "totalResults": 1
+  "latencyMs": 0.47
 }
 ```
 
----
-
-### `POST /api/v1/vector-search`
+### POST /api/v1/vector-search
 
-Explicit vector-only similarity search.
+Vector-only similarity search.
 
-```bash
-curl -X POST http://localhost:7070/api/v1/vector-search \
-  -H "Content-Type: application/json" \
-  -d '{"vector": [0.1, 0.2, 0.3, 0.4, 0.5], "topK": 10}'
-```
+### POST /api/v1/bm25
 
-### `POST /api/v1/bm25`
-
-Explicit keyword-only BM25 search.
-
-```bash
-curl -X POST http://localhost:7070/api/v1/bm25 \
-  -H "Content-Type: application/json" \
-  -d '{"text": "SIMD acceleration", "topK": 10}'
-```
+Keyword-only BM25 search. Only requires `text` field.
 
-### `POST /api/v1/hybrid`
+### POST /api/v1/hybrid
 
 Explicit hybrid search combining vector + keyword via RRF.
 
-```bash
-curl -X POST http://localhost:7070/api/v1/hybrid \
-  -H "Content-Type: application/json" \
-  -d '{"text": "vector search", "vector": [0.1, 0.2, 0.3, 0.4, 0.5], "topK": 10}'
-```
-
 ---
 
-### `GET /api/v1/search/stream` (SSE)
-
-Streaming search via Server-Sent Events. Results are emitted one-by-one as they become available, enabling progressive display in UIs.
-
-```bash
-curl -N "http://localhost:7070/api/v1/search/stream?text=vector+search&topK=5&mode=HYBRID"
-```
-
-**Query Parameters:**
+## RAG
 
-| Param | Type | Required | Default | Description |
-|-------|------|----------|---------|-------------|
-| `text` | string | ❌* | — | Query text for keyword/hybrid search |
-| `vector` | string | ❌* | — | Comma-separated floats (e.g., `0.1,0.2,0.3`) |
-| `topK` | int | ❌ | 10 | Number of results |
-| `mode` | string | ❌ | auto-detect | `KEYWORD`, `VECTOR`, or `HYBRID` |
+### POST /api/v1/rag
 
-> [!IMPORTANT]
-> *At least one of `text` or `vector` must be provided.
+Retrieval-Augmented Generation endpoint. Retrieves relevant context for LLM prompting.
 
-**Event Stream:**
+**Request:**
 
+```json
+{
+  "query": "How does HNSW indexing work?",
+  "topK": 5,
+  "tokenLimit": 4096,
+  "searchMode": "hybrid"
+}
 ```
-event: result
-data: {"id":"doc-1","score":0.9523,"rank":1}
-
-event: result
-data: {"id":"doc-3","score":0.8741,"rank":2}
 
-event: result
-data: {"id":"doc-7","score":0.8102,"rank":3}
+**Response (200):**
 
-event: done
-data: {"totalHits":3,"queryTimeMs":12,"mode":"HYBRID"}
+```json
+{
+  "context": "Assembled context text from relevant chunks...",
+  "attributions": [
+    {"documentId": "doc-1", "chunkOffset": 0},
+    {"documentId": "doc-3", "chunkOffset": 2}
+  ],
+  "isEmpty": false
+}
 ```
 
-**Event Types:**
+**Error Responses:**
 
-| Event | Description |
-|-------|-------------|
-| `result` | A single search result with id, score, and rank |
-| `done` | Search complete — includes timing and metadata |
-| `error` | An error occurred during search |
+- `400` — Missing or invalid query (must be 1–2000 chars)
+- `503` — Embedding provider unavailable
 
-> [!TIP]
-> Use the `EventSource` API in browsers or any SSE client library. Results stream immediately as they are scored, giving users instant feedback.
+---
 
-**JavaScript Example:**
-```javascript
-const source = new EventSource('/api/v1/search/stream?text=HNSW+algorithm&topK=5');
+## Index Management
 
-source.addEventListener('result', (event) => {
-  const result = JSON.parse(event.data);
-  console.log(`#${result.rank}: ${result.id} (score: ${result.score})`);
-});
+### POST /api/v1/index
 
-source.addEventListener('done', (event) => {
-  const meta = JSON.parse(event.data);
-  console.log(`Search complete in ${meta.queryTimeMs}ms`);
-  source.close();
-});
-```
+Create or manage indexes.
 
 ---
 
-## 🤖 RAG (Retrieval-Augmented Generation)
-
-### `POST /api/v1/rag`
-
-Retrieve relevant context for LLM prompting. Performs search, then assembles a context window from matching chunks.
+## Document Management
 
-```bash
-curl -X POST http://localhost:7070/api/v1/rag \
-  -H "Content-Type: application/json" \
-  -d '{
-    "query": "How does HNSW indexing work?",
-    "topK": 5,
-    "tokenLimit": 4096,
-    "searchMode": "hybrid"
-  }'
-```
+### DELETE /api/v1/documents/{id}
 
-**Request Schema:**
+Delete a document by ID.
 
-| Field | Type | Required | Default | Description |
-|-------|------|----------|---------|-------------|
-| `query` | string | ✅ | — | Query text (1–2000 chars) |
-| `topK` | int | ❌ | 5 | Results to retrieve (1–100) |
-| `tokenLimit` | int | ❌ | 4096 | Max context tokens (1–8192) |
-| `searchMode` | string | ❌ | "vector" | `"vector"` or `"hybrid"` |
+**Response (200):**
 
-**Response `200`:**
 ```json
 {
-  "context": "Assembled context text from relevant document chunks...",
-  "attributions": [
-    {"documentId": "doc-1", "chunkOffset": 0},
-    {"documentId": "doc-3", "chunkOffset": 2}
-  ],
-  "isEmpty": false
+  "id": "doc-1",
+  "deleted": true
 }
 ```
 
 ---
 
-## 🗑️ Document Management
-
-### `DELETE /api/v1/documents/{id}`
-
-Delete a document by its ID.
+## Monitoring
 
-```bash
-curl -X DELETE http://localhost:7070/api/v1/documents/doc-1
-```
+### GET /health
 
-**Response `200`:**
-```json
-{"id": "doc-1", "deleted": true}
-```
-
----
+Returns `200 OK` when the server is running.
 
-## 📊 Index Management
+### GET /api/v1/status
 
-### `POST /api/v1/index`
+Engine status including SIMD capabilities, GPU availability, and reranker configuration.
 
-Create or manage indexes.
+### GET /api/v1/metrics
 
-```bash
-curl -X POST http://localhost:7070/api/v1/index \
-  -H "Content-Type: application/json" \
-  -d '{"action": "create", "name": "my-index", "dimensions": 384}'
-```
+Request metrics including query counts, latencies, and throughput.
 
 ---
 
-## ❌ Error Responses
+## Runnable REST API Example
 
-| Status | Meaning |
-|--------|---------|
-| `200` | ✅ Success |
-| `400` | Bad request (validation error, dimension mismatch) |
-| `401` | Unauthorized (invalid or missing API key) |
-| `404` | Resource not found |
-| `503` | Service unavailable (embedding provider down) |
+This complete example demonstrates ingesting a document and searching for it:
 
----
-
-## 🔗 See Also
-
-- [Getting Started](../getting-started/quickstart.md) — Quick start with curl examples
+```bash
+# 1. Start the server (in another terminal)
+mvn exec:java -pl spector-server \
+  -Dexec.mainClass="com.spectrayan.spector.server.SpectorServer" \
+  -Dexec.args="7070 5"
 
-- [Java SDK Guide](../sdk-usage/java-client.md) — Type-safe programmatic access
+# 2. Ingest a document
+curl -X POST http://localhost:7070/api/v1/ingest \
+  -H "Content-Type: application/json" \
+  -d '{
+    "id": "readme-1",
+    "title": "Spector Search",
+    "content": "Ultra-fast SIMD-accelerated semantic search engine",
+    "vector": [0.9, 0.1, 0.3, 0.7, 0.5]
+  }'
 
-- [CLI Reference](../cli-reference/spectorctl.md) — Command-line access to the API
+# 3. Search for it
+curl -X POST http://localhost:7070/api/v1/search \
+  -H "Content-Type: application/json" \
+  -d '{
+    "text": "fast search engine",
+    "vector": [0.8, 0.2, 0.3, 0.6, 0.4],
+    "topK": 5
+  }'
 
-- [Configuration Guide](../configuration/parameters.md) — Server and auth configuration
\ No newline at end of file
+# 4. Delete the document
+curl -X DELETE http://localhost:7070/api/v1/documents/readme-1
+```
diff --git a/docs/docs/architecture/core-concepts.md b/docs/docs/architecture/core-concepts.md
deleted file mode 100644
index b675e75..0000000
--- a/docs/docs/architecture/core-concepts.md
+++ /dev/null
@@ -1,284 +0,0 @@
-# 🧠 Core Concepts
-
-> **The algorithms and data structures that make Spector blazingly fast.** This page explains HNSW, IVF-PQ, BM25, RRF, and SIMD acceleration — the building blocks behind sub-millisecond hybrid search.
-
----
-
-## 🌐 HNSW (Hierarchical Navigable Small World)
-
-HNSW is the primary index structure for approximate nearest neighbor (ANN) vector search. It builds a multi-layered graph where each node represents a vector, and edges connect similar vectors.
-
-### 🔍 How It Works
-
-```mermaid
-graph TD
-    subgraph "Layer 3 — Few nodes, long-range links"
-        A3[A] --- D3[D]
-    end
-    
-    subgraph "Layer 2 — More nodes, medium links"
-        A2[A] --- C2[C] --- D2[D] --- F2[F]
-    end
-    
-    subgraph "Layer 1 — Most nodes, short links"
-        A1[A] --- B1[B] --- C1[C] --- D1[D] --- E1[E] --- F1[F] --- G1[G]
-    end
-    
-    subgraph "Layer 0 — All nodes, local links"
-        A0[A] --- B0[B] --- C0[C] --- D0[D] --- E0[E] --- F0[F] --- G0[G] --- H0[H]
-    end
-    
-    A3 -.-> A2 -.-> A1 -.-> A0
-    D3 -.-> D2 -.-> D1 -.-> D0
-```
-
-**Search algorithm:**
-1. Enter at the top layer's entry point
-2. Greedily traverse to the closest node at each layer
-3. Drop to the next layer, using the found node as the new entry
-4. At layer 0, explore `efSearch` candidates to find top-K nearest neighbors
-
-### ⚙️ Key Parameters
-
-| Parameter | Default | Effect |
-|-----------|---------|--------|
-| `M` | 16 | Max connections per node. Higher = better recall, more memory |
-| `efConstruction` | 200 | Build-time beam width. Higher = better graph quality, slower build |
-| `efSearch` | 50 | Query-time beam width. Higher = better recall, slower query |
-
-### 🚀 Why HNSW is Fast
-
-- **Logarithmic complexity** — O(log N) layers mean search scales well
-
-- **Greedy navigation** — Each step moves closer to the target
-
-- **SIMD distance computation** — Every neighbor comparison uses hardware-accelerated vector math
-
-- **Cache-friendly** — Graph traversal exhibits good spatial locality
-
-### 💾 Persistence Format
-
-Spector uses a page-aligned binary format for HNSW persistence:
-
-```
-[Header: 64 bytes]  → magic "SPHW", version, metadata
-[Vector Region]     → 4KB-aligned float32 vectors (memory-mappable)
-[Graph Region]      → Per-node adjacency lists
-[ID Table]          → External ID ↔ internal offset mapping
-```
-
-> [!TIP]
-> Loading is a single `mmap` syscall — no deserialization needed. Startup is instant regardless of index size.
-
----
-
-## 🗜️ IVF-PQ (Inverted File with Product Quantization)
-
-IVF-PQ enables billion-scale search with **32× memory compression**. It combines two techniques:
-
-### 📊 IVF: Coarse Partitioning
-
-```mermaid
-graph LR
-    subgraph "Training: K-Means clusters vectors into cells"
-        Q[Query Vector] --> C0[Cell 0<br/>• • •]
-        Q --> C1[Cell 1<br/>• • •]
-        Q --> C2[Cell 2<br/>• • •]
-        Q --> C3[Cell N<br/>• • •]
-    end
-```
-
-Instead of comparing against all vectors, IVF narrows search to the `nprobe` nearest cells.
-
-### 🧬 PQ: Product Quantization
-
-PQ compresses each vector from full float32 to compact codes:
-
-| Step | Data | Size |
-|------|------|------|
-| Original vector (384 dims) | `[0.12, 0.45, ..., 0.78]` | 1,536 bytes |
-| Split into 16 subspaces | `[sub1] [sub2] ... [sub16]` | — |
-| Each quantized to 1 byte | `[42] [187] [3] ... [201]` | **16 bytes** |
-| **Compression ratio** | | **96×** |
-
-> [!IMPORTANT]
-> At 32 subspaces with 256 centroids, you get **32× compression** while maintaining recall@10 ≥ 80%.
-
-### ⚡ ADC (Asymmetric Distance Computation)
-
-During search, PQ uses lookup tables instead of full distance computation:
-
-1. Pre-compute distances from query to all 256 centroids per subspace (256 × 32 = 8,192 lookups)
-2. For each compressed vector, sum up table lookups (32 additions per vector)
-3. This is orders of magnitude faster than full float32 distance
-
----
-
-## 📝 BM25 (Best Matching 25)
-
-BM25 is the keyword scoring algorithm used for text search. It extends TF-IDF with term saturation and document length normalization.
-
-### 📐 Scoring Formula
-
-```
-score(D, Q) = Σ IDF(qi) × (tf(qi, D) × (k1 + 1)) / (tf(qi, D) + k1 × (1 - b + b × |D|/avgdl))
-```
-
-| Variable | Meaning |
-|----------|---------|
-| `tf(qi, D)` | Term frequency of query term qi in document D |
-| `IDF(qi)` | Inverse document frequency (how rare the term is) |
-| `\|D\|` | Document length |
-| `avgdl` | Average document length across corpus |
-| `k1` | Term frequency saturation (default: 1.2) |
-| `b` | Length normalization factor (default: 0.75) |
-
-### ⚙️ Key Parameters
-
-| Parameter | Default | Effect |
-|-----------|---------|--------|
-| `k1` | 1.2 | Controls how quickly term frequency saturates. Lower = faster saturation |
-| `b` | 0.75 | Controls document length penalty. 0 = no normalization, 1 = full |
-
-### 🚀 Spector's BM25 Implementation
-
-| Optimization | Benefit |
-|-------------|---------|
-| `float[]` scoring | Raw float arrays for max throughput |
-| Min-heap top-K | Only tracks best K results (no full sort) |
-| Virtual-thread parallel terms | Multi-term queries score in parallel |
-
-**Result:** 0.60 ms avg at 100K docs — faster than Elasticsearch's BM25.
-
----
-
-## 🧬 Reciprocal Rank Fusion (RRF)
-
-RRF combines ranked results from multiple search methods into a single unified ranking.
-
-### 📐 Formula
-
-```
-RRF_score(d) = Σ 1 / (k + rank_i(d))
-```
-
-Where `k` = 60 (default fusion constant) and `rank_i(d)` = rank of document d in the i-th result list.
-
-### 💡 Example
-
-```mermaid
-graph LR
-    subgraph "BM25 Results"
-        B1["docA (rank 1)"]
-        B2["docB (rank 2)"]
-        B3["docC (rank 3)"]
-    end
-    
-    subgraph "Vector Results"
-        V1["docC (rank 1)"]
-        V2["docA (rank 2)"]
-        V3["docD (rank 3)"]
-    end
-    
-    subgraph "🧬 RRF Fusion (k=60)"
-        R1["docA: 0.0325 ✨"]
-        R2["docC: 0.0323"]
-        R3["docB: 0.0161"]
-        R4["docD: 0.0159"]
-    end
-    
-    B1 --> R1
-    B2 --> R3
-    B3 --> R2
-    V1 --> R2
-    V2 --> R1
-    V3 --> R4
-```
-
-### ✅ Why RRF Works
-
-- **Rank-based, not score-based** — Avoids normalization issues between different scoring methods
-
-- **Resistant to outliers** — A high score in one system can't dominate
-
-- **Parameter-light** — Only one tunable constant (k)
-
-- **Empirically strong** — Competitive with learned fusion methods
-
----
-
-## ⚡ SIMD Acceleration via Java Vector API
-
-Spector uses the Java Vector API (`jdk.incubator.vector`) to execute vector math on hardware SIMD lanes.
-
-### 🔬 How It Works
-
-```java
-// Traditional scalar loop (1 operation per cycle):
-for (int i = 0; i < dim; i++) {
-    sum += a[i] * b[i];
-}
-
-// SIMD vectorized (8-16 operations per cycle):
-var species = FloatVector.SPECIES_PREFERRED;  // AVX2=8, AVX-512=16
-for (int i = 0; i < dim; i += species.length()) {
-    var va = FloatVector.fromArray(species, a, i);
-    var vb = FloatVector.fromArray(species, b, i);
-    sum = va.fma(vb, sum);  // Fused multiply-add
-}
-```
-
-### 🎯 Supported Kernels
-
-| Kernel | Operation | Used By |
-|--------|-----------|---------|
-| Dot Product | `Σ(a[i] × b[i])` | Vector similarity (DOT_PRODUCT mode) |
-| Cosine Similarity | `dot(a,b) / (‖a‖ × ‖b‖)` | Vector similarity (COSINE mode) |
-| Euclidean Distance | `√Σ(a[i] - b[i])²` | Vector similarity (EUCLIDEAN mode) |
-| Vector Ops | Norm, normalize, quantize | Internal utilities |
-
-### 🖥️ Hardware Adaptation
-
-The Vector API automatically selects the best SIMD width for your hardware:
-
-| ISA | Width | Lanes (float32) | Platform |
-|-----|-------|-----------------|----------|
-| AVX2 | 256-bit | 8 | Most modern x86 CPUs |
-| AVX-512 | 512-bit | 16 | Intel Xeon, recent AMD |
-| NEON | 128-bit | 4 | Apple Silicon, ARM servers |
-
-### 📊 Performance Impact
-
-SIMD kernels achieve sub-microsecond latency:
-
-| Dimension | Dot Product P50 | Cosine P50 |
-|-----------|----------------|-----------| 
-| 32 | 200 ns | 1,100 ns |
-| 128 | <100 ns | <100 ns |
-| 384 | ~100 ns | ~100 ns |
-| 768 | ~100 ns | ~100 ns |
-
-> [!NOTE]
-> Values at 128+ dimensions are at `System.nanoTime()` resolution floor. JMH confirms millions of ops/sec throughput.
-
-### 🎨 Design Principles
-
-- **Never hardcode lane widths** — Always use `FloatVector.SPECIES_PREFERRED`
-
-- **Branchless tail handling** — Use `VectorMask` for dimensions not divisible by lane count
-
-- **Zero allocations in hot path** — Reuse buffers, slice-based APIs
-
-- **Fused multiply-add** — Use FMA where available for accuracy and speed
-
----
-
-## 🔗 See Also
-
-- [Architecture Overview](overview.md) — How these components fit together
-
-- [GPU Acceleration](gpu-acceleration.md) — CUDA kernels for batch operations
-
-- [Performance Tuning](../operations/performance-tuning.md) — How to tune these parameters
-
-- [Configuration Guide](../configuration/parameters.md) — All parameter defaults and ranges
\ No newline at end of file
diff --git a/docs/docs/architecture/distributed-mode.md b/docs/docs/architecture/distributed-mode.md
deleted file mode 100644
index 2473c3e..0000000
--- a/docs/docs/architecture/distributed-mode.md
+++ /dev/null
@@ -1,253 +0,0 @@
-# 🌐 Distributed Mode
-
-> **Scale Spector horizontally across multiple nodes.** The distributed architecture uses consistent hash sharding, configurable replication, heartbeat-based membership, and parallel query fan-out with result merging via gRPC.
-
----
-
-## 🏗️ Architecture Overview
-
-```mermaid
-graph TD
-    Client["👤 Client"] --> Coord["🧭 Query Coordinator<br/>Fan-out + Merge + Dedup"]
-    
-    Coord --> S0["💾 Shard 0<br/>(Primary)"]
-    Coord --> S1["💾 Shard 1<br/>(Primary)"]
-    Coord --> S2["💾 Shard 2<br/>(Primary)"]
-    
-    S0 --> R0["📋 Replica 0a"]
-    S1 --> R1["📋 Replica 1a"]
-    S2 --> R2["📋 Replica 2a"]
-    
-    MS["💓 Membership Service<br/>(Heartbeat)"] -.-> S0
-    MS -.-> S1
-    MS -.-> S2
-```
-
----
-
-## 🧩 Components
-
-### 🔑 Shard Manager
-
-The `ConsistentHashShardManager` distributes documents across shards using consistent hashing on document IDs.
-
-```mermaid
-graph LR
-    subgraph "Hash Ring"
-        H1["Hash(doc-A) → Shard 0"]
-        H2["Hash(doc-B) → Shard 2"]
-        H3["Hash(doc-C) → Shard 1"]
-    end
-```
-
-**Properties:**
-
-- Each shard owns a range on a hash ring (using virtual nodes for even distribution)
-
-- Document ID → hash → ring position → assigned shard (deterministic)
-
-- Adding a shard migrates only affected documents (minimal data movement)
-
-- Shard count changes apply without full cluster restart
-
----
-
-### 📋 Replication Manager
-
-Each shard maintains configurable replicas for fault tolerance.
-
-| Behavior | Details |
-|----------|---------|
-| Writes | Go to primary, replicate to all replicas within 2s |
-| Reads | Served from any fully-synchronized replica |
-| Primary failure | Replica promoted within 10 seconds |
-| Recovery | Delta sync only (data changed since failure) |
-
----
-
-### 💓 Membership Service
-
-Heartbeat-based cluster membership tracking.
-
-| Parameter | Default | Range |
-|-----------|---------|-------|
-| `heartbeatInterval` | 2s | 500ms–30s |
-| `heartbeatTimeout` | 10s | 3s–120s |
-
-**Behavior:**
-
-- Nodes send periodic heartbeats to announce liveness
-
-- Missing heartbeats beyond timeout → node marked unavailable
-
-- New nodes trigger shard rebalancing within 5 seconds
-
-- All active nodes converge to the same membership view within 5 seconds
-
----
-
-### 🧭 Query Coordinator
-
-```mermaid
-sequenceDiagram
-    participant Client as 👤 Client
-    participant Coord as 🧭 Coordinator
-    participant S0 as 💾 Shard 0
-    participant S1 as 💾 Shard 1
-    participant S2 as 💾 Shard 2
-
-    Client->>Coord: Search request
-    par Fan-out (parallel gRPC)
-        Coord->>S0: Query
-        Coord->>S1: Query
-        Coord->>S2: Query
-    end
-    S0-->>Coord: Results
-    S1-->>Coord: Results
-    S2-->>Coord: Results
-    Note over Coord: Merge by score + dedup by ID
-    Coord-->>Client: ✨ Global top-K results
-```
-
-> [!NOTE]
-> If some shards timeout, the coordinator returns **partial results** from responding shards plus metadata indicating which shards were unreachable.
-
----
-
-## 🚀 Deployment Guide
-
-### Prerequisites
-
-- All nodes must run the same Spector version
-
-- Nodes must be reachable via gRPC (default port: 9090)
-
-- Network latency between nodes should be <10ms for optimal performance
-
-### Starting a Cluster
-
-**Node 1 (seed node):**
-
-```bash
-java -jar spector-node.jar \
-  --cluster-mode \
-  --node-id node-1 \
-  --grpc-port 9090 \
-  --shard-count 4 \
-  --replica-count 2 \
-  --seeds node-1:9090
-```
-
-**Node 2:**
-
-```bash
-java -jar spector-node.jar \
-  --cluster-mode \
-  --node-id node-2 \
-  --grpc-port 9090 \
-  --shard-count 4 \
-  --replica-count 2 \
-  --seeds node-1:9090
-```
-
-**Node 3:**
-
-```bash
-java -jar spector-node.jar \
-  --cluster-mode \
-  --node-id node-3 \
-  --grpc-port 9090 \
-  --shard-count 4 \
-  --replica-count 2 \
-  --seeds node-1:9090
-```
-
-### ✅ Verifying Cluster Health
-
-```bash
-curl http://node-1:7070/api/v1/status
-```
-
-```json
-{
-  "status": "RUNNING",
-  "clusterMode": true,
-  "activeNodes": 3,
-  "shardCount": 4,
-  "replicaCount": 2,
-  "topology": {
-    "node-1": {"status": "ACTIVE", "shards": [0, 1]},
-    "node-2": {"status": "ACTIVE", "shards": [2, 3]},
-    "node-3": {"status": "ACTIVE", "shards": ["0-replica", "2-replica"]}
-  }
-}
-```
-
-### 🔒 gRPC TLS Setup
-
-For production deployments, enable TLS on gRPC communication:
-
-```bash
-java -jar spector-node.jar \
-  --cluster-mode \
-  --grpc-port 9090 \
-  --grpc-tls \
-  --grpc-cert /path/to/cert.pem \
-  --grpc-key /path/to/key.pem \
-  --grpc-ca /path/to/ca.pem
-```
-
----
-
-## 🛡️ Failure Scenarios
-
-### 💥 Node Failure
-
-```mermaid
-graph TD
-    A["💥 Node fails"] --> B["💓 Heartbeat timeout detected"]
-    B --> C["🚫 Node removed from routing"]
-    C --> D["📋 Replica promoted to primary"]
-    D --> E["✅ Queries continue from remaining nodes"]
-```
-
-### 🔄 Node Recovery
-
-```mermaid
-graph TD
-    A["🔄 Node resumes heartbeats"] --> B["💓 Re-registered in membership"]
-    B --> C["📋 Delta sync (only changed data)"]
-    C --> D["✅ Node resumes serving reads/writes"]
-```
-
-### 🌐 Network Partition
-
-- Nodes on each side continue serving their local shards
-
-- Queries to unreachable shards return partial results with timeout metadata
-
-- When partition heals, membership reconverges and replicas sync
-
----
-
-## 📈 Scaling Guidelines
-
-| Cluster Size | Shards | Documents | Estimated Throughput |
-|-------------|--------|-----------|---------------------|
-| 2 nodes | 2–4 | Up to 500K | ~15K QPS |
-| 4 nodes | 4–8 | Up to 2M | ~29K QPS |
-| 8 nodes | 8–16 | Up to 5M | ~55K QPS |
-| 16 nodes | 16–32 | Up to 10M | ~100K QPS |
-
-> [!NOTE]
-> Throughput estimates assume 128-dim vectors, top-10, hybrid search, extrapolated from single-node measured throughput of ~7.3K concurrent hybrid ops/s at 16 threads. Actual cluster throughput depends on network latency, shard balance, query routing overhead, and hardware homogeneity. These are projected estimates, not measured cluster benchmarks.
-
----
-
-## 🔗 See Also
-
-- [Architecture Overview](overview.md) — Overall system architecture
-
-- [Configuration Guide](../configuration/parameters.md) — Cluster parameters
-
-- [Performance Tuning](../operations/performance-tuning.md) — Optimizing distributed performance
\ No newline at end of file
diff --git a/docs/docs/architecture/gpu-acceleration.md b/docs/docs/architecture/gpu-acceleration.md
deleted file mode 100644
index 7c953c1..0000000
--- a/docs/docs/architecture/gpu-acceleration.md
+++ /dev/null
@@ -1,260 +0,0 @@
-# 🎮 GPU Acceleration
-
-> **Unlock massive parallel throughput with optional CUDA GPU acceleration.** Spector loads GPU kernels via Panama FFM (Foreign Function & Memory), maintaining the zero-JNI philosophy. GPU shines for batch workloads — single queries are already sub-millisecond on CPU SIMD.
-
----
-
-## 🎯 When to Use GPU
-
-```mermaid
-graph TD
-    Q["How many concurrent queries?"] --> Single["Single query<br/>Low concurrency"]
-    Q --> Batch["Batch queries<br/>High concurrency"]
-    
-    Single --> CPU["✅ CPU SIMD<br/>Best for HNSW traversal"]
-    Batch --> GPU["✅ GPU CUDA<br/>4× speedup at 100K+ vectors"]
-    
-    style CPU fill:#d4edda
-    style GPU fill:#d4edda
-```
-
-| Scenario | Recommendation |
-|----------|---------------|
-| ✅ Batch search (multiple queries at once) | GPU |
-| ✅ Large collections (>100K vectors) | GPU |
-| ✅ High concurrency (many simultaneous users) | GPU |
-| ✅ Brute-force similarity over IVF partitions | GPU |
-| ⚡ Single queries | CPU SIMD |
-| ⚡ Small datasets (<10K vectors) | CPU SIMD |
-| ⚡ Ultra-low latency (<0.1ms) | CPU SIMD |
-
----
-
-## 📋 Requirements
-
-### Hardware
-
-- NVIDIA GPU with Compute Capability ≥ 7.0 (Volta or newer)
-
-- Recommended: RTX 3060+ or A100/H100 for production workloads
-
-### Software
-
-| Component | Version | Notes |
-|-----------|---------|-------|
-| CUDA Toolkit | 12.x | Runtime libraries required |
-| NVIDIA Driver | 525+ | Must match CUDA version |
-| JDK | 25+ | With Panama FFM support |
-
-### 🐧 Installation (Linux)
-
-```bash
-# Install CUDA toolkit
-wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64/cuda-keyring_1.1-1_all.deb
-sudo dpkg -i cuda-keyring_1.1-1_all.deb
-sudo apt update
-sudo apt install cuda-toolkit-12-4
-
-# Verify
-nvidia-smi
-nvcc --version
-```
-
-### ✅ Verify Spector GPU Detection
-
-```bash
-curl http://localhost:7070/api/v1/status
-```
-```json
-{
-  "gpuAvailable": true,
-  "gpuInfo": "NVIDIA RTX 4090, 24GB, CUDA 12.4"
-}
-```
-
----
-
-## ⚙️ Configuration
-
-```java
-var config = SpectorConfig.DEFAULT
-    .withDimensions(384)
-    .withGpu(true)
-    .withGpuMemoryBudget(2048);  // 2 GB
-```
-
-| Parameter | Default | Range | Description |
-|-----------|---------|-------|-------------|
-| `gpuEnabled` | false | — | Enable CUDA acceleration |
-| `gpuMemoryBudget` | 256 MB | 256 MB – GPU max | Maximum device memory |
-| `gpuBatchWindow` | 10 ms | 1–100 ms | Batching window for query collection |
-| `gpuMaxBatchSize` | 1024 | 1–1024 | Max queries per kernel launch |
-
-> [!TIP]
-> Set `gpuMemoryBudget` to ~70% of available GPU memory to leave room for other processes.
-
----
-
-## 🔬 GPU Kernels
-
-### Dot Product Kernel
-
-Computes dot-product similarity between a query vector and a batch of document vectors.
-
-| Property | Value |
-|----------|-------|
-| Input | query (float32[D]) + database (float32[N × D]) |
-| Output | similarity scores (float32[N]) |
-| Dimensions | Multiples of 32, range 32–2048 |
-| Batch size | 1–1,000,000 vectors per invocation |
-| Tolerance | ≤1e-5 absolute error vs CPU SIMD |
-
-### Cosine Similarity Kernel
-
-Computes cosine similarity with cached norm computation.
-
-| Optimization | Benefit |
-|-------------|---------|
-| Pre-computes norms | Cached across queries |
-| Detects pre-normalized vectors | Skips norm computation |
-| Falls back to dot product | For normalized inputs |
-| Tolerance | ≤1e-6 vs CPU SIMD |
-
-### ⏱️ Batch GPU Search
-
-```mermaid
-sequenceDiagram
-    participant Q1 as Query A (t=0ms)
-    participant Q2 as Query B (t=3ms)
-    participant Q3 as Query C (t=7ms)
-    participant GPU as 🎮 GPU Kernel
-
-    Note over Q1,GPU: Batch window = 10ms
-    Q1->>GPU: Queued
-    Q2->>GPU: Queued
-    Q3->>GPU: Queued
-    Note over GPU: t=10ms: Window closes
-    GPU->>GPU: Single kernel for [A, B, C]
-    GPU-->>Q1: Top-K results for A
-    GPU-->>Q2: Top-K results for B
-    GPU-->>Q3: Top-K results for C
-```
-
-**Properties:**
-
-- Each query receives its own independent top-K results
-
-- Individual query errors don't fail the batch
-
-- Achieves ≥2× throughput vs sequential for batch sizes >4
-
-- Large batches are automatically partitioned to fit GPU memory
-
----
-
-## 💾 Memory Management
-
-The `GpuMemoryManager` handles device memory via Panama FFM:
-
-```java
-// Allocation tied to Arena lifecycle
-try (Arena arena = Arena.ofConfined()) {
-    MemorySegment deviceMem = gpuMemoryManager.allocateDevice(sizeBytes, arena);
-    // Use device memory...
-} // Automatically freed when arena closes
-```
-
-**Key behaviors:**
-
-- ✅ Allocations are Arena-scoped with explicit lifecycle
-
-- ✅ Pinned host memory for efficient host↔device transfers
-
-- ✅ Budget enforcement prevents over-allocation
-
-- ✅ Device memory released within 100ms of Arena close
-
-- ✅ Metrics available via monitoring API
-
----
-
-## 🔄 Fallback Behavior
-
-```mermaid
-graph TD
-    A["GPU Kernel Call"] --> B{"GPU available?"}
-    B -->|No| C["⚡ CPU SIMD kernel<br/>(same interface)"]
-    B -->|Yes| D{"Kernel execution OK?"}
-    D -->|Error| E["Release device memory"]
-    E --> C
-    D -->|Success| F["✅ Return GPU results"]
-```
-
-> [!NOTE]
-> **No code changes required.** The same method signature returns results regardless of whether GPU or CPU executed the computation. Fallback is automatic and transparent.
-
-**Fallback triggers:**
-
-- GPU not detected at startup
-
-- CUDA driver not installed
-
-- Insufficient GPU memory
-
-- CUDA kernel execution error
-
-- GPU memory budget exceeded
-
----
-
-## 📊 Performance Characteristics
-
-### Single Query (CPU wins)
-
-| Method | 100K vectors, 384-dim |
-|--------|----------------------|
-| ⚡ CPU SIMD (AVX2) | ~0.05 ms |
-| 🎮 GPU (kernel launch overhead) | ~0.5–1 ms |
-
-### Batch Queries (GPU shines)
-
-| Batch Size | CPU SIMD | GPU (resident) | GPU Speedup |
-|-----------|----------|----------------|-------------|
-| 10K | 0.35 ms | 0.21 ms | **1.7×** |
-| 100K | 9.13 ms | 2.24 ms | **4.1×** |
-| 500K | 45.75 ms | 11.31 ms | **4.0×** |
-| 1M | 90.77 ms | 22.09 ms | **4.1×** |
-
-> [!IMPORTANT]
-> GPU acceleration benchmarked on RTX 4060 Ti 16GB, 384-dim vectors, with database persistently resident in VRAM. The one-time upload cost is ~464ms for 1M vectors (1.5GB). Per-query cost only includes uploading the query vector (~1.5KB) and downloading results. GPU provides consistent 4× speedup for brute-force search at scale.
-
----
-
-## 🔧 Troubleshooting
-
-| Symptom | Cause | Solution |
-|---------|-------|----------|
-| `gpuAvailable: false` | CUDA not installed | Install CUDA toolkit, verify `nvidia-smi` |
-| Slow GPU queries | Small batch sizes | Increase `gpuBatchWindow` or disable GPU |
-| Out of GPU memory | Budget too low | Increase `gpuMemoryBudget` |
-| CPU fallback always used | Native access not enabled | Add `--enable-native-access=ALL-UNNAMED` |
-
-### JVM Arguments for GPU
-
-```bash
-java --add-modules jdk.incubator.vector \
-     --enable-native-access=ALL-UNNAMED \
-     -jar spector-node.jar
-```
-
----
-
-## 🔗 See Also
-
-- [Core Concepts](core-concepts.md) — SIMD kernels that GPU extends
-
-- [Performance Tuning](../operations/performance-tuning.md) — When to use GPU vs CPU
-
-- [Configuration Guide](../configuration/parameters.md) — GPU parameters
-
-- [Architecture Overview](overview.md) — Where GPU fits in the system
\ No newline at end of file
diff --git a/docs/docs/architecture/ingestion-pipeline.md b/docs/docs/architecture/ingestion-pipeline.md
deleted file mode 100644
index 034a8c5..0000000
--- a/docs/docs/architecture/ingestion-pipeline.md
+++ /dev/null
@@ -1,259 +0,0 @@
-# 📥 Ingestion Pipeline
-
-> **Unified ingestion: document → chunk → embed → target.** A single `IngestionPipeline` with builder configuration handles all ingestion — for both search engine and cognitive memory. The pipeline decides how to process content; the `IngestionTarget` decides where to store it.
-
----
-
-## Architecture
-
-All entry points (CLI, MCP, Server) route ingestion through `SpectorRuntime`:
-
-```
-CLI/MCP/Server → SpectorRuntime.ingestion() → IngestionHandler → IngestionPipeline
-                                                                        │
-                                                                  ┌─────┴─────┐
-                                                                  ▼           ▼
-                                                       EngineIngestionTarget  CognitiveIngestionTarget
-                                                       (SEARCH mode)          (MEMORY mode)
-```
-
-- **`IngestionPipeline`** (in `spector-ingestion`) — unified chunk → embed → store orchestrator with builder pattern
-- **`IngestionTarget`** (in `spector-ingestion`) — abstraction for storage backends (engine or memory)
-- **`IngestionHandler`** (in `spector-runtime`) — thin routing layer over the pipeline
-- **`FileDiscoveryService`** (in `spector-ingestion`) — pure file discovery + title extraction utility
-
-## Module: `spector-ingestion`
-
-The ingestion module is a **low-level utility** with no dependency on engine, runtime, or memory. It defines the pipeline and the `IngestionTarget` interface that downstream modules implement.
-
-**Key classes:**
-
-| Class | Purpose |
-|-------|---------|
-| `IngestionPipeline` | Builder-configured orchestrator — chunk → embed → store |
-| `IngestionTarget` | Interface for storage backends (`ingest(id, text, vector)`) |
-| `IngestionResult` | Outcome with chunk counts, failures, timing |
-| `FileDiscoveryService` | File discovery, title extraction, config-driven filtering |
-
----
-
-## 🔄 Pipeline Flow
-
-```mermaid
-flowchart LR
-    A["📄 Document"] --> B{"Content > threshold?"}
-    B -->|Yes| C["✂️ TextChunker<br/>Config-driven<br/>chunk size + overlap"]
-    B -->|No| D["Direct embed"]
-    C --> E["🧠 Parallel Embedding<br/>Virtual threads<br/>ParallelEmbeddingPipeline"]
-    D --> E
-    E --> F["💾 IngestionTarget<br/>Engine or Cognitive"]
-    F --> G["✅ IngestionResult"]
-```
-
----
-
-## 🏗️ Builder Pattern
-
-The pipeline is configured once via a builder, then reused for all ingestion in a session:
-
-```java
-// Read chunking config from spector.yml
-var ingestionConfig = SpectorConfigFactory.ingestionDefaults(props);
-
-var pipeline = IngestionPipeline.builder()
-    .target(engineTarget)                    // or cognitiveTarget
-    .embeddingProvider(embedder)             // for auto-embedding
-    .chunking(new TextChunker(
-        ingestionConfig.chunkSize(),
-        ingestionConfig.chunkOverlap()))
-    .chunkThreshold(ingestionConfig.chunkSize())
-    .build();
-```
-
-The pipeline automatically selects a strategy based on content:
-
-| Content | Strategy | Description |
-|---------|----------|-------------|
-| ≤ threshold | **Direct** | Embed whole text, store as single doc |
-| > threshold | **Chunked** | Split via `TextChunker`, embed in parallel, store each chunk |
-| Pre-embedded | **Passthrough** | Skip embedding, store vector directly |
-| File path | **Streaming** | `StreamingChunker` for bounded-memory processing |
-
----
-
-## 🎯 IngestionTarget Interface
-
-The pipeline is decoupled from storage — it writes to any `IngestionTarget`:
-
-```java
-public interface IngestionTarget {
-    void ingest(String id, String text, float[] vector);
-
-    default void storeParentMetadata(String parentId, int chunkCount) {}
-    default void onBatchComplete() {}
-}
-```
-
-### Implementations
-
-| Target | Module | What it does |
-|--------|--------|-------------|
-| `EngineIngestionTarget` | `spector-engine` | VectorStore → VectorIndex (HNSW/IVF/Spectrum) → KeywordIndex (BM25) |
-| `CognitiveIngestionTarget` | `spector-memory` | Synaptic tags → Surprise detection → ICNU fusion → Quantize → Tier route → WAL |
-
-This decoupling enables:
-
-- **Testing** — Mock the target for unit tests
-- **Rebuilding indexes** — Point at a fresh index during reindexing
-- **Multi-tenant setups** — Route documents to different targets
-- **Custom stores** — Write to external systems alongside Spector
-
-### Virtual Thread Parallelism
-
-Embedding calls (I/O-bound, network) run in parallel using the `ParallelEmbeddingPipeline`:
-
-```mermaid
-sequenceDiagram
-    participant Pipeline as 📥 IngestionPipeline
-    participant Chunker as ✂️ TextChunker
-    participant Embed as 🧠 ParallelEmbeddingPipeline
-    participant VT1 as Virtual Thread 1
-    participant VT2 as Virtual Thread 2
-    participant Target as 💾 IngestionTarget
-
-    Pipeline->>Chunker: chunk(document)
-    Chunker-->>Pipeline: List<Chunk>
-    Pipeline->>Embed: embed(chunkTexts)
-    par Batch 1
-        Embed->>VT1: embedBatch([c1,c2,c3,c4])
-    and Batch 2
-        Embed->>VT2: embedBatch([c5,c6,c7,c8])
-    end
-    VT1-->>Embed: vectors[0..3]
-    VT2-->>Embed: vectors[4..7]
-    Embed-->>Pipeline: List<PipelineEmbeddingResult>
-    loop For each successful embedding
-        Pipeline->>Target: ingest(chunkId, text, vector)
-    end
-    Pipeline-->>Pipeline: IngestionResult
-```
-
-> [!NOTE]
-> CPU-bound work (chunking, keyword tokenization, SIMD index insertion) runs synchronously on the caller's virtual thread. Only the embedding I/O call is parallelized. This avoids context-switch overhead on hot paths.
-
----
-
-## 📋 Ingestion Modes
-
-### Text Ingestion (auto-chunked)
-
-```java
-// Pipeline decides whether to chunk based on content length vs. threshold
-IngestionResult result = pipeline.ingest("doc-1", longDocumentText);
-```
-
-### Pre-embedded (skip embedding)
-
-```java
-// For pre-computed vectors — no chunking, no embedding
-IngestionResult result = pipeline.ingest("doc-1", "Hello world", precomputedVector);
-```
-
-### Streaming File Ingestion
-
-For multi-GB files that can't fit in memory:
-
-```java
-IngestionResult result = pipeline.ingest(
-    Path.of("corpus.txt"), "corpus");
-// Bounded memory: only ~2× chunkSize held at once via StreamingChunker
-```
-
----
-
-## 📊 Result Tracking
-
-Every ingestion operation returns an `IngestionResult`:
-
-```java
-public record IngestionResult(
-    String documentId,
-    int chunksStored,
-    List<String> failures,  // chunk IDs that failed
-    long durationMs
-) {}
-```
-
-**Properties:**
-
-- Failed chunks don't halt the pipeline — other chunks continue
-- Failure reasons are logged at WARN level
-- `isFullSuccess()` returns true only if all chunks succeeded
-- Timing includes chunking + embedding + storage
-
----
-
-## 🧠 Cognitive Target Pipeline
-
-When the `CognitiveIngestionTarget` receives a chunk from the unified pipeline, it executes the cognitive processing steps:
-
-```
-IngestionPipeline                        CognitiveIngestionTarget
-    │                                           │
-    │  ingest(id, text, vector)                 │
-    ├──────────────────────────────────────────► │
-    │                                           ├── 2. Encode synaptic tags (Bloom filter)
-    │                                           ├── 3. Compute surprise (Dopamine)
-    │                                           ├── 3b. ICNU fusion (if hints provided)
-    │                                           ├── 4. Flashbulb check (extreme surprise)
-    │                                           ├── 5. Quantize to INT8
-    │                                           ├── 6. Build cognitive header
-    │                                           ├── 7. Write to tier store
-    │                                           ├── 8. Register in MemoryIndex
-    │                                           └── 9. WAL append
-```
-
-`SpectorMemory.remember()` calls `CognitiveIngestionTarget.ingestCognitive()` directly with full cognitive parameters (type, tags, source, ICNU hints).
-
----
-
-## ⚡ Design Decisions
-
-### Why not Reactor?
-
-The pipeline uses virtual threads instead of Project Reactor because:
-
-| Concern | Virtual Threads | Reactor |
-|---------|----------------|---------|
-| Embedding I/O | Native async via VT | Requires `Mono.fromCallable` wrapping |
-| Error handling | try/catch, intuitive | `onErrorResume` chains |
-| Debugging | Normal stack traces | Operator assembly traces |
-| Testing | Standard JUnit | `StepVerifier` complexity |
-| Dependencies | Zero (JDK only) | reactor-core + reactor-netty |
-
-### Why a unified pipeline?
-
-Consolidating from 3 separate ingestion paths:
-
-1. **Single code path** — Same chunking + embedding logic for search and memory
-2. **Config-driven** — Chunk size, overlap, threshold all read from `spector.yml`
-3. **No OOM** — Streaming chunker ensures bounded memory for large files
-4. **Extensible** — New targets only need to implement `IngestionTarget.ingest()`
-
-### Why a separate module?
-
-Extracting ingestion from `SpectorEngine`:
-
-1. **Testability** — Pipeline can be unit-tested with a mock `IngestionTarget`
-2. **Reusability** — Bulk ingestion tools don't need the full engine
-3. **Clarity** — Ingestion logic is isolated from search/lifecycle concerns
-4. **Extensibility** — Custom pipelines can compose different chunkers/embedders
-
----
-
-## 🔗 See Also
-
-- [RAG Pipeline](rag-pipeline.md) — Retrieval and context assembly
-- [Architecture Overview](overview.md) — Module dependency graph
-- [REST API Reference](../api-reference/rest-endpoints.md) — Ingest endpoints
-- [Configuration Guide](../configuration/parameters.md) — Chunking and embedding parameters
diff --git a/docs/docs/architecture/mcp-integration.md b/docs/docs/architecture/mcp-integration.md
deleted file mode 100644
index 34f3459..0000000
--- a/docs/docs/architecture/mcp-integration.md
+++ /dev/null
@@ -1,304 +0,0 @@
-# 🤖 MCP Integration Architecture
-
-> **Spector's built-in Model Context Protocol (MCP) server gives any AI agent instant, in-process access to SIMD-accelerated vector search — with zero network overhead.**
-
----
-
-## Overview
-
-The [Model Context Protocol (MCP)](https://modelcontextprotocol.io/) is Anthropic's open standard for connecting AI agents to external data sources. Instead of writing custom Python glue-code with orchestration frameworks, agents connect directly to an MCP server via JSON-RPC and autonomously invoke tools.
-
-**Spector's MCP server runs in-process.** When Claude Desktop or Cursor calls `semantic_search`, the request goes from JSON-RPC → Java method call → SIMD kernel — never touching a network socket. This makes Spector **23–113× faster than Python-based MCP servers** that route through HTTP/gRPC.
-
----
-
-## Architecture
-
-```mermaid
-graph LR
-    subgraph "AI Agent (Claude, Cursor, etc.)"
-        Agent["🤖 AI Agent"]
-    end
-
-    subgraph "spector-mcp (in-process)"
-        Transport["📡 StdioTransport<br/><i>JSON-RPC 2.0</i>"]
-        Server["⚡ SpectorMcpServer<br/><i>Thin orchestrator</i>"]
-        
-        subgraph Providers
-            TR["🔧 SpectorToolRegistry"]
-            RP["📄 SpectorResourceProvider"]
-            PP["💬 SpectorPromptProvider"]
-        end
-
-        subgraph "Tools (McpToolHandler subclasses)"
-            T1["SemanticSearchTool"]
-            T2["HybridSearchTool"]
-            T3["RagQueryTool"]
-            T4["IngestDocumentTool"]
-            T5["DeleteDocumentTool"]
-            T6["EngineStatusTool"]
-        end
-
-        subgraph Foundation
-            SB["ToolSchemaBuilder"]
-            RF["ResultFormatter"]
-            TH["McpToolHandler<br/><i>Abstract base</i>"]
-        end
-    end
-
-    subgraph "spector-runtime"
-        Runtime["⚡ SpectorRuntime<br/><i>Composition Root</i>"]
-    end
-
-    subgraph "spector-engine"
-        Engine["🔧 SpectorEngine"]
-    end
-
-    subgraph "spector-core"
-        SIMD["🔬 SIMD Kernels<br/><i>AVX2/AVX-512/NEON</i>"]
-    end
-
-    Agent -- "stdin/stdout" --> Transport
-    Transport --> Server
-    Server --> TR & RP & PP
-    TR --> T1 & T2 & T3 & T4 & T5 & T6
-    T1 & T2 & T3 & T4 & T5 & T6 --> TH
-    T1 & T2 & T3 & T4 & T5 & T6 --> SB
-    T1 & T2 & T3 --> RF
-    T6 --> RF
-    T1 & T2 & T3 & T4 & T5 & T6 --> Runtime
-    Runtime --> Engine
-    Engine --> SIMD
-```
-
-### Data Flow
-
-```mermaid
-sequenceDiagram
-    participant Agent as 🤖 AI Agent
-    participant MCP as 📡 MCP Transport (stdio)
-    participant Handler as 🔧 McpToolHandler
-    participant Runtime as ⚡ SpectorRuntime
-    participant Engine as 🔧 SpectorEngine
-    participant SIMD as 🔬 SIMD Kernel
-
-    Agent->>MCP: tools/call {"name": "semantic_search", "arguments": {"query": "..."}}
-    MCP->>Handler: SemanticSearchTool.execute(runtime, args)
-    
-    Note over Handler: requireString(args, "query")<br/>optionalInt(args, "top_k", 5)
-    
-    Handler->>Runtime: runtime.search().query(query, topK)
-    Runtime->>Engine: engine.search(query, topK)
-    Engine->>SIMD: HNSW traversal (off-heap MemorySegment)
-    SIMD-->>Engine: ScoredResult[] (~100µs)
-    Engine-->>Runtime: SearchResponse
-    Runtime-->>Handler: SpectorResult[]
-    
-    Note over Handler: ResultFormatter.formatSearchResults()<br/>McpToolHandler.textResult()
-    
-    Handler-->>MCP: CallToolResult (text content)
-    MCP-->>Agent: {"content": [{"type": "text", "text": "Found 5 results..."}]}
-```
-
----
-
-## Module Structure
-
-```
-spector-mcp/src/main/java/com/spectrayan/spector/mcp/
-├── SpectorMcpServer.java          ← Thin orchestrator (assembly only)
-├── SpectorMcpMain.java            ← CLI entry point
-├── schema/
-│   └── ToolSchemaBuilder.java     ← Type-safe fluent builder for JSON schemas
-├── tools/
-│   ├── McpToolHandler.java        ← Abstract base with timing, error handling
-│   ├── SpectorToolRegistry.java   ← Tool discovery & registration
-│   ├── SemanticSearchTool.java    ← Individual tool implementations
-│   ├── HybridSearchTool.java
-│   ├── RagQueryTool.java
-│   ├── IngestDocumentTool.java
-│   ├── DeleteDocumentTool.java
-│   └── EngineStatusTool.java
-├── resources/
-│   └── SpectorResourceProvider.java   ← Resource definitions & handlers
-├── prompts/
-│   └── SpectorPromptProvider.java     ← Prompt templates & handlers
-└── util/
-    └── ResultFormatter.java           ← Search result formatting utilities
-```
-
----
-
-## Tool Reference
-
-### `semantic_search`
-
-Performs semantic similarity search using vector embeddings. Requires an embedding provider (e.g., Ollama) to be configured.
-
-| Parameter | Type | Required | Default | Description |
-|:---|:---|:---|:---|:---|
-| `query` | string | ✅ | — | Natural language search query |
-| `top_k` | integer | ❌ | 5 | Number of results to return (1–100) |
-
-### `hybrid_search`
-
-Combined keyword (BM25) + semantic (vector) search with reciprocal rank fusion. Falls back to keyword-only if no embedding provider is configured.
-
-| Parameter | Type | Required | Default | Description |
-|:---|:---|:---|:---|:---|
-| `query` | string | ✅ | — | Search query for both keyword and semantic matching |
-| `top_k` | integer | ❌ | 5 | Number of results to return |
-| `mode` | enum | ❌ | `hybrid` | Search mode: `hybrid`, `keyword`, or `vector` |
-
-### `rag_query`
-
-Retrieval-Augmented Generation — retrieves relevant context with source citations formatted for LLM consumption.
-
-| Parameter | Type | Required | Default | Description |
-|:---|:---|:---|:---|:---|
-| `query` | string | ✅ | — | The question or topic to retrieve context for |
-| `top_k` | integer | ❌ | 5 | Number of context passages to retrieve |
-
-### `ingest_document`
-
-Ingests a document into the search index with automatic embedding and optional chunking.
-
-| Parameter | Type | Required | Default | Description |
-|:---|:---|:---|:---|:---|
-| `id` | string | ✅ | — | Unique document identifier |
-| `content` | string | ✅ | — | Document text content |
-| `title` | string | ❌ | — | Optional document title |
-
-### `delete_document`
-
-Removes a document from the search index by ID.
-
-| Parameter | Type | Required | Default | Description |
-|:---|:---|:---|:---|:---|
-| `id` | string | ✅ | — | Document ID to delete |
-
-### `engine_status`
-
-Returns engine metadata including document count, dimensions, SIMD capabilities, embedding provider status, and GPU availability.
-
-| Parameter | Type | Required | Default | Description |
-|:---|:---|:---|:---|:---|
-| *(none)* | — | — | — | No input parameters required |
-
----
-
-## Extending the MCP Server
-
-### Adding a New Tool
-
-Every tool extends `McpToolHandler`, which handles timing, error handling, and argument parsing. You implement four methods:
-
-```java
-public abstract class McpToolHandler {
-    abstract String name();
-    abstract String description();
-    abstract Map<String, Object> inputSchema();
-    abstract CallToolResult execute(SpectorEngine engine, Map<String, Object> args);
-
-    // Base class automatically provides:
-    // - Timing wrapper (nanoTime → milliseconds)
-    // - Structured error handling with logging
-    // - Argument parsing: requireString(), optionalInt(), optionalString()
-    // - Result factories: textResult(), errorResult()
-}
-```
-
-Define the tool schema with `ToolSchemaBuilder`:
-
-```java
-var schema = ToolSchemaBuilder.object()
-    .requiredString("query", "Natural language search query.")
-    .optionalInt("top_k", "Number of results to return.", 5)
-    .optionalEnum("mode", "Search mode.", "hybrid", "hybrid", "keyword", "vector")
-    .build();
-```
-
-Register the tool in `SpectorToolRegistry.handlers()`:
-
-```java
-List.of(
-    new SemanticSearchTool(),
-    new HybridSearchTool(),
-    new RagQueryTool(),
-    new IngestDocumentTool(),
-    new DeleteDocumentTool(),
-    new EngineStatusTool(serverVersion)
-    // new YourNewTool()  ← just add here
-);
-```
-
----
-
-## Performance: Why In-Process Wins
-
-### The Python MCP Tax
-
-Python MCP servers introduce multiple layers of overhead:
-
-```mermaid
-graph LR
-    A1["🤖 Agent"] --> B1["JSON-RPC"]
-    B1 --> C1["🐍 Python process"]
-    C1 --> D1["Deserialize"]
-    D1 --> E1["HTTP/gRPC round-trip"]
-    E1 --> F1["Vector DB"]
-    F1 --> G1["Serialize response"]
-    G1 --> H1["JSON-RPC"]
-    H1 --> I1["🤖 Agent"]
-
-    style C1 fill:#e74c3c,color:white
-    style E1 fill:#e74c3c,color:white
-```
-
-> **Total: 2–10ms per query** (network + GIL + serialization)
-
-### Spector's Zero-Copy Path
-
-```mermaid
-graph LR
-    A2["🤖 Agent"] --> B2["JSON-RPC"]
-    B2 --> C2["☕ Virtual Thread"]
-    C2 --> D2["SpectorEngine.search()"]
-    D2 --> E2["Off-heap MemorySegment"]
-    E2 --> F2["SIMD registers"]
-    F2 --> G2["✅ Results"]
-
-    style C2 fill:#00b894,color:white
-    style E2 fill:#00b894,color:white
-    style G2 fill:#00b894,color:white
-```
-
-> **Total: 88µs p50 per query** (23–113× faster)
-
-| Bottleneck | Python MCP | Spector MCP |
-|:---|:---|:---|
-| Network round-trip | 500–2,000µs | **0µs** (in-process) |
-| JSON serialization | 100–500µs | **0µs** (direct Java objects) |
-| Python GIL contention | Blocks concurrent queries | **0µs** (Virtual Threads) |
-| GC pressure | Heap allocation per query | **0µs** (off-heap Panama) |
-| Search computation | ~100µs (native C++) | **~100µs** (Panama SIMD) |
-| **Total** | **2,000–10,000µs** | **88µs p50** |
-
----
-
-## Security Considerations
-
-> [!WARNING]
-> The `ingest_document` and `delete_document` tools allow agents to modify the search index. In production environments, consider:
-> - Running the MCP server in read-only mode (expose only search tools)
-> - Implementing document-level access control
-> - Rate limiting ingestion operations
-> - Auditing all write operations
-
----
-
-## See Also
-
-- [MCP Server Usage Guide](../sdk-usage/mcp-server.md) — Practical setup for Claude Desktop, Cursor, and custom agents
-- [Architecture Overview](overview.md) — Full system architecture
-- [Core Concepts](core-concepts.md) — HNSW, BM25, RRF deep-dives
diff --git a/docs/docs/architecture/overview.md b/docs/docs/architecture/overview.md
index c3261a9..d0f0e0f 100644
--- a/docs/docs/architecture/overview.md
+++ b/docs/docs/architecture/overview.md
@@ -1,381 +1,92 @@
-# 🏗️ Architecture Overview
+# Architecture
 
-> **Spector is a modular, JVM-native AI memory backbone organized as a Maven multi-module project.** This page covers the module structure, dependency graph, data flow, threading model, and memory architecture that make sub-millisecond, agent-native search possible.
+## System Overview
 
----
+Spector Search is a multi-module Maven project built on four foundational Java technologies:
 
-## 📦 Module Diagram
+- **Java Vector API** (jdk.incubator.vector) — SIMD-accelerated similarity kernels
+- **Panama FFM** — Zero-copy memory-mapped storage and GPU interop
+- **Virtual Threads** (Project Loom) — Massive concurrency without thread pool tuning
+- **Memory-mapped indexes** — Instant startup, zero GC pressure
 
-```mermaid
-graph LR
-    subgraph "🔬 Core Layer"
-        core["spector-core<br/><i>SIMD kernels</i>"]
-        commons["spector-commons<br/><i>Config, chunkers, tokenizer</i>"]
-    end
+## Module Structure
 
-    subgraph "💾 Storage Layer"
-        storage["spector-storage<br/><i>Panama MemorySegment stores</i>"]
-    end
-
-    subgraph "📊 Index Layer"
-        index["spector-index<br/><i>HNSW + IVF-PQ + BM25</i>"]
-    end
-
-    subgraph "🔍 Query Layer"
-        query["spector-query<br/><i>Hybrid orchestrator + RRF</i>"]
-    end
-
-    subgraph "🧠 Intelligence"
-        embedapi["spector-embed-api<br/><i>EmbeddingProvider SPI</i>"]
-        embedollama["spector-embed-ollama<br/><i>Ollama provider</i>"]
-        gpu["spector-gpu<br/><i>Panama FFM + CUDA</i>"]
-    end
-
-    subgraph "📥 Pipelines"
-        ingestion["spector-ingestion<br/><i>Ingest orchestration</i>"]
-        rag["spector-rag<br/><i>RAG pipeline</i>"]
-    end
-
-    subgraph "⚡ Runtime & Interfaces"
-        runtime["spector-runtime<br/><i>Unified context (engine + memory)</i>"]
-        engine["spector-engine<br/><i>Search facade + lifecycle</i>"]
-        node["spector-node<br/><i>Armeria: REST + gRPC + SSE + cluster</i>"]
-        mcp["spector-mcp<br/><i>MCP Server — Agent-native</i>"]
-        cli["spector-cli<br/><i>spectorctl CLI</i>"]
-        client["spector-client<br/><i>Java client SDK</i>"]
-        spring["spector-spring<br/><i>Spring AI VectorStore</i>"]
-    end
-
-    subgraph "🧠 Cognitive Memory"
-        memory["spector-memory<br/><i>Biologically-inspired agent memory</i>"]
-    end
-
-    subgraph "📈 Distribution"
-        bench["spector-bench<br/><i>JMH benchmarks</i>"]
-        dist["spector-dist<br/><i>Single fat JAR</i>"]
-    end
-```
-
-> [!NOTE]
-> **Index sub-modules:** `hnsw/` (graph-based ANN), `ivf/` (inverted file + posting lists), `pq/` (product quantizer, K-Means++, ADC), `bm25/` (keyword scoring + analyzers)
-
----
-
-## 🔗 Dependency Graph
-
-```mermaid
-graph TD
-    node["🌐 node"] --> runtime["⚡ runtime"]
-    node --> mcp["🤖 mcp"]
-    node --> metrics["📈 metrics"]
-    mcp --> runtime
-    mcp --> ingestion["📥 ingestion"]
-    cli["🖥️ cli"] --> runtime
-    cli --> client["📦 client"]
-
-    runtime --> engine["⚡ engine"]
-    runtime --> memory["🧠 memory"]
-    runtime --> ingestion
-
-    engine --> query["🔍 query"]
-    engine --> rag["🤖 rag"]
-    engine --> ingestion
-    engine --> index["📊 index"]
-    engine --> storage["💾 storage"]
-    engine --> embedapi["🧬 embed-api"]
-    engine -.-> gpu["🎮 gpu"]
-
-    memory --> index
-    memory --> storage
-    memory --> ingestion
-    memory --> embedapi
-    memory --> core["🔬 core"]
-
-    metrics --> engine
-    metrics --> memory
-
-    ingestion --> config["⚙️ config"]
-    ingestion --> embedapi
-
-    rag --> query
-    rag --> index
-    rag --> storage
-    rag --> embedapi
-    rag --> commons["📄 commons"]
-
-    query --> index
-    query --> commons
-    index --> storage
-    index --> config
-    storage --> config
-    storage --> core
-    config --> core
-
-    embedapi --> commons
-    gpu --> core
-    gpu --> storage
-
-    dist["📦 dist"] --> mcp
-    dist --> cli
-    dist --> runtime
-
-    spring["🌱 spring"] --> engine
-    spring --> memory
-    spring --> metrics
-    bench["🧪 bench"] --> engine
-    bench --> memory
 ```
-
-> **Legend:** Solid arrows = compile dependency. Dotted arrow (`gpu`) = optional dependency.
-
-**Dependency rules:**
-
-| Path | Description |
-|------|-------------|
-| `runtime → engine + memory + ingestion` | Composition root — wires all subsystems |
-| `cli → runtime + client` | CLI with local batch (runtime) and remote (client) modes |
-| `node → runtime` | Unified Armeria node: REST + gRPC + cluster coordination |
-| `mcp → runtime + ingestion` | MCP agent entry point (in-process, zero network) |
-| `engine → ingestion` | `EngineIngestionTarget` implements `IngestionTarget` |
-| `memory → ingestion` | `CognitiveIngestionTarget` implements `IngestionTarget` |
-| `engine → rag` | RAG context assembly pipeline |
-| `engine -.-> gpu` | Optional GPU acceleration |
-| `memory → index, storage, core, embed-api` | Cognitive memory (independent of engine) |
-| `dist → mcp + cli + runtime` | Fat JAR distribution |
-
-!!! important
-    **No circular dependencies.** `spector-memory` and `spector-engine` are **peers** — both depend on `spector-ingestion` for the `IngestionTarget` interface, but neither depends on the other. `SpectorRuntime` is the single composition root that wires them together.
-
----
-
-## 📥 Data Flow: Ingest Path
-
-```mermaid
-sequenceDiagram
-    participant Client as 👤 Client (CLI/MCP/REST)
-    participant Runtime as ⚡ SpectorRuntime
-    participant Handler as 📥 IngestionHandler
-    participant Pipeline as 🔄 IngestionPipeline
-    participant Embed as 🧠 ParallelEmbeddingPipeline
-    participant Target as 💾 IngestionTarget
-    participant Store as 💾 Storage (mmap)
-
-    Client->>Runtime: runtime.ingestion().ingest(dir, pattern)
-    Runtime->>Handler: Pre-configured pipeline + target
-    Handler->>Handler: FileDiscoveryService.discover()
-    loop Each file
-        Handler->>Pipeline: pipeline.ingest(id, content)
-        Pipeline->>Pipeline: TextChunker.chunk(content)
-        Pipeline->>Embed: embed(chunkTexts) via virtual threads
-        Embed-->>Pipeline: List<vector>
-        loop Each chunk
-            Pipeline->>Target: target.ingest(id, text, vector)
-            Target->>Store: VectorStore + VectorIndex + KeywordIndex
-        end
-    end
-    Store-->>Client: ✅ Indexed
+spector-search/
+├── spector-core/         # SIMD kernels (DotProduct, Cosine, Euclidean)
+├── spector-commons/      # Text chunkers, tokenizer, document readers
+├── spector-storage/      # Panama MemorySegment stores (InMemory + Mmap)
+├── spector-index/        # HNSW + IVF-PQ + BM25 indexes
+│   ├── hnsw/             # HNSW graph ANN (standard + quantized INT8/INT4/INT2)
+│   ├── ivf/              # IVF inverted file index + quantized IVF-PQ
+│   ├── pq/               # Product quantizer (K-Means++, ADC)
+│   ├── text/             # BM25 keyword scoring + analyzers
+│   └── fuzz/             # Index fuzz testing framework
+├── spector-query/        # Hybrid orchestrator + RRF fusion + reranking
+├── spector-embed-api/    # EmbeddingProvider SPI
+├── spector-embed-ollama/ # Ollama embedding provider
+├── spector-gpu/          # GPU acceleration (CUDA via Panama FFM)
+├── spector-engine/       # Unified engine facade + lifecycle
+├── spector-server/       # REST API (Javalin + virtual threads)
+├── spector-cluster/      # Distributed gRPC search
+├── spector-client/       # Java client SDK
+├── spector-cli/          # spectorctl CLI tool
+└── spector-bench/        # JMH benchmarks
 ```
 
-1. **Client** calls `runtime.ingestion().ingest()` — all entry points use this
-2. **IngestionHandler** delegates to a pre-configured `IngestionPipeline`
-3. **IngestionPipeline** handles chunking (from config) and parallel embedding
-4. **IngestionTarget** receives pre-embedded chunks — `EngineIngestionTarget` for SEARCH, `CognitiveIngestionTarget` for MEMORY
-5. Each target handles its own downstream storage (VectorStore/HNSW or Quantize/TierRoute/WAL)
+## Dependency Flow
 
-> [!TIP]
-> `FileDiscoveryService` can be used independently for file discovery without any engine or runtime dependency.
-
----
-
-## 🔍 Data Flow: Search Path
-
-```mermaid
-sequenceDiagram
-    participant Client as 👤 Client
-    participant Engine as ⚡ SpectorEngine
-    participant QB as 🧭 Query Builder
-    participant BM25 as 📝 BM25 Search
-    participant HNSW as 🧠 HNSW Search
-    participant RRF as 🧬 RRF Fusion
-    participant LLM as 🤖 LLM Reranker
-
-    Client->>Engine: Search (text + vector + topK)
-    Engine->>QB: Auto-detect mode
-    Note over QB: text only → KEYWORD<br/>vector only → VECTOR<br/>both → HYBRID
-    par Parallel search on virtual threads
-        QB->>BM25: Keyword search
-        QB->>HNSW: Vector search
-    end
-    BM25->>RRF: Ranked results
-    HNSW->>RRF: Ranked results
-    RRF->>LLM: Fused top candidates
-    LLM-->>Client: ✨ Final ranked results
 ```
-
-1. **Query Builder** determines search mode from provided fields
-2. **BM25** and **HNSW** searches run in parallel on virtual threads
-3. **RRF Fusion** merges both ranked lists using `1/(k + rank)` scoring
-4. Optional **LLM Reranker** rescores top candidates via Ollama
-
----
-
-## 🤖 Data Flow: MCP Agent Path
-
-```mermaid
-sequenceDiagram
-    participant Agent as 🤖 AI Agent (Claude/Cursor)
-    participant MCP as 📡 MCP Transport (stdio)
-    participant Handler as 🔧 McpToolHandler
-    participant Runtime as ⚡ SpectorRuntime
-    participant Engine as 🔧 SpectorEngine
-    participant SIMD as 🔬 SIMD Kernels
-
-    Agent->>MCP: tools/call {"name": "semantic_search", "arguments": {"query": "..."}}
-    MCP->>Handler: SemanticSearchTool.execute(runtime, args)
-    Handler->>Runtime: runtime.search().query(text, topK)
-    Runtime->>Engine: engine.search(query, topK)
-    Engine->>SIMD: HNSW traversal (off-heap MemorySegment)
-    SIMD-->>Engine: ScoredResult[] (~100µs)
-    Engine-->>Runtime: SearchResponse
-    Runtime-->>Handler: SpectorResult[]
-    Handler-->>MCP: CallToolResult
-    MCP-->>Agent: JSON-RPC response with search results
+server → engine → query → index → core
+                       → index → storage → core
+cluster → engine
+client  → (HTTP) → server
+cli     → (HTTP) → server
+gpu     → core, storage
+engine  → commons, embed-api
 ```
 
-The MCP path routes through `SpectorRuntime` — the single composition root that holds both the search engine and optional cognitive memory. The MCP server wraps runtime handler calls with JSON-RPC transport. There is **zero network overhead** because everything runs in the same JVM process.
-
-> [!TIP]
-> For full MCP architecture details, tool schemas, and design patterns, see the dedicated [MCP Integration](mcp-integration.md) page.
-
----
-
-## 🧵 Threading Model: Virtual Threads
-
-Spector is designed from the ground up for Java virtual threads:
-
-> [!TIP]
-> **No `synchronized` blocks** anywhere in the codebase. All coordination uses `ReentrantLock` to avoid virtual thread pinning.
-
-| Operation | Threading Strategy |
-|-----------|-------------------|
-| REST request handling | One virtual thread per request |
-| Hybrid search | Parallel BM25 + HNSW via `StructuredTaskScope` |
-| Bulk ingest | Virtual thread per document |
-| Embedding generation | Batched across virtual threads |
-| HNSW construction (>10K) | Virtual threads per core for parallel insertion |
-| Distributed fan-out | Virtual thread per shard query |
-
-### 📈 Scaling Results
-
-At 50K docs with hybrid search (384-dim, production-realistic):
-
-| Virtual Threads | Throughput | Scaling |
-|-----------------|-----------|---------|
-| 1 | 3,739 ops/s | 1.0× |
-| 4 | 10,317 ops/s | **2.8×** |
-| 8 | 11,812 ops/s | **3.2×** |
-| 16 | 14,022 ops/s | **3.7×** |
-
-> [!NOTE]
-> Scaling depends on vector dimensions and workload type. 384-dim shows ~3.7× at 16 threads due to higher per-query memory bandwidth. Individual HNSW queries are inherently sequential (graph traversal data dependencies) — scaling comes from concurrent queries sharing CPU cores.
-
----
-
-## 💾 Memory Model: Panama Off-Heap
-
-All vector data lives off-heap using the Panama Foreign Function & Memory API:
-
-```mermaid
-graph TB
-    subgraph "☕ JVM Heap (minimal)"
-        HG["HNSW Graph<br/>(adjacency lists)"]
-        BM["BM25 Index<br/>(inverted index)"]
-        ES["Engine State<br/>(config, lifecycle)"]
-    end
-
-    subgraph "🧊 Off-Heap (Panama MemorySegment)"
-        VS["Vector Store<br/>Contiguous float32, SIMD-aligned<br/>Zero-copy reads, no GC pressure"]
-        QS["Quantized Store<br/>INT8 or PQ codes"]
-        GM["GPU Device Memory<br/>CUDA via FFM"]
-    end
-
-    HG -.-> VS
-    BM -.-> VS
-    ES -.-> QS
-    ES -.-> GM
-```
-
-**Benefits:**
-
-- ✅ **Zero GC pressure** — Vectors never touch the garbage collector
-
-- ✅ **Instant startup** — Memory-mapped files load via `mmap` syscall, no deserialization
-
-- ✅ **SIMD-friendly layout** — Contiguous float32 arrays ready for Vector API operations
-
-- ✅ **Explicit lifecycle** — `Arena`-scoped memory with deterministic cleanup
-
-- ✅ **Memory efficiency** — Store billions of vectors limited only by disk/address space
-
-### 📊 Storage Types
-
-| Store | Location | Use Case |
-|-------|----------|----------|
-| `InMemoryVectorStore` | Off-heap (Arena) | Development, small datasets |
-| `MmapVectorStore` | Memory-mapped file | Production, persistence |
-| `QuantizedVectorStore` | Off-heap (INT8) | Memory-constrained deployments |
-| `IvfPqStore` | Off-heap (PQ codes) | Billion-scale (32× compression) |
-
----
-
-## 🌐 API Layer
-
-```mermaid
-graph TD
-    subgraph "SpectorNode - Armeria Server, single port"
-        CORS["CorsService decorator"]
-        Auth["API Key decorator"]
-        COMPRESS["EncodingService - gzip/brotli"]
-        subgraph "ApiModule Registration"
-            SE["🔍 SearchEndpoint"]
-            IE["📥 IngestEndpoint"]
-            RE["🤖 RagEndpoint"]
-            DE["🗑️ DocumentEndpoint"]
-            STE["📊 StatusEndpoint"]
-            ESE["📡 EventStreamEndpoint"]
-        end
-        gRPC["gRPC Service<br/>inter-node fan-out"]
-        HEALTH["💚 /health"]
-        PROM["📊 /metrics"]
-    end
-
-    subgraph "Service Facades"
-        SS["SearchService"]
-        IS["IngestService"]
-        RS["RagService"]
-    end
-
-    SE --> SS
-    IE --> IS
-    RE --> RS
-    SS & IS --> EB["SpectorEventBus<br/>17 event types"]
-    SS --> ENGINE["⚡ SpectorEngine"]
-```
-
-Every request runs on its own virtual thread. The Armeria server handles HTTP REST, gRPC, and SSE events on a single port. API endpoints are registered via the `ApiModule` factory pattern, enabling straightforward API versioning (`/api/v1`, `/api/v2`).
-
-### Streaming via SSE
-
-The `/api/v1/search/stream` endpoint uses Server-Sent Events to emit results progressively. The `/api/v1/events` endpoint provides a live event stream where clients can subscribe to search, ingest, cluster, MCP, and engine events with optional category filtering.
-
----
-
-## 🔗 See Also
-
-- [Core Concepts](core-concepts.md) — Algorithms and data structures in detail
-
-- [Distributed Mode](distributed-mode.md) — Multi-node clustering architecture
-
-- [GPU Acceleration](gpu-acceleration.md) — CUDA kernel integration via Panama
-
-- [Performance Tuning](../operations/performance-tuning.md) — Optimizing for your workload
\ No newline at end of file
+## Data Flow
+
+### Ingestion Path
+
+1. REST request arrives at `spector-server`
+2. `SpectorEngine` routes to appropriate handler
+3. Vector stored in off-heap `VectorStore` (Panama MemorySegment)
+4. HNSW graph updated with new node connections
+5. BM25 inverted index updated with text tokens
+6. Document metadata stored for retrieval
+
+### Search Path
+
+1. Query arrives at `spector-server`
+2. `SpectorEngine` delegates to `QueryOrchestrator`
+3. Parallel execution:
+    - **Vector leg**: HNSW traversal with SIMD distance computation
+    - **Keyword leg**: BM25 scoring across inverted index
+4. Results fused via Reciprocal Rank Fusion (RRF)
+5. Optional: LLM re-ranking via Ollama
+6. Top-K results returned with scores
+
+### RAG Path
+
+1. Documents read by `DocumentReader` (PDF, HTML, Markdown)
+2. Text split by `TokenAwareChunker` respecting sentence boundaries
+3. Chunks embedded in parallel via `EmbeddingPipeline`
+4. On query: relevant chunks retrieved and scored
+5. `ContextBuilder` assembles context within token limit
+6. Context returned with source attributions
+
+## Key Design Decisions
+
+| Decision | Rationale |
+|----------|-----------|
+| Off-heap vectors (Panama) | Avoids GC pressure, enables mmap for instant load |
+| Virtual threads | Scales to thousands of concurrent queries without pool tuning |
+| SIMD via Vector API | 10-100× faster distance computation than scalar Java |
+| HNSW for ANN | Proven recall/latency tradeoff, logarithmic search time |
+| IVF-PQ for scale | 32× memory compression enables billion-scale on commodity hardware |
+| Multi-level quantization | INT8/INT4/INT2 with non-uniform calibration covers 4×–16× compression |
+| Configurable rescore | Oversampling-based rescore recovers recall lost to quantization |
+| Consistent hashing | Minimal data movement on cluster topology changes |
+| gRPC for cluster | Low-latency binary protocol for shard fan-out |
diff --git a/docs/docs/architecture/rag-pipeline.md b/docs/docs/architecture/rag-pipeline.md
deleted file mode 100644
index 6abb068..0000000
--- a/docs/docs/architecture/rag-pipeline.md
+++ /dev/null
@@ -1,305 +0,0 @@
-# 🤖 RAG Pipeline
-
-> **End-to-end Retrieval-Augmented Generation built right into Spector.** From document ingestion to LLM-ready context assembly — with token-aware chunking, parallel embedding, and source attribution out of the box.
-
----
-
-## Module: `spector-rag`
-
-The RAG pipeline is a standalone module (`spector-rag`) that can be used independently or through the engine facade. It orchestrates the full flow: query embedding → retrieval → context assembly → attribution.
-
-**Key classes:**
-
-| Class | Purpose |
-|-------|---------|
-| `RagPipeline` | End-to-end orchestrator |
-| `ContextBuilder` | Token-budget-aware context assembly |
-| `RagRequest` / `RagResponse` | Clean input/output types |
-| `ScoredChunk` | Chunk + relevance score |
-| `ChunkAttribution` | Source provenance tracking |
-
-```java
-// Standalone usage (no engine facade required)
-var pipeline = new RagPipeline(searchOrchestrator, documentStore, embeddingProvider);
-RagResponse response = pipeline.execute(new RagRequest("What is HNSW?"));
-// response.contextText() → assembled context for LLM
-// response.attributions() → source document references
-```
-
-> [!NOTE]
-> The `spector-rag` module uses virtual threads for the embedding call and synchronous search for retrieval. No reactive framework needed — the JDK handles async I/O natively.
-
----
-
-## 🔄 Pipeline Overview
-
-```mermaid
-flowchart LR
-    A["📄 Document Readers<br/>PDF / HTML / Markdown"] --> B["✂️ Token-Aware Chunker<br/>Sentence boundaries<br/>Configurable overlap"]
-    B --> C["🧠 Parallel Embedding<br/>Batched via virtual threads<br/>Pluggable providers"]
-    C --> D["📊 Index & Store<br/>HNSW + BM25 + mmap"]
-    D --> E["🔍 Search & Retrieve<br/>Vector / Hybrid"]
-    E --> F["📝 Context Builder<br/>Score-ranked assembly<br/>Token limit enforcement"]
-    F --> G["✨ LLM-Ready Context<br/>+ Source Attributions"]
-```
-
----
-
-## 📄 Document Readers
-
-The pipeline supports three document formats out of the box:
-
-| Reader | Format | Behavior |
-|--------|--------|----------|
-| `PdfDocumentReader` | PDF | Extracts text, preserves paragraph boundaries |
-| `HtmlDocumentReader` | HTML | Strips tags, converts headings to sections |
-| `MarkdownDocumentReader` | Markdown | Preserves heading structure as delimiters |
-
-```java
-DocumentReader reader = new PdfDocumentReader();
-DocumentResult result = reader.read(Path.of("whitepaper.pdf"));
-// result.text() → extracted text
-// result.metadata() → {sourceFile, format: "PDF", characterCount}
-```
-
-| Property | Value |
-|----------|-------|
-| Max file size | 100 MB |
-| Max extraction time | 30 seconds per file |
-| Failure isolation | Per-file (one failure doesn't halt pipeline) |
-| Output | Text string + metadata |
-
-> [!NOTE]
-> Unsupported formats return a descriptive error. Corrupted files report the failure without stopping the pipeline.
-
----
-
-## ✂️ Token-Aware Chunking
-
-The `TokenAwareChunker` splits text into chunks that respect token boundaries and embedding model limits.
-
-```mermaid
-flowchart TD
-    Input["📄 Input Text<br/>(long document)"] --> Split["Split Strategy"]
-    Split --> S1["1️⃣ Prefer sentence boundaries"]
-    Split --> S2["2️⃣ Fall back to word boundaries"]
-    Split --> S3["3️⃣ Measure by token count"]
-    
-    S1 --> Chunks["✂️ Overlapping Chunks<br/>Each ≤ maxTokens"]
-    S2 --> Chunks
-    S3 --> Chunks
-```
-
-### Configuration
-
-| Parameter | Default | Range | Description |
-|-----------|---------|-------|-------------|
-| `maxTokens` | 512 | 1–8192 | Max tokens per chunk |
-| `overlapTokens` | 50 | 0–maxTokens-1 | Overlap between chunks |
-
-```java
-ChunkConfig config = new ChunkConfig(512, 50);
-List<TextChunk> chunks = chunker.chunk(extractedText, config);
-```
-
-### Properties
-
-- ✅ **Round-trip reconstruction** — Concatenating chunks reconstructs the original text
-
-- ✅ **Token limit guarantee** — Every chunk has ≤ maxTokens
-
-- ✅ **Single chunk for short text** — Returns exactly one chunk if input fits
-
-- ✅ Empty/whitespace input returns an empty list
-
-> [!TIP]
-> Set `maxTokens` to match your embedding model's max input length. Increase `overlapTokens` (100–200) if chunks need more surrounding context for coherence.
-
----
-
-## 🧠 Parallel Embedding Pipeline
-
-The `ParallelEmbeddingPipeline` generates vector embeddings from text chunks using configurable batch parallelism.
-
-```mermaid
-flowchart LR
-    subgraph "Input Chunks"
-        C1[C1] & C2[C2] & C3[C3] & C4[C4] & C5[C5] & C6[C6] & C7[C7] & C8[C8]
-    end
-
-    subgraph "Virtual Thread 1"
-        B1["Batch [C1-C4]<br/>→ Embedding Provider"]
-    end
-
-    subgraph "Virtual Thread 2"
-        B2["Batch [C5-C8]<br/>→ Embedding Provider"]
-    end
-
-    C1 & C2 & C3 & C4 --> B1
-    C5 & C6 & C7 & C8 --> B2
-    
-    B1 --> Out["Embeddings [E1...E8]<br/>Order preserved ✅"]
-    B2 --> Out
-```
-
-| Parameter | Default | Range | Description |
-|-----------|---------|-------|-------------|
-| `batchSize` | 32 | 1–256 | Chunks per embedding API call |
-| `maxRetries` | 3 | 0–10 | Retries for failed batches |
-
-**Failure handling:**
-
-- Failed batches are retried up to `maxRetries` times
-
-- Processing continues for remaining batches even if one fails
-
-- Input-output ordering is always preserved
-
----
-
-## 📝 Context Builder
-
-The `ContextBuilder` assembles retrieved chunks into a coherent context window for LLM prompting.
-
-```mermaid
-flowchart TD
-    A["🔍 Retrieved Chunks<br/>(scored)"] --> B["Sort by relevance ↓"]
-    B --> C{"Would adding next chunk<br/>exceed token limit?"}
-    C -->|No| D["Add chunk to context"]
-    D --> C
-    C -->|Yes| E["Skip chunk"]
-    E --> F["📝 Final Context<br/>+ Source Attributions"]
-    D --> F
-```
-
-| Parameter | Default | Range |
-|-----------|---------|-------|
-| `tokenLimit` | 4096 | 256–131,072 |
-
-**Properties:**
-
-- Context never exceeds the configured token limit
-
-- Chunks appear in descending relevance order
-
-- Every included chunk has a source attribution
-
-- Empty context (not an exception) when no chunks fit
-
----
-
-## 🌐 The `/api/v1/rag` Endpoint
-
-A single API call for retrieval-augmented generation:
-
-```bash
-curl -X POST http://localhost:7070/api/v1/rag \
-  -H "Content-Type: application/json" \
-  -d '{
-    "query": "How does HNSW indexing work?",
-    "topK": 5,
-    "tokenLimit": 4096,
-    "searchMode": "hybrid"
-  }'
-```
-
-**Request Parameters:**
-
-| Field | Type | Default | Range | Description |
-|-------|------|---------|-------|-------------|
-| `query` | string | — | 1–2000 chars | The question/query |
-| `topK` | int | 5 | 1–100 | Chunks to retrieve |
-| `tokenLimit` | int | 4096 | 1–8192 | Max context tokens |
-| `searchMode` | string | "vector" | "vector", "hybrid" | Search strategy |
-
-**Response:**
-```json
-{
-  "context": "HNSW builds a multi-layer graph structure where each layer contains a subset of nodes...",
-  "attributions": [
-    {"documentId": "architecture.md", "chunkOffset": 3},
-    {"documentId": "algorithms.md", "chunkOffset": 0}
-  ],
-  "isEmpty": false
-}
-```
-
----
-
-## 🎯 End-to-End Example
-
-### 1️⃣ Ingest Documents via Ingestion Pipeline
-
-```java
-// Create pipeline with embedding provider
-var pipeline = new IngestionPipeline(target, embeddingProvider);
-
-// Single document (auto-embed)
-pipeline.ingest("doc-1", "HNSW builds a multi-layer graph structure...");
-
-// Large document (chunked, parallel embedding)
-String whitepaper = Files.readString(Path.of("architecture.pdf.txt"));
-IngestionResult result = pipeline.ingestChunked("whitepaper-1", whitepaper);
-// result: 47 chunks stored, 0 failures, 2340ms
-```
-
-### 2️⃣ Query via RAG Pipeline
-
-```java
-// Direct usage of RagPipeline (standalone module)
-var ragPipeline = new RagPipeline(searchOrchestrator, documentStore, embeddingProvider);
-
-RagResponse response = ragPipeline.execute(
-    new RagRequest("What is product quantization?", 5, 4096, "hybrid"));
-
-System.out.println(response.contextText());     // assembled context
-System.out.println(response.attributions());    // source references
-System.out.println(response.queryTimeMs());     // 12ms
-```
-
-### 3️⃣ Query via REST API
-
-```bash
-curl -X POST http://localhost:7070/api/v1/rag \
-  -d '{"query": "What is product quantization?", "topK": 3}'
-```
-
-### 4️⃣ Use Context with an LLM
-
-```python
-import requests
-
-# Get context from Spector
-rag_response = requests.post("http://localhost:7070/api/v1/rag", json={
-    "query": "Explain product quantization",
-    "topK": 5,
-    "tokenLimit": 3000
-}).json()
-
-# Use with your LLM
-prompt = f"""Based on the following context, answer the question.
-
-Context:
-{rag_response['context']}
-
-Question: Explain product quantization
-
-Answer:"""
-```
-
-> [!TIP]
-> For Spring AI applications, use the `SpectorRagService` or `QuestionAnswerAdvisor` for automatic context retrieval. See [Spring AI Integration](../sdk-usage/spring-ai.md).
-
----
-
-## 🔗 See Also
-
-- [Ingestion Pipeline](ingestion-pipeline.md) — Document ingestion module
-
-- [Spring AI Integration](../sdk-usage/spring-ai.md) — Spring AI RAG service
-
-- [REST API Reference](../api-reference/rest-endpoints.md) — RAG endpoint details
-
-- [Core Concepts](core-concepts.md) — Algorithms used in retrieval
-
-- [Configuration Guide](../configuration/parameters.md) — RAG pipeline parameters
\ No newline at end of file
diff --git a/docs/docs/cli-reference/spectorctl.md b/docs/docs/cli-reference/spectorctl.md
index 28e38b2..da77cbd 100644
--- a/docs/docs/cli-reference/spectorctl.md
+++ b/docs/docs/cli-reference/spectorctl.md
@@ -1,52 +1,33 @@
-# 🖥️ CLI Reference
+# spectorctl CLI Reference
 
-> **Manage Spector from the command line.** `spectorctl` connects to a running server via REST and provides commands for indexing, ingestion, search, and status monitoring — with both human-friendly tables and machine-parseable JSON output.
+`spectorctl` is the command-line tool for managing Spector Search instances. It connects to a running server via the REST API.
 
----
-
-## 📦 Installation
+## Installation
 
 Build from source:
 
 ```bash
-cd spector
+cd spector-search
 mvn clean package -pl spector-cli -am -DskipTests
 ```
 
-The CLI JAR is at `spector-cli/target/spector-cli.jar`. Run it with:
-
-```bash
-java -jar spector-cli/target/spector-cli.jar [command] [options]
-```
-
-> [!TIP]
-> Create an alias for convenience:
-> ```bash
-> alias spectorctl='java -jar /path/to/spector-cli.jar'
-> ```
+The CLI is available at `spector-cli/target/spector-cli.jar`.
 
----
-
-## 🌐 Global Options
+## Global Options
 
 | Option | Default | Description |
 |--------|---------|-------------|
 | `--host` | localhost | Spector server hostname |
 | `--port` | 7070 | Spector server port |
-| `--json` | false | Output in JSON format (machine-parseable) |
-| `--api-key` | — | API key for authentication |
+| `--json` | false | Output in JSON format |
 | `--help` | — | Show help for any command |
 
----
-
-## 📋 Commands
+## Commands
 
-### 📊 `index` — Index Management
-
-Create, list, and delete indexes.
+### index — Index Management
 
 ```bash
-# Create an index with specific dimensions
+# Create an index
 spectorctl index create --name my-index --dimensions 384
 
 # List all indexes
@@ -56,207 +37,103 @@ spectorctl index list
 spectorctl index delete --name my-index
 ```
 
-| Option | Required | Description |
-|--------|----------|-------------|
-| `--name` | ✅ | Index name |
-| `--dimensions` | ✅ (create) | Vector dimensionality |
-
----
-
-### 📥 `ingest` — Document Ingestion
-
-The `ingest` command supports two modes, auto-detected from the flags:
-
-#### Local Batch Mode (via Runtime)
-
-Discovers and ingests files directly through `SpectorRuntime` — no server needed. Reads configuration from `spector.yml`.
-
-```bash
-# Ingest from config (root-directory, pattern, etc. from spector.yml)
-spectorctl ingest --config spector.yml
-
-# Ingest with explicit root directory
-spectorctl ingest --root /path/to/docs --pattern "**/*.md"
-
-# Override chunk size
-spectorctl ingest --config spector.yml --root . --chunk-size 1200
-```
-
-| Option | Required | Description |
-|--------|----------|-------------|
-| `--config` | ❌ | Path to `spector.yml` config file |
-| `--root` | ❌ | Root directory for file discovery |
-| `--pattern` | ❌ | File glob pattern (default from config) |
-| `--chunk-size` | ❌ | Chunk size in characters (default from config) |
-
-> [!TIP]
-> If `--config` is provided and `spector.yml` contains `spector.ingestion.root-directory`, local batch mode activates automatically — no `--root` flag needed.
-
-#### Remote Mode (via HTTP)
-
-Sends a single document to a running Spector server.
+### ingest — Document Ingestion
 
 ```bash
-# Ingest text content
-spectorctl ingest --id doc-1 --content "Hello world"
-
-# Ingest from a file
-spectorctl ingest --file README.md --title "Project README"
+# Ingest a single document
+spectorctl ingest --id doc-1 \
+  --content "SIMD-accelerated vector search" \
+  --vector "0.1,0.2,0.3,0.4,0.5"
 ```
 
-| Option | Required | Description |
-|--------|----------|-------------|
-| `--id` | ❌ | Document ID (auto-generated if not provided) |
-| `--content` | ❌ | Document text content |
-| `--file` | ❌ | Path to file to ingest |
-| `--title` | ❌ | Document title |
-
----
-
-### 🔍 `search` — Search Documents
+### search — Search Documents
 
 ```bash
-# Text/keyword search
+# Text search
 spectorctl search --text "vector search engine" --topK 10
 
 # Vector search
 spectorctl search --vector "0.1,0.2,0.3,0.4,0.5" --topK 5
 
-# Hybrid search
-spectorctl search --text "search" --vector "0.1,0.2,0.3,0.4,0.5" --topK 10
-
-# JSON output for scripting
+# JSON output
 spectorctl search --text "search" --json
 ```
 
-| Option | Required | Description |
-|--------|----------|-------------|
-| `--text` | ❌* | Query text for keyword search |
-| `--vector` | ❌* | Comma-separated query vector |
-| `--topK` | ❌ | Number of results (default: 10) |
+### status — Server Status
 
-> [!IMPORTANT]
-> *At least one of `--text` or `--vector` is required.
+```bash
+# Check server status
+spectorctl status
+```
 
----
+## Runnable CLI Example
 
-### 💚 `status` — Server Status
+This complete example demonstrates the full workflow using `spectorctl`:
 
 ```bash
-# Human-readable status
-spectorctl status
+# 1. Check that the server is running
+spectorctl --host localhost --port 7070 status
 
-# JSON output
-spectorctl status --json
-```
+# 2. Ingest documents
+spectorctl ingest --id cli-doc-1 \
+  --content "Spector Search uses HNSW for approximate nearest neighbors" \
+  --vector "0.9,0.1,0.3,0.7,0.5"
+
+spectorctl ingest --id cli-doc-2 \
+  --content "IVF-PQ provides memory-efficient billion-scale search" \
+  --vector "0.2,0.8,0.4,0.1,0.6"
 
----
+# 3. Search for documents
+spectorctl search --text "nearest neighbor search" --topK 5
 
-## 🎨 Output Formats
+# 4. Get results in JSON format for scripting
+spectorctl search --text "billion scale" --topK 3 --json
 
-### 📋 Table Format (Default)
+# 5. Check engine status and metrics
+spectorctl status
+```
 
-Human-readable tables for interactive use:
+### Expected Output
 
 ```
 $ spectorctl status
 ╔══════════════════════════════════════╗
-║ Spector Status                ║
+║ Spector Search Status                ║
 ╠══════════════════════════════════════╣
 ║ Status:    RUNNING                   ║
 ║ Port:      7070                      ║
 ║ SIMD:      AVX-512 (512-bit)         ║
 ║ GPU:       Available (CUDA 12.x)     ║
-║ Documents: 1250                      ║
+║ Documents: 2                         ║
 ╚══════════════════════════════════════╝
-```
 
-```
 $ spectorctl search --text "nearest neighbor" --topK 5
 ┌─────────────┬────────┬────────────────────────────────────────────┐
 │ ID          │ Score  │ Content                                    │
 ├─────────────┼────────┼────────────────────────────────────────────┤
-│ doc-1       │ 0.9412 │ Spector uses HNSW for approximate.. │
-│ doc-2       │ 0.7231 │ IVF-PQ provides memory-efficient billion.. │
+│ cli-doc-1   │ 0.9412 │ Spector Search uses HNSW for approximate.. │
+│ cli-doc-2   │ 0.7231 │ IVF-PQ provides memory-efficient billion..  │
 └─────────────┴────────┴────────────────────────────────────────────┘
 ```
 
-### 🔧 JSON Format (`--json`)
-
-Machine-parseable output for scripting and automation:
+## Error Handling
 
-```json
-{"status": "RUNNING", "port": 7070, "simd": "AVX-512 (512-bit)", "gpuAvailable": true, "documentCount": 1250}
-```
-
----
+| Scenario | Behavior |
+|----------|----------|
+| Server unreachable | Displays connection error with host:port |
+| Invalid arguments | Shows error message and command usage |
+| No results | Displays empty result table |
 
-## 🔧 Scripting Examples
+## Using with Scripts
 
-### Pipe to jq
+The `--json` flag makes output machine-parseable:
 
 ```bash
-# Extract document IDs from search results
+# Pipe search results to jq
 spectorctl search --text "query" --json | jq '.results[].id'
 
-# Check server health in CI
+# Check status in CI
 if spectorctl status --json | jq -e '.status == "RUNNING"' > /dev/null; then
   echo "Server is healthy"
 fi
 ```
-
-### Batch Ingestion from File
-
-```bash
-# Ingest from a JSONL file
-while IFS= read -r line; do
-  id=$(echo "$line" | jq -r '.id')
-  content=$(echo "$line" | jq -r '.content')
-  vector=$(echo "$line" | jq -r '.vector | join(",")')
-  spectorctl ingest --id "$id" --content "$content" --vector "$vector"
-done < documents.jsonl
-```
-
-### Health Check Script
-
-```bash
-#!/bin/bash
-MAX_RETRIES=30
-for i in $(seq 1 $MAX_RETRIES); do
-  if spectorctl --host $SPECTOR_HOST --port $SPECTOR_PORT status --json 2>/dev/null | \
-     jq -e '.status == "RUNNING"' > /dev/null 2>&1; then
-    echo "✅ Spector is ready"
-    exit 0
-  fi
-  echo "⏳ Waiting for server... ($i/$MAX_RETRIES)"
-  sleep 1
-done
-echo "❌ Server did not start in time"
-exit 1
-```
-
----
-
-## ⚠️ Error Handling
-
-| Scenario | Behavior |
-|----------|----------|
-| Server unreachable | Displays connection error with host:port |
-| Invalid arguments | Shows error message and command usage |
-| Missing required options | Shows which options are missing |
-| No results found | Displays empty result table |
-
-```
-$ spectorctl --host badhost --port 9999 status
-Error: Cannot connect to badhost:9999 — Connection refused
-```
-
----
-
-## 🔗 See Also
-
-- [REST API Reference](../api-reference/rest-endpoints.md) — The API that spectorctl uses
-
-- [Getting Started](../getting-started/quickstart.md) — Server setup before using CLI
-
-- [Configuration Guide](../configuration/parameters.md) — Server configuration
\ No newline at end of file
diff --git a/docs/docs/configuration/parameters.md b/docs/docs/configuration/parameters.md
index 6eb89c3..c4c1382 100644
--- a/docs/docs/configuration/parameters.md
+++ b/docs/docs/configuration/parameters.md
@@ -1,177 +1,89 @@
-# ⚙️ Configuration Guide
+# Configuration Parameters
 
-> **Every knob, dial, and lever in Spector — with sensible defaults and expert tuning advice.** Whether you're optimizing for recall, latency, throughput, or memory, this page has you covered.
+Spector Search is configured via `SpectorConfig`. All parameters have sensible defaults.
 
----
-
-## 🎯 Core Parameters
+## Core Parameters
 
 | Parameter | Default | Range | Description |
 |-----------|---------|-------|-------------|
-| `dimensions` | 384 | 1–2048 | Vector dimensionality (must match your embedding model) |
-| `capacity` | 100,000 | 1–10,000,000 | Maximum document count |
+| `dimensions` | 384 | 1–2048 | Vector dimensionality |
+| `capacity` | 100,000 | 1–10M | Maximum document count |
 | `similarityFunction` | COSINE | COSINE, DOT_PRODUCT, EUCLIDEAN | Distance metric |
 
-> [!TIP]
-> **Quick model reference:**
-> | Model | Dimensions |
-> |-------|-----------|
-> | all-MiniLM-L6-v2 | 384 |
-> | e5-base-v2 | 768 |
-> | text-embedding-ada-002 | 1536 |
-> | nomic-embed-text | 768 |
-
-**Choosing a similarity function:**
-
-- **COSINE** — Normalized embeddings (most models)
-
-- **DOT_PRODUCT** — Unnormalized embeddings where magnitude matters
-
-- **EUCLIDEAN** — Spatial/geometric data
-
----
-
-## 🗜️ Quantization Parameters
-
-| Parameter | Default | Range | Description |
-|-----------|---------|-------|-------------|
-| `quantization` | NONE | NONE, SCALAR_INT8, SCALAR_INT4, SCALAR_INT2, IVF_PQ | Quantization type |
-| `oversamplingFactor` | auto | 1–20 | Rescore oversampling (auto: INT8→1, INT4→3, INT2→5) |
-
-### 🎛️ Quantization Profiles
-
-| Priority | Type | Oversampling | Compression | Recall | Use Case |
-|----------|------|--------------|-------------|--------|----------|
-| 🎯 Max recall | INT8 | 1 (none) | 4× | 95–99% | Quality-critical search |
-| ⚖️ Balanced | INT4 | 3 | 8× | 85–95% | Best compression/recall ratio |
-| 💾 Memory-first | INT2 | 5 | 16× | 75–90% | Fit large datasets in RAM |
-| 🚀 Billion-scale | IVF_PQ | — | 32× | 75–90% | Massive datasets |
-
-> [!TIP]
-> **Start with INT4** for most workloads. It gives 8× compression with excellent recall when paired with the default 3× rescore. Only go to INT2 if memory is the binding constraint, or IVF-PQ if you're at billion scale.
-
-### Oversampling Tuning
-
-The `oversamplingFactor` controls how many extra candidates are retrieved before rescoring with exact distances:
-
-- **1** — No rescore (fastest, quantized scores returned directly)
-
-- **3** — Good balance for INT4 (retrieves 3×K candidates, rescores to top-K)
-
-- **5** — Recommended for INT2 (compensates for aggressive quantization)
-
-- **10+** — Diminishing returns; use only if recall is still insufficient
-
-```java
-// INT4 with custom oversampling
-var config = SpectorConfig.DEFAULT
-    .withDimensions(384)
-    .withCapacity(50_000_000)
-    .withQuantization(QuantizationType.SCALAR_INT4)
-    .withRescore(5);  // Higher oversampling = better recall, slightly slower
-```
-
----
-
-## 🌐 HNSW Index Parameters
+## HNSW Index Parameters
 
 | Parameter | Default | Range | Description |
 |-----------|---------|-------|-------------|
 | `M` | 16 | 4–64 | Max connections per node per layer |
-| `efConstruction` | 200 | 16–800 | Construction beam width |
-| `efSearch` | 50 | 10–500 | Search beam width |
-
-### 🎛️ Tuning Profiles
+| `efConstruction` | 200 | 16–800 | Construction beam width (higher = better recall, slower build) |
+| `efSearch` | 50 | 10–500 | Search beam width (higher = better recall, slower query) |
 
-| Priority | M | efConstruction | efSearch | Trade-off |
-|----------|---|----------------|----------|-----------|
-| 🎯 High recall | 32–64 | 400–800 | 200–500 | More memory, slower build/search |
-| ⚖️ Balanced | 16 | 200 | 50 | Good recall with fast performance |
-| ⚡ Low latency | 8–12 | 100 | 20–30 | Faster search, lower recall |
-| 💾 Memory-constrained | 4–8 | 100 | 20 | Minimal memory, lower recall |
-
-> [!IMPORTANT]
-> `efSearch` should be ≥ `topK` for meaningful results. Setting `efSearch < topK` means you're asking for more results than the algorithm explores.
-
----
-
-## 📝 BM25 Parameters
+## BM25 Parameters
 
 | Parameter | Default | Range | Description |
 |-----------|---------|-------|-------------|
 | `k1` | 1.2 | 0.0–3.0 | Term frequency saturation |
 | `b` | 0.75 | 0.0–1.0 | Document length normalization |
 
-| Corpus Type | Recommended k1 | Recommended b |
-|-------------|----------------|---------------|
-| Short docs (tweets, titles) | 1.2 | 0.3 |
-| Medium docs (articles) | 1.2 | 0.75 |
-| Long docs (books, papers) | 1.5–2.0 | 0.75 |
-| Mixed lengths | 1.2 | 0.5 |
-
----
-
-## 🧬 Hybrid Search (RRF)
+## Hybrid Search
 
-| Parameter | Default | Range | Description |
-|-----------|---------|-------|-------------|
-| `RRF k` | 60 | 1–1000 | Reciprocal Rank Fusion constant |
-
-- `k = 60` — Original paper recommendation, works well generally
+| Parameter | Default | Description |
+|-----------|---------|-------------|
+| `RRF k` | 60 | Reciprocal Rank Fusion constant |
 
-- Lower `k` (10–30) — Emphasizes top-ranked results more strongly
+## GPU Configuration
 
-- Higher `k` (100+) — Flattens rank importance
+| Parameter | Default | Description |
+|-----------|---------|-------------|
+| `gpuEnabled` | false | Enable CUDA GPU acceleration |
+| `gpuMemoryBudget` | 256 MB | Maximum GPU memory allocation |
 
----
+> **Note:** For INT4/INT2 quantization, GPU acceleration requires vector dimensions to be a multiple of 32. Non-aligned dimensions automatically fall back to CPU/SIMD.
 
-## 🎮 GPU Configuration
+## Quantization Configuration
 
 | Parameter | Default | Range | Description |
 |-----------|---------|-------|-------------|
-| `gpuEnabled` | false | true/false | Enable CUDA GPU acceleration |
-| `gpuMemoryBudget` | 256 MB | 256 MB – GPU max | Maximum GPU memory allocation |
-| `gpuBatchWindow` | 10 ms | 1–100 ms | Batching window for query collection |
-| `gpuMaxBatchSize` | 1024 | 1–1024 | Maximum queries per GPU batch |
+| `quantization` | NONE | NONE, SCALAR_INT8, SCALAR_INT4, SCALAR_INT2 | Scalar quantization type |
+| `oversamplingFactor` | auto | 1–20 | Rescore oversampling factor (auto: INT8→1, INT4→3, INT2→5) |
 
-> [!NOTE]
-> Enable GPU for batch workloads with >10K vectors. Single queries are often faster on CPU SIMD due to zero kernel launch overhead.
-> For INT4/INT2 quantization, GPU acceleration requires dimensions to be a multiple of 32. Non-aligned dimensions automatically fall back to CPU/SIMD.
+### Quantization Types
 
----
+| Type | Compression | Recall | Calibration | Best For |
+|------|-------------|--------|-------------|----------|
+| SCALAR_INT8 | 4× | 95–99% | Linear (min/max) | High-recall, moderate scale |
+| SCALAR_INT4 | 8× | 85–95% | Non-uniform (quantile) | Balanced compression/recall |
+| SCALAR_INT2 | 16× | 75–90% | Non-uniform (quantile) | Memory-constrained, large datasets |
 
-## 🤖 Reranker Configuration
+### Rescore Strategy
 
-| Parameter | Default | Range | Description |
-|-----------|---------|-------|-------------|
-| `rerankerEnabled` | false | true/false | Enable LLM re-ranking via Ollama |
-| `rerankerModel` | — | Any Ollama model | Model name (e.g., "llama3.2") |
-| `rerankerEndpoint` | http://localhost:11434 | URL | Ollama API endpoint |
-| `rerankerMaxCandidates` | 20 | 1–100 | Max docs sent to LLM |
+When `oversamplingFactor > 1`, Spector retrieves `oversamplingFactor × k` candidates using fast quantized distance, then rescores with exact float32 distances to return the true top-K:
 
-> [!WARNING]
-> Re-ranking adds **100–500ms latency** per query. Use only when precision is critical and latency budget allows.
+| Quantization | Default Oversampling | Effect |
+|-------------|---------------------|--------|
+| INT8 | 1 (no rescore) | Already near-lossless |
+| INT4 | 3 | Recovers recall to 85–95% |
+| INT2 | 5 | Compensates for aggressive quantization |
 
----
+Set `oversamplingFactor` to 1 to disable rescoring (faster, lower recall).
 
-## 🖥️ Server Configuration
+## Reranker Configuration
 
 | Parameter | Default | Description |
 |-----------|---------|-------------|
-| `port` | 7070 | HTTP server port |
-| `apiKey` | — | Optional API key (empty = no auth) |
-| `corsOrigins` | * | Allowed CORS origins |
+| `rerankerEnabled` | false | Enable LLM re-ranking via Ollama |
+| `rerankerModel` | — | Ollama model name (e.g., "llama3.2") |
+| `rerankerEndpoint` | http://localhost:11434 | Ollama API endpoint |
+| `rerankerMaxCandidates` | 20 | Max docs sent to LLM for re-ranking |
 
-```bash
-# Format: port dimensions apiKey
-mvn exec:java -pl spector-node \
-  -Dexec.mainClass="com.spectrayan.spector.server.SpectorNode" \
-  -Dexec.args="7070 384 my-secret-key"
-```
+## Server Configuration
 
----
+| Parameter | Default | Description |
+|-----------|---------|-------------|
+| `port` | 7070 | HTTP server port |
+| `apiKey` | — | Optional API key for authentication |
 
-## 🌐 Cluster Configuration
+## Cluster Configuration
 
 | Parameter | Default | Range | Description |
 |-----------|---------|-------|-------------|
@@ -179,98 +91,28 @@ mvn exec:java -pl spector-node \
 | `replicaCount` | 1 | 1–5 | Replicas per shard |
 | `heartbeatInterval` | 2s | 500ms–30s | Cluster heartbeat interval |
 | `heartbeatTimeout` | 10s | 3s–120s | Node unavailability timeout |
-| `queryTimeout` | 10s | 1s–60s | Per-shard query timeout |
-
-> [!TIP]
-> Rule of thumb: **100K–500K docs per shard** for optimal balance. Set `heartbeatTimeout` to at least 5× `heartbeatInterval`.
-
----
 
-## 🤖 RAG Pipeline Configuration
+## RAG Pipeline Configuration
 
 | Parameter | Default | Range | Description |
 |-----------|---------|-------|-------------|
 | `maxTokens` | 512 | 1–8192 | Max tokens per chunk |
 | `overlapTokens` | 50 | 0–maxTokens-1 | Overlap between chunks |
-| `embeddingBatchSize` | 32 | 1–256 | Batch size for embedding generation |
+| `embeddingBatchSize` | 32 | 1–256 | Embedding batch size |
 | `embeddingRetries` | 3 | 0–10 | Retry count for failed batches |
-| `contextTokenLimit` | 4096 | 256–131072 | Max tokens in assembled context |
 
----
-
-## 🎯 Configuration Examples
-
-### 🎯 High-Recall Setup
+## Example Configuration
 
 ```java
 var config = SpectorConfig.DEFAULT
     .withDimensions(384)
-    .withCapacity(500_000)
-    .withQuantization(QuantizationType.SCALAR_INT8)
-    .withM(32)
-    .withEfConstruction(400)
-    .withEfSearch(200);
-```
-
-### 🗜️ Balanced Compression (INT4)
-
-```java
-var config = SpectorConfig.DEFAULT
-    .withDimensions(384)
-    .withCapacity(50_000_000)
-    .withQuantization(QuantizationType.SCALAR_INT4)
-    .withRescore(3);  // default for INT4
-```
-
-### 💾 Maximum Compression (INT2)
-
-```java
-var config = SpectorConfig.DEFAULT
-    .withDimensions(384)
-    .withCapacity(200_000_000)
-    .withQuantization(QuantizationType.SCALAR_INT2)
-    .withRescore(5);  // default for INT2
-```
-
-### ⚡ Low-Latency Setup
-
-```java
-var config = SpectorConfig.DEFAULT
-    .withDimensions(128)
     .withCapacity(100_000)
-    .withM(12)
-    .withEfConstruction(100)
-    .withEfSearch(30);
-```
-
-### 🎮 GPU-Accelerated Batch Processing
-
-```java
-var config = SpectorConfig.DEFAULT
-    .withDimensions(768)
-    .withCapacity(1_000_000)
+    .withQuantization(QuantizationType.SCALAR_INT4)  // 8× compression
+    .withRescore(3)                                   // 3× oversampling for recall
     .withGpu(true)
-    .withGpuMemoryBudget(2048);  // 2 GB
-```
+    .withReranker("http://localhost:11434", "llama3.2", 20);
 
-### 🤖 RAG Pipeline
-
-```java
-var config = SpectorConfig.DEFAULT
-    .withDimensions(384)
-    .withMaxTokens(1024)
-    .withOverlapTokens(100)
-    .withEmbeddingBatchSize(64);
+try (var engine = new SpectorEngine(config)) {
+    // Use engine...
+}
 ```
-
----
-
-## 🔗 See Also
-
-- [Performance Tuning](../operations/performance-tuning.md) — Benchmarks and optimization strategies
-
-- [Architecture Overview](../architecture/overview.md) — How configuration affects system behavior
-
-- [Distributed Mode](../architecture/distributed-mode.md) — Cluster-specific configuration
-
-- [GPU Acceleration](../architecture/gpu-acceleration.md) — GPU setup requirements
\ No newline at end of file
diff --git a/docs/docs/cortex/index.md b/docs/docs/cortex/index.md
deleted file mode 100644
index f1f1fc5..0000000
--- a/docs/docs/cortex/index.md
+++ /dev/null
@@ -1,317 +0,0 @@
----
-title: "🧬 Spector Cortex — Neural Dashboard"
-description: "Real-time visualization dashboard for Spector's cognitive memory engine — neural graphs, vector spaces, SIMD lanes, memory heatmaps, and live cognitive metrics."
----
-
-# 🧬 Spector Cortex — Neural Dashboard
-
-!!! quote "The Vision"
-    What if you could **watch your AI's brain think?** Spector Cortex is a real-time neural dashboard that visualizes the cognitive memory engine — from SIMD lanes firing to Hebbian edges strengthening to memories decaying along the Ebbinghaus curve. It's the difference between a black box and a living brain.
-
----
-
-![Spector Cortex Dashboard](spector-cortex-dashboard.png)
-
----
-
-## Overview
-
-Spector Cortex is an Angular 21 standalone application that provides a real-time, interactive visualization of Spector's cognitive memory engine. It connects to a running Spector Node via SSE (Server-Sent Events) and renders every cognitive event — queries, recalls, consolidation cycles, graph mutations — as they happen.
-
-The dashboard is built around **12 panels** organized in a responsive 3-column grid, each visualizing a different aspect of the cognitive pipeline:
-
-| Panel | Visualization | What It Shows |
-|:------|:--------------|:--------------|
-| **Neural Graph** | Three.js 3D graph | 200-node cognitive network with Hebbian, temporal, and entity edges — particles flow along connections during query spreading activation |
-| **Vector Space** | Three.js point cloud | 300-point PCA-projected embedding space with query dot and nearest-neighbor lines |
-| **Scoring Pipeline** | Animated funnel bars | The 6-phase cognitive scoring funnel — from total records → tombstone → tags → valence → decay → distance → final top-K |
-| **Live Metrics** | Canvas time-series | Real-time recall/remember/reinforce/forget rates plotted as multi-line chart |
-| **Cognitive Profile** | Canvas radar chart | 6-axis radar showing current thalamic modulation parameters (α, β, strictness, hyperfocus, lateral, valence range) |
-| **SIMD & Hardware** | Canvas register grid | 16-lane SIMD register heatmap showing vector processing utilization |
-| **Memory Heatmap** | Canvas segment bars | Off-heap memory segment utilization across all 4 tier stores + graph structures |
-| **Decay Curve** | Canvas overlay chart | Ebbinghaus forgetting curve (dashed) vs. LTP reconsolidation curve (solid) — shows how recall events boost retention |
-| **Query History** | Scrollable timeline | Chronological query traces with profile, latency, and augmented result counts |
-| **Zeigarnik Effect** | Tension gauge | Unresolved memory count and cognitive tension percentage — the Zeigarnik effect biases recall toward incomplete tasks |
-| **Habituation** | IoR/satiation bars | Inhibition of Return, semantic satiation, and habituation penalty gauges — the anti-filter-bubble mechanisms |
-| **Query Input** | Search bar | Submit queries to see the full pipeline execute in real time |
-
----
-
-## Architecture
-
-### Technology Stack
-
-| Layer | Technology |
-|:------|:-----------|
-| **Framework** | Angular 21 (standalone, zoneless) |
-| **UI Components** | Angular Material 3 (M3 design tokens) |
-| **3D Visualization** | Three.js (Neural Graph, Vector Space) |
-| **2D Visualization** | Canvas 2D API with `requestAnimationFrame` |
-| **State Management** | Angular Signals (reactive, fine-grained) |
-| **Real-time Data** | SSE via `ng-sse-client` (mock data available) |
-| **Styling** | SCSS with M3 CSS custom properties (`--mat-sys-*`) |
-| **Theme** | Dark / Light toggle, fully token-based |
-
-### Signal-Based Reactive Architecture
-
-Spector Cortex uses a **pure signal-based architecture** — no RxJS, no NgRx, no zone.js.
-
-```mermaid
-graph LR
-    SSE["SSE Stream<br/><i>or Mock Data</i>"] --> CS["CortexStateService<br/><i>Signal Store</i>"]
-    CS --> NG["Neural Graph"]
-    CS --> VS["Vector Space"]
-    CS --> PF["Pipeline Funnel"]
-    CS --> MC["Metrics Chart"]
-    CS --> PR["Profile Radar"]
-    CS --> SP["SIMD Panel"]
-    CS --> MH["Memory Heatmap"]
-    CS --> DC["Decay Curve"]
-    CS --> QH["Query History"]
-    CS --> ZT["Zeigarnik Tracker"]
-    CS --> HM["Habituation Meter"]
-    CS --> QI["Query Input"]
-```
-
-**`CortexStateService`** is the single source of truth. It holds 20+ signals covering:
-
-- **Query state**: current trace, query history, running status
-- **Graph state**: nodes, edges, pulses, layer toggles, active profile
-- **Metrics state**: time-series history, decay curves, habituation metrics
-- **System state**: SIMD utilization, memory segments, JVM metrics
-- **Vector state**: embedding points, query vector, nearest neighbors
-
-All components are **pure presentation** — they read signals and render. No component contains business logic.
-
-### Mock Data System
-
-The `MockDataService` generates realistic runtime data so the dashboard is fully functional without a running Spector Node:
-
-```typescript
-// Toggle mock data on/off via signal
-state.useMockData.set(true);   // Enable mock data
-state.useMockData.set(false);  // Switch to real SSE stream
-```
-
-Mock data includes:
-
-- **Simulated queries** every 2-4 seconds with randomized latency, profile selection, and scoring funnel
-- **Graph pulses** cycling through Hebbian, temporal, and entity edge types
-- **Reflect cycles** with consolidation animations (edge pruning, tombstone compaction)
-- **Vector points** — 300 embeddings in PCA-projected 3D space with natural tier-based clustering
-- **Metrics time-series** — recall/remember/reinforce/forget rates with realistic fluctuation
-- **Decay curves** — 30-day Ebbinghaus + LTP reconsolidation with stochastic recall bumps
-- **Habituation metrics** — IoR, satiation, and penalty values evolving over time
-- **Zeigarnik tracking** — unresolved/total task counts with tension percentage
-
----
-
-## Quick Start
-
-### Prerequisites
-
-- **Node.js** ≥ 20
-- **npm** ≥ 10
-
-### Run Locally
-
-```bash
-cd spector-cortex
-npm install
-npx ng serve --port 4300
-```
-
-Open [http://localhost:4300](http://localhost:4300) — the dashboard starts immediately with mock data.
-
-### Connect to a Running Spector Node
-
-By default, the dashboard uses mock data. To connect to a real Spector Node:
-
-1. Ensure your Spector Node is running with SSE events enabled
-2. Update the SSE endpoint in the environment configuration
-3. Set `useMockData` to `false` in `CortexStateService`
-
----
-
-## Panel Deep Dives
-
-### Neural Graph
-
-The centerpiece of the dashboard — a Three.js 3D graph with 200 nodes organized by memory tier:
-
-- **Node colors**: Working (amber), Episodic (green), Semantic (blue), Procedural (purple)
-- **Node radius**: Proportional to tier (Working = inner, Procedural = outer shell)
-- **3 edge types**:
-    - **Hebbian** — solid white lines (co-activation strength)
-    - **Temporal** — dashed cyan lines (causal/temporal chains)
-    - **Entity** — solid gold lines (entity-relationship knowledge)
-
-**Interactive features:**
-
-- [x] **Layer toggles** — show/hide each edge type independently
-- [x] **Query traversal particles** — colored spheres flow along edges during spreading activation
-- [x] **Particle trails** — each particle has a larger, dimmer glow sphere trailing behind
-- [x] **Ambient particle stream** — continuous particles to keep the graph alive
-- [x] **Profile visual transforms** — HYPERFOCUS (tunnel vision), PARANOID (red shift), DIVERGENT (rainbow shimmer)
-- [x] **Consolidation animation** — edges dim and prune when `reflect()` fires
-- [x] **Mouse interaction** — camera follows mouse position for parallax effect
-
-### Vector Space
-
-A Three.js point cloud of 300 memory embeddings projected into 3D via PCA:
-
-- Points are colored by tier and sized by importance
-- **Query dot** — when a query fires, a white pulsing sphere appears at the query vector position
-- **Nearest-neighbor lines** — 5 translucent lines connect the query dot to its closest memories
-- Camera orbits slowly with mouse parallax
-
-### Scoring Pipeline
-
-Animated horizontal funnel showing the 6-phase cognitive scoring pipeline:
-
-| Phase | Description |
-|:------|:------------|
-| Total Records | Starting record count |
-| After Tombstone | Tombstone-filtered records |
-| After Tag Gate | Synaptic tag bloom filter pass |
-| After Valence | Emotional valence range filter |
-| After Decay | Temporal decay threshold |
-| Vector Distance | L2 distance scoring |
-| Final Top-K | Final result set |
-
-Each bar animates smoothly to new values and shows the delta percentage (reduction) from the previous phase.
-
-### Decay Curve
-
-Visualizes the Ebbinghaus forgetting curve alongside LTP (Long-Term Potentiation) reconsolidation:
-
-- **Red dashed line** — raw Ebbinghaus exponential decay (no intervention)
-- **Primary solid line** — actual retention with LTP reconsolidation bumps from recall events
-- **Filled area** — shows the retention gain from the reconsolidation system
-- X-axis spans 30 days; Y-axis shows retention percentage
-
-### Cognitive Profile Radar
-
-6-axis radar chart showing the current cognitive profile's thalamic modulation parameters:
-
-| Axis | Parameter | Range |
-|:-----|:----------|:------|
-| α Similarity | Similarity weight | 0–1.0 |
-| β Importance | Importance weight | 0–1.0 |
-| Strictness | Score threshold | 0–10.0 |
-| Hyperfocus | Focus mode boost | 0–2.0 |
-| Lateral | Divergent retrieval | 0–1.0 |
-| Valence Range | Emotional filter width | 0–255 |
-
-The radar morphs smoothly when the active profile changes (BALANCED → HYPERFOCUS → PARANOID → etc.).
-
----
-
-## Project Structure
-
-```
-spector-cortex/
-├── src/
-│   ├── app/
-│   │   ├── core/
-│   │   │   ├── models/
-│   │   │   │   ├── cortex-events.ts      # SSE event type interfaces
-│   │   │   │   ├── graph-types.ts         # Graph pulse interfaces
-│   │   │   │   └── memory-types.ts        # CognitiveProfile, PROFILE_PARAMS
-│   │   │   └── services/
-│   │   │       ├── cortex-state.service.ts # Signal store (single source of truth)
-│   │   │       ├── mock-data.service.ts    # Simulated event generator
-│   │   │       └── theme.service.ts        # Dark/light theme toggle
-│   │   ├── features/
-│   │   │   ├── dashboard/                  # Main layout (3-col grid)
-│   │   │   ├── header/                     # Toolbar with status & controls
-│   │   │   ├── neural-graph/               # Three.js neural graph
-│   │   │   ├── vector-space/               # Three.js vector space
-│   │   │   ├── pipeline-funnel/            # Scoring pipeline funnel
-│   │   │   ├── simd-panel/                 # SIMD lane heatmap
-│   │   │   ├── memory-heatmap/             # Off-heap segment visualization
-│   │   │   ├── profile-radar/              # Cognitive profile radar chart
-│   │   │   ├── metrics-chart/              # Live metrics time-series
-│   │   │   ├── decay-curve/                # Ebbinghaus + LTP chart
-│   │   │   ├── query-input/                # Search bar
-│   │   │   ├── query-history/              # Query timeline
-│   │   │   ├── zeigarnik-tracker/          # Incomplete tension gauge
-│   │   │   └── habituation-meter/          # Anti-loop mechanism gauges
-│   │   └── app.component.ts                # Root component
-│   ├── styles.scss                          # Global M3 theme
-│   └── index.html
-├── angular.json
-├── package.json
-└── tsconfig.json
-```
-
----
-
-## Design Principles
-
-### 1. Angular Material 3 Tokens Only
-
-All colors reference M3 CSS custom properties — **zero hardcoded colors**:
-
-```scss
-// ✅ Correct — uses M3 token
-color: var(--mat-sys-primary);
-background: var(--mat-sys-surface-container-high);
-
-// ❌ Wrong — hardcoded color
-color: #bb86fc;
-```
-
-This ensures the entire dashboard automatically adapts when switching between dark and light themes.
-
-### 2. Separation of Concerns
-
-| Layer | Rule |
-|:------|:-----|
-| **Components** | Pure presentation only — read signals, render UI |
-| **Services** | All business logic, state mutations, data processing |
-| **Templates** | Separate `.html` files — no inline templates |
-| **Styles** | Separate `.scss` files — no inline styles |
-
-### 3. Canvas for Performance
-
-All 2D charts use raw Canvas 2D API with `requestAnimationFrame` instead of chart libraries — this keeps the bundle small and eliminates third-party DOM overhead in animation-heavy panels.
-
-### 4. Responsive Grid
-
-The dashboard uses CSS Grid with breakpoints:
-
-| Breakpoint | Columns | Behavior |
-|:-----------|:--------|:---------|
-| > 1200px | 3 columns | Full layout |
-| 768–1200px | 2 columns | Neural Graph spans full width |
-| < 768px | 1 column | Single column, stacked |
-
----
-
-## Connecting to Real Data
-
-Spector Cortex is designed to consume SSE events from `spector-node`. The event types map directly to signals:
-
-| SSE Event Type | Signal | Panel |
-|:---------------|:-------|:------|
-| `query.trace` | `currentQueryTrace` | Neural Graph, Pipeline, History |
-| `query.vector` | `queryVector` | Vector Space |
-| `graph.pulse` | `graphPulses` | Neural Graph edges |
-| `reflect.complete` | `lastReflect` | Neural Graph consolidation |
-| `profile.change` | `activeProfile` | Profile Radar, Neural Graph |
-| `metrics.snapshot` | `metricsHistory` | Metrics Chart |
-| `habituation.update` | `habituation` | Habituation Meter |
-
-When `useMockData` is `false`, the `EventStreamService` connects to the configured SSE endpoint and pushes events into `CortexStateService` signals.
-
----
-
-## Future Roadmap
-
-- [ ] **Integration with Synaptiq** — embed Cortex panels into the Synaptiq monitoring dashboard
-- [ ] **Async event emission** — SSE events emitted on virtual threads (gated behind feature flag)
-- [ ] **Replay mode** — record and replay cognitive sessions for debugging
-- [ ] **Cluster view** — multi-node visualization for distributed Spector deployments
-- [ ] **GPU acceleration panel** — CUDA kernel execution timeline visualization
-- [ ] **Memory diff view** — before/after comparison of consolidation cycles
diff --git a/docs/docs/cortex/spector-cortex-dashboard.png b/docs/docs/cortex/spector-cortex-dashboard.png
deleted file mode 100644
index dc8dcfd..0000000
Binary files a/docs/docs/cortex/spector-cortex-dashboard.png and /dev/null differ
diff --git a/docs/docs/deep-dives/ann-search-primer.md b/docs/docs/deep-dives/ann-search-primer.md
deleted file mode 100644
index 74c097a..0000000
--- a/docs/docs/deep-dives/ann-search-primer.md
+++ /dev/null
@@ -1,244 +0,0 @@
-# 🔍 Approximate Nearest Neighbor Search
-
-> **A beginner-friendly guide to how search engines find similar items in milliseconds, even across millions of records.** This page explains ANN from first principles — no math prerequisites required.
-
----
-
-## 🤔 The Problem: Finding Similar Things
-
-Imagine you have a photo of a sunset and want to find the 10 most similar sunset photos from a collection of 10 million images. Each image has been converted to a **vector** — a list of numbers that captures its visual essence:
-
-```
-🌅 Your photo  → [0.82, -0.15, 0.44, 0.67, ..., 0.21]  (768 numbers)
-📸 Photo #1    → [0.79, -0.12, 0.41, 0.70, ..., 0.18]  (768 numbers)
-📸 Photo #2    → [-0.55, 0.88, -0.23, 0.11, ..., 0.67] (768 numbers)
-...
-📸 Photo #10M  → [0.33, 0.44, -0.12, 0.55, ..., 0.91]  (768 numbers)
-```
-
-The **naive approach** compares your photo to every single photo in the collection:
-
-```
-10,000,000 comparisons × 768 multiplications each = 7.68 billion operations
-```
-
-Even on a fast CPU, that takes **seconds**. For a real-time search engine serving thousands of users simultaneously, seconds is an eternity.
-
-> [!NOTE]
-> This is called the **curse of dimensionality** — as vectors get longer (higher dimensional), the search space grows exponentially. Brute-force becomes impossible at scale.
-
----
-
-## 💡 The Key Insight: "Close Enough" Is Good Enough
-
-Here's the breakthrough: for most applications, you don't need the *mathematically perfect* top-10. You need results that are *really close* to perfect. If the true best match has a similarity score of 0.97 and your algorithm returns a match with 0.96, no user will notice the difference.
-
-**Approximate Nearest Neighbor (ANN)** algorithms exploit this insight. They organize vectors into clever data structures that let you skip most comparisons while still finding excellent results.
-
-The trade-off:
-
-```mermaid
-graph LR
-    A["🎯 Exact Search\n100% recall\nO(n) time"] -->|"Trade accuracy\nfor speed"| B["⚡ ANN Search\n95%+ recall\nO(log n) time"]
-```
-
----
-
-## 🏗️ ANN Algorithm Families
-
-### 1. 🌳 Tree-Based Methods
-
-**Idea:** Recursively split the vector space into regions. At search time, only explore the regions near the query.
-
-**Example: KD-Trees**
-- Split along one dimension at each level (like cutting a map into quadrants)
-- Works well up to ~20 dimensions
-- Falls apart in high dimensions (the "curse" again)
-
-**Example: Annoy (Spotify)**
-- Builds random projection trees
-- Each tree splits space with random hyperplanes
-- Uses multiple trees and merges results for better recall
-
-```mermaid
-graph TD
-    Root["All vectors"] --> L["Left half\n(dim 5 < 0.3)"]
-    Root --> R["Right half\n(dim 5 ≥ 0.3)"]
-    L --> LL["Leaf: 500 vectors"]
-    L --> LR["Leaf: 480 vectors"]
-    R --> RL["Leaf: 510 vectors"]
-    R --> RR["Leaf: 510 vectors"]
-```
-
-> **Verdict:** Simple but limited. Trees struggle above 50 dimensions, which is far below modern embedding sizes (384–4096).
-
----
-
-### 2. 🗂️ Inverted File (IVF)
-
-**Idea:** Cluster vectors into groups (using K-Means). At search time, only search the closest clusters.
-
-**How it works:**
-1. **Training:** Run K-Means to find cluster centers (centroids)
-2. **Ingestion:** Assign each vector to its nearest centroid
-3. **Search:** Find the `nprobe` closest centroids to the query, then brute-force search only those clusters
-
-```mermaid
-graph TD
-    Q["🔍 Query"] --> C["Find nearest centroids"]
-    C --> P1["📦 Cluster 1\n~3,000 vectors"]
-    C --> P2["📦 Cluster 2\n~3,100 vectors"]
-    C --> P3["📦 Cluster 3\n~2,900 vectors"]
-    P1 --> M["Merge & return top-K"]
-    P2 --> M
-    P3 --> M
-```
-
-**Speed:** With 1000 clusters and `nprobe=10`, you search only 1% of the data.
-
-**Recall control:** The `nprobe` parameter is your recall/speed knob:
-- `nprobe=1` → Fast but ~30% recall (might miss neighbors in adjacent clusters)
-- `nprobe=10` → Balanced, ~85% recall
-- `nprobe=50` → Slower but ~98% recall
-
-> **Verdict:** Excellent at scale (billions of vectors). The foundation of most production systems.
-
----
-
-### 3. 🕸️ Graph-Based Methods (HNSW)
-
-**Idea:** Build a navigable graph where each vector is connected to its neighbors. At search time, traverse the graph like walking through a social network.
-
-This is the most important ANN algorithm today. See our [HNSW Deep Dive](hnsw-explained.md) for the full story.
-
-**Key properties:**
-- **High recall** (95-99%) out of the box
-- **Fast search** — O(log n) comparisons
-- **Slow build** — each insertion requires graph updates
-- **Memory hungry** — stores graph edges alongside vectors
-
-> **Verdict:** Best recall-vs-speed trade-off for datasets up to ~10M vectors. The gold standard.
-
----
-
-### 4. 🔗 Hybrid: IVF + HNSW (SpectorIndex)
-
-**Idea:** Use IVF to partition the space, then build a small HNSW graph inside each partition. Best of both worlds.
-
-This is what Spector's flagship **SpectorIndex** implements. See our [SpectorIndex Deep Dive](spector-index-architecture.md) for the full architecture.
-
-```mermaid
-graph TD
-    Q["🔍 Query"] --> IVF["IVF: Find closest partitions"]
-    IVF --> S1["Shard 1: HNSW graph\n(5,000 vectors)"]
-    IVF --> S2["Shard 2: HNSW graph\n(4,800 vectors)"]
-    IVF --> S3["Shard 3: Flat scan\n(200 vectors)"]
-    S1 --> M["Global merge → top-K"]
-    S2 --> M
-    S3 --> M
-```
-
-> **Verdict:** Scales to millions while maintaining excellent recall. The future of vector search.
-
----
-
-## 📐 Distance Metrics
-
-How do we measure "similarity" between two vectors? Three common choices:
-
-### Cosine Similarity
-
-Measures the **angle** between vectors. Ignores magnitude (length).
-
-$$\text{cosine}(a, b) = \frac{a \cdot b}{\|a\| \cdot \|b\|}$$
-
-- Range: [-1, 1] (1 = identical direction, 0 = perpendicular, -1 = opposite)
-- Best for: **text embeddings** (where direction captures meaning)
-
-### Euclidean Distance (L2)
-
-Measures the **straight-line distance** between two points.
-
-$$L2(a, b) = \sqrt{\sum_i (a_i - b_i)^2}$$
-
-- Range: [0, ∞) (0 = identical, higher = more different)
-- Best for: **image embeddings**, clustering
-- Key property: **translation-invariant** (shifting both vectors by the same amount doesn't change the distance)
-
-### Dot Product
-
-The raw inner product — like cosine but without normalization.
-
-$$\text{dot}(a, b) = \sum_i a_i \cdot b_i$$
-
-- Range: (-∞, ∞) (higher = more similar for normalized vectors)
-- Best for: **recommendation systems** (where magnitude matters)
-
-> [!TIP]
-> For **unit-normalized vectors** (length = 1), all three metrics give equivalent rankings:
-> $$L2^2(a, b) = 2 - 2 \cdot \text{cosine}(a, b)$$
-> So choosing between them is mainly about convention and API design.
-
----
-
-## 📊 The Recall–Speed–Memory Triangle
-
-Every ANN algorithm makes trade-offs between three properties:
-
-```mermaid
-graph TD
-    R["🎯 Recall\n(accuracy)"] --- S["⚡ Speed\n(latency)"]
-    S --- M["💾 Memory\n(footprint)"]
-    M --- R
-```
-
-| Algorithm | Recall | Speed | Memory | Scale |
-|-----------|--------|-------|--------|-------|
-| Brute force | 100% | ❌ Slow | ✅ Minimal | < 100K |
-| KD-Tree | 90-95% | ⚡ Fast | ✅ Low | < 1M (low-dim) |
-| IVF-Flat | 85-98% | ⚡ Fast | ✅ Low | < 100M |
-| HNSW | 95-99% | ⚡⚡ Very fast | ❌ High | < 10M |
-| IVF-HNSW | 90-99% | ⚡⚡ Very fast | ⚡ Moderate | < 100M |
-| IVF-PQ | 80-92% | ⚡ Fast | ⚡⚡ Very low | Billions |
-
----
-
-## 🧪 How to Measure ANN Quality
-
-### Recall@K
-
-The most common metric. For each query, what fraction of the true top-K nearest neighbors did the algorithm find?
-
-```
-recall@10 = (true positives in top-10 results) / 10
-```
-
-A recall@10 of 0.95 means the algorithm found 9.5 out of 10 true nearest neighbors on average.
-
-### QPS (Queries Per Second)
-
-How many searches the system can handle per second. Higher is better.
-
-### Build Time
-
-How long it takes to index all vectors. Matters for systems with frequent updates.
-
----
-
-## 🎓 Key Takeaways
-
-1. **Brute force doesn't scale.** Beyond ~100K vectors, you need an ANN algorithm.
-2. **HNSW is the default choice** for datasets up to 10M vectors — excellent recall with fast search.
-3. **IVF shines at scale** — partitioning is essential for 10M+ vectors.
-4. **Quantization complements ANN** — compress vectors to fit more in memory and scan faster.
-5. **The `nprobe` and `efSearch` parameters** are your recall/speed knobs. Always tune them for your workload.
-6. **Real embeddings have structure** — ANN algorithms perform much better on real data (which forms natural clusters) than on random vectors.
-
----
-
-## 🔗 See Also
-
-- [HNSW Explained](hnsw-explained.md) — How the most popular ANN algorithm works, step by step
-- [SpectorIndex Architecture](spector-index-architecture.md) — Spector's IVF-HNSW-SVASQ hybrid index
-- [SVASQ Quantization](svasq-deep-dive.md) — How SVASQ compresses vectors with near-lossless quality
-- [Understanding Quantization](understanding-quantization.md) — All quantization techniques compared
diff --git a/docs/docs/deep-dives/hnsw-explained.md b/docs/docs/deep-dives/hnsw-explained.md
deleted file mode 100644
index 29f4aab..0000000
--- a/docs/docs/deep-dives/hnsw-explained.md
+++ /dev/null
@@ -1,270 +0,0 @@
-# 🕸️ HNSW Explained
-
-> **How the world's most popular vector search algorithm works, from first principles.** Hierarchical Navigable Small World graphs power vector search in Pinecone, Weaviate, Qdrant, pgvector, and Spector. This page explains HNSW step by step, with intuition, diagrams, and practical tuning advice.
-
----
-
-## 🤔 The Intuition: Six Degrees of Separation
-
-You've probably heard that any two people on Earth are connected by at most six handshakes. This is the **small-world phenomenon** — in certain networks, you can reach any node in surprisingly few hops.
-
-HNSW exploits this same principle for vector search. Instead of comparing your query against every vector, you **navigate a graph** — hopping from neighbor to neighbor, getting closer to the target with each step.
-
-```mermaid
-graph LR
-    Q["🔍 Query"] -->|"hop 1"| A["Node A\n(far)"]
-    A -->|"hop 2"| B["Node B\n(closer)"]
-    B -->|"hop 3"| C["Node C\n(close!)"]
-    C -->|"hop 4"| D["🎯 Node D\n(nearest!)"]
-```
-
-Instead of 10 million comparisons, you make ~100. That's the magic.
-
----
-
-## 📐 From Flat to Hierarchical
-
-### The Problem with a Single Graph
-
-A simple navigable small-world (NSW) graph connects each vector to its nearest neighbors. Search starts at a random entry point and greedily walks toward the query — always moving to the neighbor closest to the target.
-
-This works, but it has a problem: **local minima**. The greedy walk can get stuck in a region that's locally optimal but globally suboptimal.
-
-### The Fix: Add Layers
-
-HNSW solves this with a **hierarchy** — multiple layers of the same graph, each progressively sparser:
-
-```mermaid
-graph TD
-    subgraph "Layer 2 (sparse — highway)"
-        L2A["A"] --- L2D["D"]
-        L2D --- L2G["G"]
-    end
-    
-    subgraph "Layer 1 (medium)"
-        L1A["A"] --- L1B["B"]
-        L1B --- L1D["D"]
-        L1D --- L1F["F"]
-        L1F --- L1G["G"]
-    end
-    
-    subgraph "Layer 0 (dense — all vectors)"
-        L0A["A"] --- L0B["B"]
-        L0B --- L0C["C"]
-        L0C --- L0D["D"]
-        L0D --- L0E["E"]
-        L0E --- L0F["F"]
-        L0F --- L0G["G"]
-        L0A --- L0C
-        L0D --- L0F
-    end
-    
-    L2A -.-> L1A
-    L2D -.-> L1D
-    L2G -.-> L1G
-    L1A -.-> L0A
-    L1B -.-> L0B
-    L1D -.-> L0D
-    L1F -.-> L0F
-    L1G -.-> L0G
-```
-
-Think of it like navigating a city:
-- **Layer 2 (highway):** A few major intersections — long jumps, coarse navigation
-- **Layer 1 (main roads):** More nodes, shorter jumps
-- **Layer 0 (streets):** Every single location — fine-grained search
-
----
-
-## 🔧 How Search Works
-
-### Step 1: Start at the Top
-
-Enter the graph at the top layer's entry point. There are very few nodes here, so you can quickly find which region of the space the query belongs to.
-
-### Step 2: Greedy Descent
-
-At each layer, perform a **greedy search**: repeatedly move to the neighbor closest to the query until no neighbor is closer. Then descend to the next layer, starting from the same node.
-
-### Step 3: Fine-Grained Search at Layer 0
-
-At the bottom layer (which contains all vectors), perform a more thorough search. Instead of pure greedy descent, maintain a **candidate list** of the best nodes seen so far, exploring their neighbors to find even better candidates.
-
-```mermaid
-sequenceDiagram
-    participant Q as 🔍 Query
-    participant L2 as Layer 2
-    participant L1 as Layer 1
-    participant L0 as Layer 0
-
-    Q->>L2: Start at entry point
-    Note over L2: Greedy walk → find region
-    L2->>L1: Descend with best node
-    Note over L1: Greedy walk → refine region
-    L1->>L0: Descend with best node
-    Note over L0: efSearch candidates → precise top-K
-    L0->>Q: Return top-K nearest neighbors
-```
-
-### The `efSearch` Parameter
-
-At layer 0, the algorithm maintains a **dynamic candidate list** of size `efSearch`. Larger `efSearch` = more candidates explored = higher recall but slower search.
-
-| `efSearch` | Recall@10 | Relative Speed |
-|-----------|-----------|---------------|
-| 10 | ~80% | Fastest |
-| 50 | ~95% | Fast |
-| 100 | ~98% | Moderate |
-| 200 | ~99.5% | Slower |
-| 500 | ~99.9% | Slowest |
-
-> [!TIP]
-> Start with `efSearch=64` and increase until you hit your recall target. For most applications, `efSearch=100-200` provides an excellent balance.
-
----
-
-## 🏗️ How Construction Works
-
-Building the HNSW graph is where the algorithm spends most of its time. Each vector is inserted one at a time.
-
-### Step 1: Assign a Random Layer
-
-Each new vector is assigned a maximum layer using an exponential distribution:
-
-```
-layer = floor(-ln(random()) × mL)
-```
-
-Where `mL = 1 / ln(M)` and M is the max connections per node. This ensures:
-- Most vectors (85%) exist only at Layer 0
-- ~12% reach Layer 1
-- ~2% reach Layer 2
-- ~0.2% reach Layer 3
-
-### Step 2: Find Neighbors via Search
-
-To insert a vector, first search the existing graph to find its nearest neighbors (exactly like a query search). The search quality during insertion is controlled by `efConstruction`.
-
-### Step 3: Connect to Neighbors
-
-Connect the new vector to its `M` nearest neighbors at each layer it belongs to. Also add reverse connections (the graph is bidirectional).
-
-### The `efConstruction` Parameter
-
-Higher `efConstruction` = better neighbor selection during build = higher-quality graph = better recall at search time. But it also means slower insertion.
-
-| `efConstruction` | Build Speed | Graph Quality | Recall@10 |
-|-----------------|------------|--------------|-----------|
-| 16 | ⚡⚡ Fast | Low | ~85% |
-| 100 | ⚡ Moderate | Good | ~95% |
-| 200 | 🐌 Slow | High | ~98% |
-| 500 | 🐌🐌 Very slow | Very high | ~99% |
-
-### The `M` Parameter (Max Connections)
-
-`M` controls how many edges each node has. More connections = more paths to explore = better recall, but more memory.
-
-| M | Memory per vector | Recall impact |
-|---|-------------------|---------------|
-| 8 | Low | Good for low-dim (< 64) |
-| **16** | **Moderate** | **Default — good for most cases** |
-| 32 | High | Better for high-dim (768+) |
-| 64 | Very high | Diminishing returns |
-
-> [!IMPORTANT]
-> The construction parameters `efConstruction` and `M` are permanent — they determine the graph structure. You can adjust `efSearch` at query time without rebuilding.
-
----
-
-## 🧮 Complexity Analysis
-
-| Operation | Time Complexity | Why |
-|-----------|----------------|-----|
-| **Search** | O(log n) | Each layer halves the search space |
-| **Insert** | O(log n) | Same as search + edge updates |
-| **Memory** | O(n × M) | Each vector stores M edges per layer |
-
-For reference, with 1 million 768-dim vectors and M=16:
-- **Search:** ~100-200 distance computations (vs 1,000,000 for brute force)
-- **Memory:** ~12 bytes per edge × 16 edges × 1M vectors ≈ **192 MB** (just for edges, plus the vectors themselves)
-
----
-
-## ⚡ Why HNSW Is Fast
-
-Three factors combine to make HNSW remarkably efficient:
-
-### 1. Logarithmic Hops
-
-The hierarchical structure means you traverse O(log n) layers, each requiring a small number of greedy steps. For 1M vectors, that's ~6-8 layers with ~10 steps each = ~70 distance computations.
-
-### 2. Locality
-
-As you descend layers, you converge on a small region of the space. At layer 0, you're only exploring a local neighborhood — excellent CPU cache behavior.
-
-### 3. SIMD Acceleration
-
-Each distance computation (L2, cosine, dot product) can be parallelized using SIMD instructions. Spector uses the Java Vector API to compute 8-16 dimensions simultaneously:
-
-```java
-// 8 dimensions computed in a single CPU instruction
-FloatVector va = FloatVector.fromArray(SPECIES, a, offset);
-FloatVector vb = FloatVector.fromArray(SPECIES, b, offset);
-FloatVector diff = va.sub(vb);
-sum = diff.fma(diff, sum);  // sum += diff * diff
-```
-
----
-
-## 🚫 HNSW's Limitations
-
-HNSW is excellent, but it's not perfect:
-
-### 1. Memory Hungry
-
-The graph edges consume significant memory — roughly 50-100% of the vector storage. This limits HNSW to datasets that fit in RAM.
-
-### 2. Slow Construction
-
-Building the graph requires O(n log n) total work. Inserting 1M vectors at `efConstruction=200` can take minutes. At 10M+, construction time becomes a serious concern.
-
-### 3. No Deletion (Efficiently)
-
-Removing vectors from an HNSW graph is tricky — you need to rewire edges, which can degrade graph quality over time.
-
-### 4. Doesn't Scale Beyond ~10M
-
-At 10M+ vectors, HNSW's memory consumption and construction time make it impractical as a standalone index. This is why hybrid approaches (like IVF-HNSW) are preferred at scale.
-
----
-
-## 🔬 HNSW in Spector
-
-Spector uses HNSW in two contexts:
-
-### 1. Standalone HNSW Index
-
-The `QuantizedHnswIndex` is the workhorse for datasets up to ~10M vectors. It combines HNSW with scalar or SVASQ quantization:
-
-- **Asymmetric Distance Computation (ADC):** Float32 query vs. quantized stored vectors
-- **Off-heap memory:** Graph edges and quantized vectors stored in Panama `MemorySegment`
-- **SIMD kernels:** Java Vector API for distance computation
-
-### 2. Adaptive Shards in SpectorIndex
-
-The flagship `SpectorIndex` (IVF-HNSW-SVASQ) uses HNSW graphs inside large IVF shards:
-
-- Shards below 20,000 vectors: exact flat scan (SIMD, faster than HNSW for small N)
-- Shards above 20,000 vectors: automatically promoted to HNSW with SVASQ quantization
-- This **adaptive** approach avoids HNSW's overhead for small partitions while exploiting its efficiency for large ones
-
-See [SpectorIndex Architecture](spector-index-architecture.md) for the full design.
-
----
-
-## 📖 Further Reading
-
-- **Original Paper:** Malkov & Yashunin, ["Efficient and robust approximate nearest neighbor using Hierarchical Navigable Small World graphs"](https://arxiv.org/abs/1603.09320) (2016)
-- [ANN Search Primer](ann-search-primer.md) — Overview of all ANN algorithm families
-- [SpectorIndex Architecture](spector-index-architecture.md) — How HNSW fits into the IVF-HNSW-SVASQ design
-- [Performance Tuning](../operations/performance-tuning.md) — Tuning `M`, `efConstruction`, and `efSearch` in Spector
diff --git a/docs/docs/deep-dives/quantization-comparison.md b/docs/docs/deep-dives/quantization-comparison.md
deleted file mode 100644
index 009ce38..0000000
--- a/docs/docs/deep-dives/quantization-comparison.md
+++ /dev/null
@@ -1,266 +0,0 @@
-# ⚖️ Quantization Comparison
-
-> **How different search engines approach vector compression — and why they make different choices.** Architecture constraints, legacy decisions, and design philosophy all shape which quantization methods an engine supports.
-
----
-
-## 🌍 The Quantization Landscape
-
-Every vector search engine faces the same fundamental problem: vectors are too big to fit in memory at scale. But each engine solves it differently based on their architecture:
-
-| Constraint | Impact on Quantization Choice |
-|-----------|-------------------------------|
-| Immutable segments (Lucene) | Makes IVF training/updating difficult |
-| Embedded vs. distributed | Affects whether training is practical |
-| GPU availability | Enables larger codebook training |
-| Disk vs. memory architecture | Changes what "compression" means |
-
-> [!NOTE]
-> There is no universally "best" quantization method. The right choice depends on your recall requirements, memory budget, dataset size, and which engine you're already using.
-
----
-
-## 🟡 Elasticsearch's Approach: BBQ + DiskBBQ
-
-### What is BBQ (Better Binary Quantization)?
-
-BBQ is Elasticsearch's answer to vector compression, introduced in version 8.16. It's a **1-bit quantization** method — each float32 dimension becomes a single bit — enhanced with asymmetric rescoring to recover lost accuracy.
-
-**How BBQ works:**
-1. **Quantize:** Convert each vector to binary (sign bit extraction) — 32× compression
-2. **Store metadata:** Keep per-vector correction factors (norm, mean)
-3. **First-pass search:** Use Hamming distance on binary codes (very fast)
-4. **Rescore:** Re-rank top candidates using stored correction factors for better accuracy
-
-```mermaid
-graph TD
-    Q["Query"] --> Binary["Binary Hamming Search<br/>32x compressed, fast scan"]
-    Binary --> Candidates["Top 100 candidates"]
-    Candidates --> Rescore["Asymmetric Rescoring<br/>Uses stored correction factors"]
-    Rescore --> Final["Top 10 final results<br/>~90% recall"]
-```
-
-### Why Elasticsearch Chose Binary Over PQ
-
-Elasticsearch is built on **Apache Lucene**, which uses an **immutable segment** architecture:
-
-- Segments are write-once, read-many
-
-- Merging combines segments but doesn't update in place
-
-- New data goes to new segments
-
-This makes IVF-PQ challenging because:
-
-- **IVF centroids** need to be computed across all data — hard when data arrives in segments
-
-- **PQ codebooks** need training on representative data — segment-local training produces poor codebooks
-
-- **Partition rebalancing** on merge is expensive
-
-Binary quantization, by contrast, is **per-vector** — no global training needed, works perfectly with immutable segments.
-
-> [!TIP]
-> BBQ is clever engineering within Lucene's constraints. The rescoring step recovers much of the recall lost by binary compression, achieving ~90% recall@10 for high-dimensional embeddings (768+).
-
-### What is DiskBBQ?
-
-DiskBBQ (introduced experimentally) adds IVF-like partitioning on top of BBQ:
-
-- Vectors are grouped into clusters (similar to IVF)
-
-- Only relevant clusters are loaded from disk during search
-
-- Designed to work within Lucene's segment model by treating clusters as segment-local structures
-
-**Trade-off:** More complex than plain BBQ, but enables disk-resident indexes for datasets that exceed RAM.
-
----
-
-## 🔵 Spector's Approach: Scalar + SVASQ + SVASQ-4 + IVF-PQ
-
-### Why These Two?
-
-Spector is a **purpose-built vector engine** — no segment model, no legacy constraints. This gives freedom to implement whatever quantization works best for the use case.
-
-The two-method strategy covers the full spectrum:
-
-| Need | Solution | Compression | Recall |
-|------|----------|-------------|--------|
-| Quality-first (≤50M vectors) | Scalar INT8 | 4× | 95–99% |
-| Quality + rotation (≤50M) | **SVASQ INT8** | 4× | **97–99.5%** |
-| Balanced (10M–100M vectors) | Scalar INT4 | 8× | 85–95% |
-| Balanced + rotation (10M–100M) | **SVASQ-4** | **6–8×** | **95–99%** |
-| Memory-constrained (50M–500M) | Scalar INT2 | 16× | 75–90% |
-| Scale-first (100M–1B+ vectors) | IVF-PQ | 32× | 75–90% |
-
-### Advantages of Purpose-Built Indexes
-
-Without Lucene's segment model:
-
-- **Global IVF training** — K-Means runs over the entire dataset, producing optimal partitions
-
-- **Codebook updates** — Retrain when data distribution shifts significantly
-
-- **Partition rebalancing** — Redistribute vectors across partitions as the index grows
-
-- **Memory-mapped storage** — Custom binary format designed for quantized data layout
-
-```mermaid
-graph LR
-    subgraph "Elasticsearch (Segment Model)"
-        Seg1["Segment 1<br/>BBQ binary codes"]
-        Seg2["Segment 2<br/>BBQ binary codes"]
-        Seg3["Segment 3<br/>BBQ binary codes"]
-    end
-    
-    subgraph "Spector (Global Index)"
-        IVF["IVF Partitions<br/>Globally optimized"]
-        PQ["PQ Codebooks<br/>Trained on all data"]
-        IVF --> PQ
-    end
-```
-
-### IVF-PQ vs. BBQ at Same Compression (32×)
-
-| Metric | Spector IVF-PQ | Elasticsearch BBQ |
-|--------|---------------|-------------------|
-| Compression | 32× | 32× |
-| Recall@10 (384-dim) | 80–92% | 70–85% |
-| Recall@10 (768-dim) | 85–95% | 85–92% |
-| Training required | Yes (K-Means + PQ) | No (per-vector) |
-| Works with segments | No (global index) | Yes |
-| Disk-friendly | Via mmap | Via DiskBBQ |
-
-> [!IMPORTANT]
-> At the same 32× compression ratio, PQ preserves more information than binary because it learns the data distribution. Binary quantization discards magnitude entirely — only direction (sign) survives.
-
----
-
-## 🟣 Other Approaches
-
-### Milvus: IVF-PQ + IVF-SQ8 + DiskANN
-
-Milvus offers the widest quantization menu:
-
-| Method | Compression | Use Case |
-|--------|-------------|----------|
-| IVF-PQ | 32×+ | Billion-scale, memory-constrained |
-| IVF-SQ8 | 4× | Moderate scale, high recall |
-| DiskANN | Varies | Disk-resident billion-scale search |
-| HNSW | None (full) | Highest recall, unlimited memory |
-
-**Philosophy:** Give users every option and let them choose. This flexibility comes with complexity — users must understand trade-offs to configure correctly.
-
-### Qdrant: Scalar + Binary + Oversampling
-
-Qdrant takes a practical approach:
-
-| Method | Details |
-|--------|---------|
-| Scalar INT8 | Standard 4× compression, applied per-segment |
-| Binary | 32× with configurable oversampling for rescoring |
-| Oversampling | Retrieve 3–5× more candidates, rescore with full vectors |
-
-**Key innovation:** Qdrant's oversampling strategy is straightforward but effective. Retrieve more candidates with cheap binary search, then rescore the shortlist with full-precision vectors. Recall depends on oversampling factor.
-
-### FAISS: The Research Gold Standard
-
-Meta's FAISS library is the reference implementation for quantization research:
-
-| Method | Description |
-|--------|-------------|
-| IVF-PQ | The classic — inverted file + product quantization |
-| OPQ | Optimized PQ — rotates data before splitting to minimize quantization error |
-| IVFADC | IVF with Asymmetric Distance Computation |
-| IVF-PQ + Refine | Two-stage: PQ shortlist → full-precision rescore |
-| ScaNN | Anisotropic quantization (prioritizes angular error) |
-| Binary (LSH) | Locality-Sensitive Hashing for binary codes |
-
-> [!NOTE]
-> FAISS isn't a search engine — it's a library. Most production vector databases (including Milvus) build on FAISS's algorithms internally.
-
----
-
-## 🧭 Decision Guide
-
-Use this flowchart to pick the right quantization for your workload:
-
-```mermaid
-flowchart TD
-    Start["How many vectors?"] --> Small["< 10M vectors"]
-    Start --> Medium["10M - 100M vectors"]
-    Start --> Large["> 100M vectors"]
-    
-    Small --> SmallRecall["Recall requirement?"]
-    SmallRecall --> SmallHigh["> 95% recall"]
-    SmallRecall --> SmallMod["80-95% recall"]
-    SmallHigh --> A["Use: No quantization or Scalar INT8"]
-    SmallMod --> B["Use: Scalar INT8"]
-    
-    Medium --> MedMem["Memory budget?"]
-    MedMem --> MedHigh["> 64 GB available"]
-    MedMem --> MedLow["< 64 GB available"]
-    MedHigh --> C["Use: Scalar INT8"]
-    MedLow --> D["Use: IVF-PQ (32x)"]
-    
-    Large --> LargeRecall["Recall requirement?"]
-    LargeRecall --> LargeHigh["> 90% recall"]
-    LargeRecall --> LargeMod["75-90% recall"]
-    LargeRecall --> LargeLow["< 75% acceptable"]
-    LargeHigh --> E["Use: IVF-PQ + Rescore"]
-    LargeMod --> F["Use: IVF-PQ"]
-    LargeLow --> G["Use: Binary + Rescore"]
-```
-
-### Quick Rules of Thumb
-
-| Situation | Recommendation |
-|-----------|---------------|
-| "I need maximum recall" | No quantization or Scalar INT8 |
-| "I want balanced compression/recall" | Scalar INT4 + rescore (8×, 85–95%) |
-| "I need to fit in a single machine" | Scalar INT2 (16×) or IVF-PQ (32×) |
-| "I need the fastest possible filtering" | Scalar INT2 as first pass + rescore |
-| "I'm using Elasticsearch" | BBQ (it's your best option there) |
-| "I'm building from scratch" | INT4 for moderate scale, IVF-PQ for billions |
-| "I don't want training complexity" | Scalar INT8 or INT4 (calibration is automatic) |
-
----
-
-## 📊 Summary Table
-
-Which quantization methods are available in each engine:
-
-| Engine | Scalar INT8 | Scalar INT4/INT2 | Binary | Product Quantization | IVF-PQ | DiskANN | Rescoring |
-|--------|:-----------:|:----------------:|:------:|:-------------------:|:------:|:-------:|:---------:|
-| **Spector** | ✅ | ✅ (non-uniform) | ❌ | ✅ (via IVF-PQ) | ✅ | ❌ | ✅ (SVASQ/SVASQ-4 + configurable oversampling) |
-| **Elasticsearch** | ✅ | ❌ | ✅ (BBQ) | ❌ | ❌ | ❌ | ✅ (asymmetric) |
-| **Milvus** | ✅ (IVF-SQ8) | ❌ | ❌ | ✅ | ✅ | ✅ | ✅ |
-| **Qdrant** | ✅ | ❌ | ✅ | ❌ | ❌ | ❌ | ✅ (oversampling) |
-| **FAISS** | ✅ | ❌ | ✅ (LSH) | ✅ | ✅ | ❌ | ✅ |
-| **Weaviate** | ✅ | ❌ | ✅ | ✅ | ❌ | ❌ | ✅ |
-
-### Compression × Recall Trade-off by Engine
-
-| Engine | 4× (Scalar) Recall | 8× (INT4) Recall | 16× (INT2) Recall | 32× (Best Method) Recall | Architecture Constraint |
-|--------|:------------------:|:-----------------:|:------------------:|:------------------------:|------------------------|
-| **Spector** | 97–99.5% (SVASQ) | 95–99% (SVASQ-4+rescore) | 75–90% (INT2+rescore) | 80–92% (IVF-PQ) | None (purpose-built) |
-| **Elasticsearch** | 95–99% | — | — | 70–90% (BBQ + rescore) | Lucene segments |
-| **Milvus** | 95–99% | — | — | 80–92% (IVF-PQ) | Distributed complexity |
-| **Qdrant** | 95–99% | — | — | 65–85% (Binary + oversample) | Per-segment quantization |
-| **FAISS** | 95–99% | — | — | 85–95% (OPQ) | Library, not engine |
-
-> [!TIP]
-> FAISS achieves the highest PQ recall because OPQ (Optimized Product Quantization) rotates the vector space before splitting into subspaces, minimizing quantization error. This is computationally expensive during training but pays off at query time.
-
----
-
-## 🔗 See Also
-
-- [Understanding Quantization](understanding-quantization.md) — Quantization from first principles
-
-- [Core Concepts](../architecture/core-concepts.md) — HNSW, IVF-PQ, BM25, and SIMD fundamentals
-
-- [Performance Tuning](../operations/performance-tuning.md) — How to tune nprobe, subspaces, and other parameters
-
-- [Architecture Overview](../architecture/overview.md) — How Spector's storage layer is designed
\ No newline at end of file
diff --git a/docs/docs/deep-dives/real-embedding-benchmarks.md b/docs/docs/deep-dives/real-embedding-benchmarks.md
deleted file mode 100644
index a24f09d..0000000
--- a/docs/docs/deep-dives/real-embedding-benchmarks.md
+++ /dev/null
@@ -1,147 +0,0 @@
-# 📊 Large-Scale Real-Embedding & Shard Promotion Benchmarks
-
-This page presents the exhaustive experimental results and performance characteristics of **SpectorIndex (IVF-HNSW-SVASQ)**. 
-
-To evaluate the system under realistic production workloads, we benchmarked the index using high-dimensional text embeddings from real-world datasets rather than synthetic structureless Gaussian noise. Additionally, we analyzed the performance and recall characteristics of our adaptive shard promotion system at a scale of 100,000 vectors.
-
----
-
-## 🔬 Experimental Setup & System Context
-
-All tests were performed locally under standard, repeatable conditions to isolate CPU and JVM execution metrics:
-
-- **Hardware:** 24-core Intel Core Ultra 9 285K, AVX2 256-bit SIMD instruction extensions.
-- **Runtime Environment:** Java 25 (OpenJDK 25.0.1), garbage collection managed via the ZGC (Z Garbage Collector), 12GB allocated heap (`-Xmx12g`).
-- **Core Optimization:** Panama Vector API (`jdk.incubator.vector`) enabled via JVM arguments to compile hardware-native SIMD instructions on the fly.
-- **Embedding Model:** `qwen3-embedding` (4,096 dimensions) via a local GPU-accelerated Ollama inference runner.
-- **Dataset (Real-Embedding):** 10,000 diverse sentences sampled from 8 distinct semantic topic categories (quantum mechanics, biotechnology, economics, history, creative arts, cybersecurity, environmental policy, medicine).
-- **Queries:** 100 fresh, out-of-distribution sentences sampled from the same topic categories.
-- **Ground Truth:** Absolute exact $L2^2$ brute-force top-10 neighbors computed on uncompressed float32 vectors.
-
----
-
-## 📈 Part 1: Real-Embedding Sweep (4096-dim Qwen3)
-
-Real-world transformer embeddings naturally cluster into distinct, low-dimensional manifolds. Sentences about quantum mechanics group together; sentences about macroeconomics form another group. SpectorIndex exploits this structured geometry, yielding **near-perfect recall at fraction-of-a-percent partition scans**.
-
-The sweeps evaluate different `nCentroids` (IVF Voronoi cells) and `nProbe` depths. All measurements represent average search latency and QPS over 500 query iterations.
-
-### 1. nCentroids = 32
-Vectors are divided into 32 cells (average ~312 vectors per partition).
-
-| nProbe | % of Index Searched | Avg Latency | p50 (Median) | p99 (Worst Case) | Throughput (QPS) | Recall@10 | Ingest Latency |
-| :--- | :--- | :--- | :--- | :--- | :--- | :--- | :--- |
-| **4** | 12.5% | 1.167 ms | 1.094 ms | 1.828 ms | **857** | **1.0000** | 555 ms (18,018/s) |
-| **8** | 25.0% | 2.237 ms | 2.236 ms | 2.957 ms | **447** | **1.0000** | 541 ms |
-| **16** | 50.0% | 4.560 ms | 4.567 ms | 5.443 ms | **219** | **1.0000** | 550 ms |
-| **32** | 100.0% | 7.767 ms | 7.781 ms | 8.426 ms | **129** | **1.0000** | 554 ms |
-
----
-
-### 2. nCentroids = 64
-Vectors are divided into 64 cells (average ~156 vectors per partition).
-
-| nProbe | % of Index Searched | Avg Latency | p50 (Median) | p99 (Worst Case) | Throughput (QPS) | Recall@10 | Ingest Latency |
-| :--- | :--- | :--- | :--- | :--- | :--- | :--- | :--- |
-| **4** | 6.3% | 0.624 ms | 0.625 ms | 0.923 ms | **1,601** | **1.0000** | 1,012 ms (9,881/s) |
-| **8** | 12.5% | 1.168 ms | 1.141 ms | 1.592 ms | **856** | **1.0000** | 1,007 ms |
-| **16** | 25.0% | 2.198 ms | 2.233 ms | 2.805 ms | **455** | **1.0000** | 1,007 ms |
-| **32** | 50.0% | 4.439 ms | 4.502 ms | 5.118 ms | **225** | **1.0000** | 1,006 ms |
-| **64** | 100.0% | 7.921 ms | 7.893 ms | 8.828 ms | **126** | **1.0000** | 1,003 ms |
-
----
-
-### 3. nCentroids = 128
-Vectors are divided into 128 cells (average ~78 vectors per partition).
-
-| nProbe | % of Index Searched | Avg Latency | p50 (Median) | p99 (Worst Case) | Throughput (QPS) | Recall@10 | Ingest Latency |
-| :--- | :--- | :--- | :--- | :--- | :--- | :--- | :--- |
-| **4** | **3.1%** | **0.455 ms** | **0.443 ms** | **0.651 ms** | **2,198** | **0.9980** | 1,965 ms (5,089/s) |
-| **8** | **6.3%** | **0.751 ms** | **0.719 ms** | **1.100 ms** | **1,332** | **0.9990** | 1,960 ms |
-| **16** | 12.5% | 1.218 ms | 1.152 ms | 1.753 ms | **821** | **1.0000** | 1,970 ms |
-| **32** | 25.0% | 2.298 ms | 2.273 ms | 2.856 ms | **435** | **1.0000** | 1,964 ms |
-| **64** | 50.0% | 4.475 ms | 4.455 ms | 5.177 ms | **223** | **1.0000** | 1,965 ms |
-
----
-
-### 4. nCentroids = 256
-Vectors are divided into 256 cells (average ~39 vectors per partition).
-
-| nProbe | % of Index Searched | Avg Latency | p50 (Median) | p99 (Worst Case) | Throughput (QPS) | Recall@10 | Ingest Latency |
-| :--- | :--- | :--- | :--- | :--- | :--- | :--- | :--- |
-| **4** | **1.56%** | **0.538 ms** | **0.535 ms** | **0.642 ms** | **1,857** | **0.9950** | 3,873 ms (2,582/s) |
-| **8** | **3.13%** | **0.690 ms** | **0.676 ms** | **0.997 ms** | **1,450** | **1.0000** | 3,986 ms |
-| **16** | 6.25% | 0.957 ms | 0.942 ms | 1.218 ms | **1,045** | **1.0000** | 3,874 ms |
-| **32** | 12.50% | 1.468 ms | 1.425 ms | 1.879 ms | **681** | **1.0000** | 3,881 ms |
-| **64** | 25.00% | 2.872 ms | 2.836 ms | 3.552 ms | **348** | **1.0000** | 3,897 ms |
-
-> [!NOTE]
-> *Note on nCentroids=256 sweeps:* The data for `nProbe=64` represents a highly comprehensive coverage of large-partition lookups. The 256 centroid partition sweeps show that searching less than **1.6% of the clusters** (nProbe=4) still yields **99.5% recall** at an incredibly low latency of **0.538ms**.
-
----
-
-### 💡 Structural Recall Analysis: Synthetic vs. Real Data
-
-The outstanding recall achieved on real text embeddings (99.5% - 100.0% even at highly aggressive probes) highlights a fundamental math concept: **synthetic high-dimensional vectors are a poor model for real-world embeddings.**
-
-Synthetic high-dimensional data (like random Gaussian distributions) spreads uniformly across the entire hypersphere. There is no topic coherence, no clusters, and no structure. As a result, the true nearest neighbors of a random vector are randomly scattered across the Voronoi partitions of the index, requiring an exhaustive search (`nProbe = ALL`) to get reasonable recall.
-
-In contrast, real embeddings (e.g., Sentence-BERT, CLIP, Qwen) occupy a much smaller semantic manifold. Vectors corresponding to similar concepts occupy the same spatial coordinate subspaces. The coarse K-Means centroids learn these clusters precisely. As a result, the nearest neighbors of a query sentence are mathematically guaranteed to reside in the exact same Voronoi cells or adjacent cells—achieving perfect search quality at extremely low probe depths.
-
-| Metric | Random Gaussian (128-dim) | Real Qwen3 (4096-dim) |
-| :--- | :--- | :--- |
-| **Recall@10 (nCentroids=128, nProbe=4)** | 23.40% | **99.80%** (4.3× increase) |
-| **Recall@10 (nCentroids=128, nProbe=8)** | 38.20% | **99.90%** (2.6× increase) |
-| **Recall@10 (nCentroids=128, nProbe=32)** | 59.20% | **1.0000** (1.7× increase) |
-
----
-
-## ⚡ Part 2: Shard Promotion Benchmark (100K Scale)
-
-To evaluate HNSW promotions at scale, we conducted a benchmark at 100,000 vectors comparing exhaustive **Flat Shard mode** (linear SIMD scan over float32 residuals) vs **Promoted HNSW Shard mode** (pre-calibrated 132-bit SVASQ quantized HNSW graph search inside each centroid's shard). 
-
-A total of 32 coarse centroids were used, resulting in an average of 3,125 vectors per shard. The promotion threshold `shardThreshold` was configured to `1,000`, ensuring all 32 partitions promoted to HNSW graphs during ingestion.
-
-### Performance Summary (100K, 128-dim vectors)
-
-| nProbe | Mode | Avg Latency | p50 (Median) | p99 (Worst Case) | Throughput (QPS) | Recall@10 | Ingestion Rate |
-| :--- | :--- | :--- | :--- | :--- | :--- | :--- | :--- |
-| **4** | Flat | 0.388 ms | 0.383 ms | 0.671 ms | **2,580** | 0.3260 | 632,911 docs/s |
-| **4** | HNSW | 0.418 ms | 0.362 ms | 0.962 ms | **2,392** | 0.3230 | 7,638 docs/s |
-| **8** | Flat | 0.717 ms | 0.709 ms | 0.953 ms | **1,394** | 0.5350 | 632,911 docs/s |
-| **8** | HNSW | 0.722 ms | 0.694 ms | 1.208 ms | **1,386** | 0.5280 | 7,638 docs/s |
-| **16** | Flat | 1.462 ms | 1.462 ms | 1.704 ms | **684** | 0.7760 | 632,911 docs/s |
-| **16** | HNSW | 1.719 ms | 1.541 ms | 3.716 ms | **582** | 0.7670 | 7,638 docs/s |
-| **32** | Flat | 3.111 ms | 3.077 ms | 3.787 ms | **321** | **1.0000** | 632,911 docs/s |
-| **32** | HNSW | **2.892 ms** | **2.724 ms** | **4.934 ms** | **346** | **0.9870** | 7,638 docs/s |
-
-### 🛠️ Shard Promotion Analysis
-
-#### 1. Recall Equivalence
-The promoted HNSW shards achieve **almost identical recall** to the exhaustive float32 Flat Shards (e.g., `0.9870` HNSW vs `1.0000` Flat at `nProbe = 32`). This confirms that:
-- The translation of internal HNSW contiguous graph node indices (`nodeIdx`) to external global `storeIndex` values is correct.
-- Forcing `SimilarityFunction.EUCLIDEAN` for all residual operations inside the promoted HNSW index prevents mathematical similarity mismatches with the IVF boundaries.
-
-#### 2. Trade-Off: Ingestion vs. Search Speed
-- **Ingestion:** Flat Shards ingest at an astronomical **632K docs/sec** because adding a vector requires only subtracting the centroid and appending to a float32 array. Quantized HNSW construction ingests at **7.6K docs/sec** because it performs O(N log N) graph traversals and builds indexing structures on heap.
-- **Shallow Searches (nProbe <= 16):** Flat Shard mode remains slightly faster for small queries. Contiguous SIMD memory scans have zero graph traversal or pointer-chasing overhead, and the hardware prefetcher is highly efficient at low sizes.
-- **Deep Searches (nProbe = 32):** Promoted HNSW Shards win at deep lookups (where all centroids are searched), achieving **346 QPS** (2.89ms) vs. **321 QPS** (3.11ms) for Flat mode. As the search space increases, the graph's logarithmic traversal complexity bypasses exhaustive scans.
-
----
-
-## 🛠️ Tuning Recommendations for SpectorIndex
-
-Based on the empirical sweeps above, we recommend the following tuning strategies:
-
-1. **Centroid Count Scaling:** Maintain $C \approx \sqrt{N}$ (e.g., 128 centroids for 10K–50K vectors, 512 centroids for 1M vectors) to balance coarse routing costs and partition sizing.
-2. **Real-world Query Probe:** Set `nProbe` between **8 and 16** for real embedding workloads. Unlike synthetic data where nProbe must be large, real embeddings achieve 99.9% - 100% recall with `nProbe = 8`, which cuts search latency and doubles query throughput.
-3. **Adaptive Promotion Boundary:** Use `shardThreshold = 10_000` to promote shards to HNSW. At sizes below 10,000 vectors, contiguous SIMD scans over residuals remain faster than graph traversal.
-
----
-
-## 🔗 Related Pages
-
-- [SVASQ Deep Dive](svasq-deep-dive.md) — The mathematics behind FWHT and affine quantization.
-- [SpectorIndex Architecture](spector-index-architecture.md) — The multi-level adaptive IVF-HNSW shard strategy.
-- [Spector + SVASQ Whitepaper](svasq-spectorindex-whitepaper.md) — Formal academic whitepaper detailing Spector's mathematical properties.
-- [Performance Tuning Guide](../operations/performance-tuning.md) — Fine-tuning system, SIMD, and index settings.
diff --git a/docs/docs/deep-dives/spector-index-architecture.md b/docs/docs/deep-dives/spector-index-architecture.md
deleted file mode 100644
index 9e9a3e5..0000000
--- a/docs/docs/deep-dives/spector-index-architecture.md
+++ /dev/null
@@ -1,280 +0,0 @@
-# 🏛️ SpectorIndex: IVF-HNSW-SVASQ Architecture
-
-> **The flagship adaptive vector index of the Spector search engine.** SpectorIndex combines Inverted File partitioning, Hierarchical Navigable Small World graphs, and SVASQ residual quantization into a single index that scales from 10K to millions of vectors with excellent recall, fast ingestion, and minimal memory.
-
----
-
-## 🎯 Design Goals
-
-SpectorIndex was designed to solve the fundamental limitations of standalone HNSW:
-
-| Problem with HNSW | SpectorIndex Solution |
-|-------------------|-----------------------|
-| Slow ingestion (O(n log n)) | IVF partitioning + flat buffer → **100K+ docs/s** |
-| High memory (graph edges) | SVASQ INT8 residuals → **4× compression** |
-| Doesn't scale past ~10M | IVF coarse search → only probe relevant partitions |
-| No compression | SVASQ with FWHT → near-lossless INT8 |
-
----
-
-## 🏗️ Three-Layer Architecture
-
-SpectorIndex combines three orthogonal techniques:
-
-```mermaid
-graph TD
-    subgraph "Layer 1: IVF — Coarse Partitioning"
-        Q["🔍 Query"] --> KM["K-Means\nFind nProbe\nclosest centroids"]
-        KM --> S1["Shard 1"]
-        KM --> S2["Shard 2"]
-        KM --> S3["Shard N"]
-    end
-    
-    subgraph "Layer 2: Adaptive Shards"
-        S1 --> F1["< 20K vectors:\nExact Flat Scan\n(SIMD, zero GC)"]
-        S2 --> H1["≥ 20K vectors:\nLocal HNSW Graph\n(SVASQ-quantized)"]
-        S3 --> F2["< 20K vectors:\nExact Flat Scan"]
-    end
-    
-    subgraph "Layer 3: SVASQ Residual Quantization"
-        H1 --> V1["Residual: r = x - centroid\nFWHT rotation → INT8\n4× compression"]
-    end
-    
-    F1 --> M["Global Merge\n(L2 distance, top-K)"]
-    H1 --> M
-    F2 --> M
-    M --> R["🎯 Results"]
-```
-
-### Layer 1: IVF (Inverted File)
-
-K-Means clustering partitions the vector space into `nCentroids` Voronoi cells. At query time, only the `nProbe` closest cells are searched, reducing the effective search space by `nCentroids / nProbe`.
-
-### Layer 2: Adaptive Shards
-
-Each Voronoi cell contains a **SpectorShard** — an adaptive data structure that operates in one of two modes:
-
-- **Flat mode** (size < `shardThreshold`): Stores float32 residuals in a contiguous buffer. Search is an exact SIMD scan — faster than HNSW for small partitions because there's no pointer-chasing overhead.
-- **HNSW mode** (size ≥ `shardThreshold`): A local SVASQ-quantized HNSW graph. The flat buffer is consumed during promotion and released to free heap memory.
-
-### Layer 3: SVASQ Residual Quantization
-
-Vectors are stored as **residuals** (`r = x − centroid`), then compressed with SVASQ:
-1. Apply FWHT (Fast Walsh-Hadamard Transform) to spread variance
-2. Quantize to INT8 with calibrated min/max per dimension
-3. Store: `[4-byte L2 norm | D bytes of INT8 codes]`
-
----
-
-## 🔄 Lifecycle
-
-### Phase 1: Training
-
-```java
-SpectorIndex index = SpectorIndex.builder()
-    .dimensions(768)
-    .nCentroids(256)
-    .nProbe(16)
-    .shardThreshold(20_000)
-    .build();
-
-index.train(representativeVectors);  // K-Means++ → learn centroids
-```
-
-Training runs K-Means++ on a representative sample to learn `nCentroids` centroids. This is a one-time operation (typically < 10 seconds for 50K training vectors).
-
-### Phase 2: Ingestion
-
-```java
-index.add("doc-1", 0, vector);  // ~100K-250K docs/s
-```
-
-For each vector:
-1. Find nearest centroid (`KMeans.nearestCentroid`)
-2. Compute residual: `r = vector - centroid`
-3. Store in the centroid's shard (flat buffer, no graph construction)
-4. If shard crosses threshold → automatic promotion to HNSW
-
-### Phase 3: Search
-
-```java
-ScoredResult[] results = index.search(queryVector, 10);
-```
-
-1. Find `nProbe` closest centroids to query
-2. For each probed centroid: compute residual query `q_res = query - centroid`
-3. Search each shard with its residual query
-4. **Global merge** using L2 distance (translation-invariant)
-5. Return top-K
-
----
-
-## 🔑 Critical Design Decision: L2 for Residual Search
-
-This is the most important architectural decision in SpectorIndex, and getting it wrong destroys recall.
-
-### The Problem
-
-When searching across multiple shards, each shard returns results with scores computed in its own **translated coordinate system** (centered at its centroid). If you use **cosine similarity** on residuals, scores from different shards are **not comparable**:
-
-```
-Shard A (centroid c_A):  cosine(q - c_A, x - c_A)  → angle in c_A's space
-Shard B (centroid c_B):  cosine(q - c_B, y - c_B)  → angle in c_B's space
-```
-
-A score of 0.95 from shard A and 0.93 from shard B might not reflect their true relative similarity to the query.
-
-### The Solution
-
-**L2 distance is translation-invariant:**
-
-$$\|(q - c) - (x - c)\|^2 = \|q - x\|^2$$
-
-The centroid cancels out! So L2 on residuals gives the **exact same distance** as L2 on original vectors, regardless of which centroid's shard the vector resides in. This makes cross-shard scores directly comparable.
-
-> [!IMPORTANT]
-> SpectorIndex always uses **EUCLIDEAN distance** internally for residual search and global merge, regardless of the user's configured `similarityFunction`. The user's metric is used only for centroid routing (where it operates in absolute space). This is the same approach used by FAISS's `IndexIVFFlat`.
-
-### Mathematical Proof
-
-For any two vectors $q, x$ and any centroid $c$:
-
-$$\|(q - c) - (x - c)\|^2 = \sum_i ((q_i - c_i) - (x_i - c_i))^2 = \sum_i (q_i - x_i)^2 = \|q - x\|^2$$
-
-This identity holds exactly in floating-point arithmetic (the centroid terms cancel algebraically before any rounding).
-
----
-
-## 🏎️ Performance Characteristics
-
-### Ingestion: 100K–250K docs/s
-
-SpectorIndex's ingestion is **28-160× faster** than standalone HNSW because:
-- No graph construction during add (flat buffer append)
-- Residual computation is O(D) — just subtraction
-- Memory-mapped flat arrays with sequential writes
-- Graph construction is deferred until shard promotion
-
-### Search: Sub-millisecond at Optimal Config
-
-**Real embeddings (Qwen3-embedding, 4096-dim, 10K vectors):**
-
-| nCentroids | nProbe | % Searched | Latency | QPS | Recall@10 |
-|------------|--------|-----------|---------|-----|-----------|
-| **128** | **4** | **3.1%** | **0.46ms** | **2,173** | **1.0000** |
-| 128 | 8 | 6.3% | 0.73ms | 1,368 | 1.0000 |
-| 64 | 4 | 6.3% | 0.62ms | 1,601 | 1.0000 |
-| 64 | 8 | 12.5% | 1.17ms | 856 | 1.0000 |
-| 32 | 4 | 12.5% | 1.17ms | 857 | 1.0000 |
-
-> [!TIP]
-> With real embeddings, even `nProbe=4` at 128 centroids gives **perfect recall** while searching only 3.1% of the data. Real embeddings have natural cluster structure that IVF exploits beautifully.
-
-### Memory: 4× Compression with SVASQ
-
-After shard promotion, SVASQ quantization compresses stored residuals to ~(D + 4) bytes per vector — approximately 4× compression versus float32.
-
----
-
-## ⚙️ Configuration Guide
-
-### Centroid Count (`nCentroids`)
-
-The number of IVF partitions. More centroids = finer partitioning = better recall at low nProbe, but slower training.
-
-| Dataset Size | Recommended `nCentroids` |
-|-------------|-------------------------|
-| 10K–50K | 32–64 |
-| 50K–500K | 64–256 |
-| 500K–5M | 256–1024 |
-| 5M–50M | 1024–4096 |
-
-**Rule of thumb:** `nCentroids ≈ √N` (square root of dataset size).
-
-### Probe Count (`nProbe`)
-
-How many centroids to search at query time. The primary recall/speed knob.
-
-| `nProbe` | Recall | Speed | Use Case |
-|---------|--------|-------|----------|
-| 4 | ~30% | ⚡⚡⚡ | Filtering, not primary search |
-| 16 | ~77% | ⚡⚡ | Fast approximate search |
-| 32 | ~90% | ⚡ | Balanced |
-| 64+ | ~95%+ | 🐌 | High-recall requirements |
-
-> [!TIP]
-> With **real (structured) embeddings**, recall at any given nProbe is significantly higher than with random data. Expect 90%+ recall at `nProbe=16` with production embedding models.
-
-### Shard Threshold (`shardThreshold`)
-
-When a shard's size reaches this threshold, it promotes from flat scan to HNSW.
-
-- **Default: 20,000** — optimal for most workloads
-- Lower values: earlier promotion, higher memory usage, potentially faster search in large shards
-- Higher values: longer flat scan period, lower memory, simpler data path
-
-### Oversampling Factor (`oversamplingFactor`)
-
-After HNSW promotion, the number of candidates retrieved per shard is `k × oversamplingFactor`. Higher values improve recall at the cost of more candidates to merge.
-
-- **Default: 3** — retrieves 30 candidates per shard for top-10 queries
-- Increase to 5-10 if recall is insufficient
-
----
-
-## 🔬 Adaptive Shard Promotion
-
-The adaptive shard design is inspired by the observation from the [original research](../../../new-index-research.md):
-
-> *"Scanning a flat, contiguous MemorySegment of SVASQ vectors using an unrolled 256-bit FMA loop utilizes aggressive CPU pre-fetchers. Panama can evaluate roughly 1,000 vectors in < 1 microsecond."*
-
-For small partitions (< 20K vectors), a flat SIMD scan over contiguous memory is **5-10× faster** than HNSW pointer-chasing. Only when partitions grow large enough for the O(log n) advantage to kick in does HNSW become worthwhile.
-
-```mermaid
-graph LR
-    Add["add(vector)"] --> Check{"size ≥ threshold?"}
-    Check -->|No| Flat["Append to\nflat buffer"]
-    Check -->|Yes| Promote["🔄 Promote"]
-    Promote --> Cal["Calibrate SVASQ\nfrom flat buffer"]
-    Cal --> Build["Build HNSW\n(bulk insert)"]
-    Build --> Free["Free flat buffer\n(reclaim heap)"]
-```
-
-### Thread Safety During Promotion
-
-Promotion holds the write-lock exclusively. The sequence ensures correctness:
-
-1. **In-flight flat scans** complete before promotion runs (they hold read-locks)
-2. **New searches** arriving during promotion block on the read-lock
-3. After promotion, a `volatile` flag enables a **lock-free fast path** for all subsequent searches
-4. The `volatile` write establishes a happens-before edge, guaranteeing the HNSW index is visible to all threads
-
----
-
-## 🧬 FWHT Order of Operations
-
-When combining FWHT with IVF, the order matters:
-
-**Ingestion:**
-1. Find nearest centroid `c` (using original vector in absolute space)
-2. Compute residual `r = x - c`
-3. Apply FWHT to `r` (not to `x` — FWHT before centroid assignment breaks clustering)
-4. Quantize to INT8
-
-**Search:**
-1. Find nProbe closest centroids
-2. For each centroid `c`: compute `q_res = q - c`
-3. Apply FWHT to `q_res`
-4. Pre-multiply scale/offset (SVASQ query pushdown)
-5. Scan the shard
-
----
-
-## 🔗 See Also
-
-- [Large-Scale Benchmarks](real-embedding-benchmarks.md) — Empirical sweeps for real embeddings and HNSW shard promotions.
-- [SVASQ Deep Dive](svasq-deep-dive.md) — How SVASQ quantization works in detail
-- [HNSW Explained](hnsw-explained.md) — How the graph search algorithm works
-- [ANN Search Primer](ann-search-primer.md) — Overview of all ANN algorithm families
-- [SVASQ + SpectorIndex Whitepaper](svasq-spectorindex-whitepaper.md) — Academic treatment
-- [Performance Tuning](../operations/performance-tuning.md) — Practical tuning advice
diff --git a/docs/docs/deep-dives/svasq-deep-dive.md b/docs/docs/deep-dives/svasq-deep-dive.md
deleted file mode 100644
index cbaf6fa..0000000
--- a/docs/docs/deep-dives/svasq-deep-dive.md
+++ /dev/null
@@ -1,359 +0,0 @@
-# 🌀 SpectorQuant — SVASQ (Spector Vector-Aligned Scalar Quantization)
-
-> **How Spector achieves INT8 precision rivaling INT12–INT16 using the Fast Walsh-Hadamard Transform.** SVASQ is Spector's custom quantization technique that combines mathematical rotation with affine scalar quantization to minimize information loss. This page explains the theory, implementation, and why it outperforms standard scalar quantization.
-
----
-
-## 🤔 The Problem with Standard Scalar Quantization
-
-Standard INT8 quantization maps each dimension independently:
-
-```
-quantized[i] = round(255 × (value[i] - min[i]) / (max[i] - min[i]))
-```
-
-This works well when all dimensions have similar variance. But real embeddings often have **outlier dimensions** — a few dimensions with much larger ranges than the rest:
-
-```
-Dim 0:  range [-0.05, 0.05]  → 255 bins across 0.10 range → precision: 0.0004
-Dim 42: range [-3.50, 3.50]  → 255 bins across 7.00 range → precision: 0.0275
-```
-
-Dimension 42 has **70× worse precision** than dimension 0. Since distance computation sums all dimensions, these imprecise outlier dimensions dominate the quantization error — dragging down recall.
-
-> [!NOTE]
-> This problem is particularly acute for transformer embeddings (BERT, GPT, etc.), which often have a few "dominant" dimensions with disproportionately large values.
-
----
-
-## 💡 The SVASQ Insight: Rotate First, Then Quantize
-
-SVASQ solves the outlier problem with a two-step approach:
-
-1. **Rotate** the vector using a mathematical transform that **spreads variance uniformly** across all dimensions
-2. **Quantize** the rotated vector using standard INT8 — now every dimension has similar precision
-
-The rotation doesn't change any distances (it's an orthogonal transform), but it dramatically improves quantization quality.
-
-```mermaid
-graph LR
-    V["Raw Vector\n(uneven variance)"] --> FWHT["🌀 FWHT Rotation\n(spread variance)"]
-    FWHT --> SQ["🔢 INT8 Quantization\n(uniform precision)"]
-    SQ --> Store["💾 Store\n(4× compressed)"]
-```
-
----
-
-## 🔬 The Fast Walsh-Hadamard Transform (FWHT)
-
-### What It Does
-
-The FWHT is an orthogonal transform (like the Fourier Transform, but using only +1 and -1 instead of complex exponentials). It multiplies each vector by a **Hadamard matrix**:
-
-$$\hat{x} = H_n \cdot x$$
-
-Where $H_n$ is the Hadamard matrix of order $n$ (a power of 2):
-
-$$H_1 = [1], \quad H_2 = \begin{bmatrix} 1 & 1 \\ 1 & -1 \end{bmatrix}, \quad H_4 = \begin{bmatrix} H_2 & H_2 \\ H_2 & -H_2 \end{bmatrix}$$
-
-### Why It Spreads Variance
-
-Each output dimension of the Hadamard transform is a **sum or difference of all input dimensions** (with alternating signs). If one input dimension has a spike, the Hadamard transform distributes that spike's energy equally across all output dimensions.
-
-**Before FWHT:** One outlier dimension (dim 42) has 100× the variance of others.
-
-**After FWHT:** Every output dimension has roughly equal variance — the outlier's energy is smeared uniformly.
-
-### Why It's Fast
-
-Unlike the FFT (which requires O(n log n) complex multiplications), the FWHT uses only **additions and subtractions** — no multiplications at all:
-
-```java
-// In-place FWHT: O(n log n) additions, zero multiplications
-for (int len = 1; len < n; len <<= 1) {
-    for (int i = 0; i < n; i += len << 1) {
-        for (int j = i; j < i + len; j++) {
-            float u = data[j];
-            float v = data[j + len];
-            data[j]       = u + v;  // butterfly add
-            data[j + len] = u - v;  // butterfly subtract
-        }
-    }
-}
-```
-
-On a modern CPU with SIMD, this processes 128-dim vectors in under **50 nanoseconds**.
-
-### Key Properties
-
-| Property | Value |
-|----------|-------|
-| Complexity | O(n log n) — only additions/subtractions |
-| Invertible | Yes — `FWHT(FWHT(x)) = n·x` |
-| Orthogonal | Yes — preserves L2 distances: `‖Hx - Hy‖ = ‖x - y‖` |
-| Real-valued | Yes — no complex numbers (unlike FFT) |
-| Dimension requirement | Power of 2 (pad if needed) |
-
-> [!IMPORTANT]
-> **Distance preservation** is the critical property. Because the Hadamard matrix is orthogonal, `L2(FWHT(x), FWHT(y)) = L2(x, y)`. This means quantizing in the rotated space doesn't introduce any systematic bias — only the random quantization noise, which is now spread uniformly.
-
----
-
-## 🏗️ SVASQ Pipeline
-
-### Ingestion (Encoding)
-
-For each vector `x`:
-
-```mermaid
-graph LR
-    X["x (float32)"] --> Pad["Pad to\npower-of-2"]
-    Pad --> FWHT["FWHT\nrotation"]
-    FWHT --> Norm["Extract\n‖x̂‖₂ norm"]
-    FWHT --> Quant["INT8\nquantize"]
-    Norm --> Store["Store: [norm₃₂ | int8[D]]"]
-    Quant --> Store
-```
-
-1. **Pad** the vector to the next power of 2 (e.g., 768 → 1024)
-2. **Apply FWHT** — the in-place butterfly transform
-3. **Extract and store the L2 norm** of the rotated vector (float32, 4 bytes)
-4. **Calibrate** per-dimension min/max from a representative sample
-5. **Quantize** each rotated dimension to INT8: `q[i] = round(255 × (x̂[i] - min[i]) / scale[i])`
-6. **Store** as `[4-byte norm | D bytes of INT8]`
-
-### Search (Asymmetric Distance Computation)
-
-```mermaid
-graph LR
-    Q["query (float32)"] --> Pad2["Pad to\npower-of-2"]
-    Pad2 --> FWHT2["FWHT\nrotation"]
-    FWHT2 --> Prep["Pre-multiply:\nq̃[i] = (q̂[i] - min[i]) / scale[i]"]
-    Prep --> Scan["SIMD scan:\ndot(q̃, int8_stored)"]
-    Scan --> Result["Approximate L2"]
-```
-
-The key optimization: **query pushdown**. Instead of dequantizing each stored vector, we transform the query into the quantized coordinate system:
-
-```
-q̃[i] = (q̂[i] - min[i]) / scale[i]
-```
-
-Then the approximate L2 distance reduces to a simple dot product between the transformed float32 query and the stored INT8 codes — which SIMD can compute at billions of operations per second.
-
----
-
-## 🧬 Residual SVASQ: The IVF Superpower
-
-When SVASQ is used inside an IVF index (like SpectorIndex), vectors are quantized as **residuals** — the difference from their assigned centroid:
-
-$$r = x - c_{\text{nearest}}$$
-
-### Why Residuals Matter
-
-Residual vectors are **much tighter** than absolute vectors:
-- **Absolute coordinates** might span [-3.0, 3.0] → 255 INT8 bins cover a range of 6.0
-- **Residual coordinates** span [-0.2, 0.2] → 255 INT8 bins cover a range of 0.4
-
-That's a **15× improvement in quantization precision** — the same 8-bit integer now represents a 15× smaller step size.
-
-> [!TIP]
-> **INT8 residual quantization gives the spatial precision of INT12–INT16 absolute quantization.** This is why SpectorIndex achieves excellent recall despite using only 1 byte per dimension.
-
-### The FWHT Order
-
-When combining FWHT with IVF residual quantization, the order of operations matters:
-
-```mermaid
-graph LR
-    X["x"] --> C["Find nearest\ncentroid c"]
-    C --> R["r = x - c\n(residual)"]
-    R --> FWHT3["FWHT(r)\n(rotate residual)"]
-    FWHT3 --> Q["INT8 quantize\n(rotated residual)"]
-```
-
-**CRITICAL:** Apply FWHT to the **residual**, not to the raw vector. Applying FWHT before centroid assignment would break the spatial clustering — the Hadamard transform scrambles the dimensions, making K-Means clusters meaningless.
-
----
-
-## 📊 SVASQ vs Other Quantization
-
-| Technique | Compression | Recall@10 | Speed | Notes |
-|-----------|------------|-----------|-------|-------|
-| Float32 (baseline) | 1× | 100% | ⚡ | Reference |
-| **Scalar INT8** | 4× | 95-99% | ⚡⚡ | Simple, good baseline |
-| **SVASQ INT8** | ~4× | **97-99.5%** | ⚡⚡ | FWHT rotation removes outlier impact |
-| **SVASQ-4 (INT4)** | **6-8×** | **95-99%** | ⚡⚡ | Nibble-packed FWHT + 3× rescore recommended |
-| Scalar INT4 | 8× | 85-95% | ⚡⚡ | Aggressive, needs rescore |
-| Product Quantization | 32× | 80-92% | ⚡ | Complex, requires training |
-
-SVASQ achieves the compression of standard INT8 with recall approaching float32 — because the FWHT rotation ensures every dimension contributes equally to the quantized distance.
-
----
-
-## 🔢 SVASQ-4: INT4 Nibble-Packed Quantization
-
-SVASQ-4 extends the SVASQ pipeline to 4-bit quantization, achieving **~2× additional compression** over SVASQ-8 (6–8× total vs float32).
-
-### Why It Works
-
-The FWHT rotation that makes SVASQ-8 work is equally beneficial for INT4:
-
-- After FWHT, all dimensions contribute equally → INT4 quantization noise is **isotropic**
-- With IVF residuals, the tight range means INT4 on residuals ≈ INT6–INT7 on absolute vectors
-- 15 quantization levels (vs 255 for INT8) is sufficient for ranking with oversampling rescore
-
-### Memory Layout
-
-```
-[float32 normSq (4 bytes)] [INT4 × paddedDim nibble-packed (paddedDim/2 bytes)]
-```
-
-Two 4-bit values are packed per byte using **offset encoding** (shifting [-7, 7] to [0, 14]):
-
-```
-byte = (hiNibble << 4) | loNibble
-```
-
-| Dims | Float32 | SVASQ-8 | SVASQ-4 | SVASQ-4 Compression |
-|------|---------|--------|--------|-------------------|
-| 384 → 512 | 1,536 B | 516 B | 260 B | **5.9×** |
-| 768 → 1024 | 3,072 B | 1,028 B | 516 B | **6.0×** |
-| 4096 | 16,384 B | 4,100 B | 2,052 B | **8.0×** |
-
-### Calibration
-
-SVASQ-4 uses **tighter clipping** than SVASQ-8 (2.5σ vs 3.0σ) to optimize for 15 quantization levels:
-
-```java
-SvasqParams params = SvasqCalibrator.calibrate4bit(corpus, dimensions, seed);
-// params.bitWidth() == 4
-// params.bytesPerVector() == 4 + paddedDim / 2
-```
-
-### SIMD Kernel
-
-The `Svasq4SimdKernel` extracts nibbles via shift+mask in each loop iteration, providing natural instruction-level parallelism:
-
-```java
-// Load VL packed bytes = 2×VL dimensions
-ByteVector packed = ByteVector.fromMemorySegment(B_SPECIES, segment, offset, nativeOrder);
-
-// Extract high nibbles (even dims) and low nibbles (odd dims)
-ByteVector hi = packed.lanewise(LSHR, 4).and(0x0F);  // → [0, 14]
-ByteVector lo = packed.and(0x0F);                      // → [0, 14]
-
-// Widen to float32 and FMA with deinterleaved query arrays
-accHi = ((FloatVector) hi.castShape(F_SPECIES, 0)).fma(qTildeHi[i], accHi);
-accLo = ((FloatVector) lo.castShape(F_SPECIES, 0)).fma(qTildeLo[i], accLo);
-```
-
-The hi/lo split gives the CPU two independent FMA chains — one for even dimensions and one for odd — maximizing pipeline utilization.
-
-### Usage
-
-=== "Builder API"
-
-    ```java
-    SpectorEngine engine = SpectorEngine.builder()
-        .dimensions(768)
-        .capacity(500_000)
-        .svasq4()              // SVASQ-4 with default 3× rescore
-        .build();
-    ```
-
-=== "Config API"
-
-    ```java
-    SpectorConfig config = SpectorConfig.DEFAULT
-        .withDimensions(768)
-        .withSvasq4(5);        // 5× oversampling for higher recall
-    ```
-
-=== "Direct Index API"
-
-    ```java
-    QuantizedHnswIndex index = QuantizedHnswIndex.svasq4(
-        768, 100_000, SimilarityFunction.COSINE, HnswParams.DEFAULT, 3);
-    ```
-
-### Expected Recall
-
-| Configuration | Recall@10 | Notes |
-|--------------|-----------|-------|
-| SVASQ-4 (no rescore) | ~95–97% | Direct quantized distance only |
-| SVASQ-4 (2× rescore) | ~96–98% | Moderate oversampling |
-| **SVASQ-4 (3× rescore)** | **~97–99%** | **Recommended default** |
-| SVASQ-4 (5× rescore) | ~98–99% | Higher latency, diminishing returns |
-| SVASQ-8 (no rescore) | ~97–99.5% | For comparison |
-
----
-
-## 💻 Implementation in Spector
-
-### SvasqCalibrator
-
-Calibrates min/max statistics per dimension from a representative sample:
-
-```java
-// SVASQ-8 calibration
-SvasqParams params8 = SvasqCalibrator.calibrate(flatData, sampleSize, dimensions);
-
-// SVASQ-4 calibration (tighter clipping for 15 levels)
-SvasqParams params4 = SvasqCalibrator.calibrate4bit(flatData, sampleSize, dimensions);
-```
-
-### SvasqStrategy / Svasq4Strategy
-
-Encodes vectors and computes asymmetric distances:
-
-```java
-// SVASQ-8
-SvasqStrategy strategy = new SvasqStrategy(params, SimilarityFunction.EUCLIDEAN);
-
-// SVASQ-4
-Svasq4Strategy strategy4 = new Svasq4Strategy(params4, SimilarityFunction.EUCLIDEAN);
-
-// Both implement QuantizationStrategy — same API
-byte[] encoded = strategy.encode(residualVector);
-float dist = strategy.computeDistance(segment, offset, qs);
-```
-
-### SvasqSimdKernel / Svasq4SimdKernel
-
-The Panama SIMD kernel that computes SVASQ distances directly from off-heap memory:
-
-```java
-// SVASQ-8: Zero-copy INT8 codes from MemorySegment
-float l2Dist = SvasqSimdKernel.computeL2(segment, offset, paddedDim, queryState);
-
-// SVASQ-4: Zero-copy nibble-packed INT4 codes from MemorySegment
-float l2Dist4 = Svasq4SimdKernel.computeL2(segment, offset, halfPaddedDim, queryState4);
-```
-
----
-
-## 📐 Mathematical Proof: Distance Preservation
-
-For completeness, here's why FWHT preserves L2 distance.
-
-The Hadamard matrix $H_n$ (normalized by $1/\sqrt{n}$) is orthogonal: $H^T H = I$.
-
-For any two vectors $x, y$:
-
-$$\|Hx - Hy\|^2 = (Hx - Hy)^T(Hx - Hy) = (x - y)^T H^T H (x - y) = (x - y)^T(x - y) = \|x - y\|^2$$
-
-Therefore: $L2(Hx, Hy) = L2(x, y)$. QED.
-
-The quantization error is now distributed uniformly across all dimensions (because FWHT spread the variance), so the expected quantization error is **minimized** — this is the optimality condition proven by Lyubarskii & Vershynin (2010) for random orthogonal transforms.
-
----
-
-## 🔗 See Also
-
-- [Large-Scale Benchmarks](real-embedding-benchmarks.md) — Empirical sweeps for real embeddings and HNSW shard promotions.
-- [Roadmap](../roadmap.md) — Future compression improvements (SVASQ-PQ, padding-aware storage, norm f16)
-- [Understanding Quantization](understanding-quantization.md) — All quantization techniques compared
-- [SpectorIndex Architecture](spector-index-architecture.md) — How SVASQ fits into the IVF-HNSW index
-- [SVASQ Whitepaper](svasq-spectorindex-whitepaper.md) — Academic treatment with proofs and benchmarks
-- [Quantization Comparison](quantization-comparison.md) — How Spector compares to other engines' quantization
diff --git a/docs/docs/deep-dives/svasq-spectorindex-whitepaper.md b/docs/docs/deep-dives/svasq-spectorindex-whitepaper.md
deleted file mode 100644
index ae58764..0000000
--- a/docs/docs/deep-dives/svasq-spectorindex-whitepaper.md
+++ /dev/null
@@ -1,298 +0,0 @@
-# SVASQ + SpectorIndex: A Technical Whitepaper
-
-> **Vectorized Affine Scalar Quantization with Adaptive IVF-HNSW Indexing for High-Performance Approximate Nearest Neighbor Search**
-
-*Spector Engine — 2026*
-
----
-
-## Abstract
-
-We present **SVASQ** (Vectorized Affine Scalar Quantization), a novel vector compression technique that applies the Fast Walsh-Hadamard Transform (FWHT) to spread dimensional variance before INT8 affine quantization, achieving near-lossless recall with 4× compression. We integrate SVASQ into **SpectorIndex**, an adaptive hybrid index combining Inverted File (IVF) coarse partitioning with per-partition Hierarchical Navigable Small World (HNSW) graphs that automatically promote from exact flat scans to quantized graph search as partitions grow. The system achieves 100K–250K vector ingestions per second (28–160× faster than standalone HNSW), sub-millisecond search latency, and perfect recall at full probe depth, implemented entirely on the JVM using Java 21's Vector API (Project Panama) for SIMD acceleration and off-heap memory for zero-GC search paths.
-
----
-
-## 1. Introduction
-
-Vector similarity search is the computational backbone of modern AI applications — retrieval-augmented generation (RAG), semantic search, recommendation systems, and multimodal retrieval all depend on finding the K nearest neighbors of a query vector among millions or billions of stored embeddings.
-
-The fundamental tension in ANN search is the **recall–speed–memory triangle**:
-- **HNSW** [[1]](#references) achieves excellent recall (95–99%) with O(log n) search, but suffers from slow O(n log n) construction and high memory consumption (graph edges consume 50–100% of vector storage).
-- **IVF** [[2]](#references) enables fast ingestion and cache-friendly search through spatial partitioning, but standalone flat IVF has limited recall at low probe depths.
-- **Product Quantization** [[3]](#references) provides aggressive compression (32–96×) but requires expensive codebook training, complex lookup-table-based distance computation, and suffers from significant recall degradation.
-
-SpectorIndex addresses all three limitations simultaneously by combining the strengths of IVF, HNSW, and a novel quantization approach (SVASQ) that achieves the simplicity and speed of scalar quantization with recall approaching float32 exact search.
-
----
-
-## 2. SVASQ: Vectorized Affine Scalar Quantization
-
-### 2.1 The Outlier Problem in Scalar Quantization
-
-Standard INT8 scalar quantization maps each dimension independently using a linear affine transform:
-
-$$q_i = \text{round}\left(255 \cdot \frac{x_i - \text{min}_i}{\text{max}_i - \text{min}_i}\right)$$
-
-The quantization error per dimension is bounded by $\epsilon_i \leq \frac{\text{max}_i - \text{min}_i}{510}$, which is inversely proportional to the dynamic range. When a small number of dimensions have disproportionately large ranges (common in transformer embeddings [[4]](#references)), the quantization error concentrates in those dimensions, degrading distance approximation quality.
-
-### 2.2 Variance Equalization via FWHT
-
-SVASQ resolves the outlier problem by applying an orthogonal rotation before quantization. We use the **Fast Walsh-Hadamard Transform** (FWHT), which multiplies the vector by the normalized Hadamard matrix $H_n$:
-
-$$\hat{x} = \frac{1}{\sqrt{n}} H_n \cdot x$$
-
-**Theorem 1 (Distance Preservation).** For any vectors $x, y \in \mathbb{R}^n$: $\|H_n x - H_n y\| = \|x - y\|$.
-
-*Proof.* $H_n$ is orthogonal ($H_n^T H_n = nI$), so $\|(Hx - Hy)\|^2 = (x-y)^T H^T H (x-y) = n\|x-y\|^2$. After normalization by $1/\sqrt{n}$, the distance is preserved exactly. □
-
-**Theorem 2 (Variance Spreading).** Let $x$ be a random vector with covariance $\Sigma$. The Hadamard transform $\hat{x} = H_n x / \sqrt{n}$ has covariance $\hat{\Sigma} = H_n \Sigma H_n^T / n$. If $\Sigma$ has one dominant eigenvalue $\lambda_1 \gg \lambda_i$ for $i > 1$, the diagonal entries of $\hat{\Sigma}$ are approximately equal: $\hat{\Sigma}_{ii} \approx \text{tr}(\Sigma)/n$.
-
-*Intuition:* Each output dimension of the Hadamard transform is a sum/difference of all input dimensions with alternating signs. A single outlier dimension's variance is distributed across all output dimensions.
-
-### 2.3 SVASQ Encoding Pipeline
-
-Given a vector $x \in \mathbb{R}^D$:
-
-1. **Pad** to $\hat{D}$ = next power of 2 (zero-fill)
-2. **FWHT:** $\hat{x} = \text{FWHT}(x)$ — in-place O(D log D) using only additions/subtractions
-3. **Extract norm:** $\|x\|_2$ stored as float32 (4 bytes)
-4. **Calibrate:** Per-dimension $\text{min}_i, \text{scale}_i$ from a representative sample (one-time)
-5. **Quantize:** $q_i = \text{clamp}(\text{round}(255 \cdot (\hat{x}_i - \text{min}_i) / \text{scale}_i), 0, 255)$
-6. **Store:** `[norm_f32 | q_0, q_1, ..., q_{D̂-1}]` — total $\hat{D} + 4$ bytes
-
-**Storage cost:** For 768-dim vectors: $\hat{D} = 1024$, total = 1028 bytes/vector (vs. 3072 bytes for float32) — **3.0× compression**.
-
-### 2.4 Asymmetric Distance Computation (ADC)
-
-At query time, we avoid dequantizing stored vectors. Instead, we transform the query into the quantized coordinate system (**query pushdown**):
-
-$$\tilde{q}_i = \frac{\hat{q}_i - \text{min}_i}{\text{scale}_i}$$
-
-The approximate L2² distance reduces to:
-
-$$\hat{d}(q, x) \approx \sum_i (\tilde{q}_i - q_i)^2 \cdot \text{scale}_i^2$$
-
-This is a weighted dot-product between float32 query coefficients and INT8 stored codes, which the Java Vector API (Panama) computes using fused multiply-add SIMD instructions at ~1 billion operations per second.
-
----
-
-## 3. SpectorIndex: Adaptive IVF-HNSW Architecture
-
-### 3.1 Two-Level Partitioning
-
-SpectorIndex organizes vectors in a two-level hierarchy:
-
-**Level 1 (IVF):** K-Means++ produces $C$ centroids from a training sample. Each vector is assigned to its nearest centroid and stored as a **residual** $r = x - c_{\text{nearest}}$.
-
-**Level 2 (Adaptive Shards):** Each centroid's partition is a `SpectorShard` operating in one of two modes:
-
-| Mode | Condition | Search | Memory |
-|------|-----------|--------|--------|
-| **Flat** | size < $T$ | Exact SIMD scan over float32 residuals | Float32 buffer |
-| **HNSW** | size ≥ $T$ | SVASQ-quantized graph traversal | SVASQ codes + graph edges |
-
-Where $T$ is the `shardThreshold` (default: 20,000).
-
-### 3.2 Why Flat Scan Beats HNSW for Small Partitions
-
-Modern SIMD hardware can scan contiguous memory at extraordinary speed. Using the Java Vector API with 256-bit lanes:
-
-- **Flat scan throughput:** ~1,000 vectors per microsecond (sequential memory access, hardware prefetcher engaged)
-- **HNSW graph traversal:** ~10–50 nodes per microsecond (random memory access, L2 cache misses at ~100ns each)
-
-For partitions of $N < 20{,}000$ vectors, the flat scan completes in $N / 1000 \approx 20\mu s$ — faster than HNSW's $O(\log N)$ graph hops with their cache miss penalties.
-
-### 3.3 Automatic Shard Promotion
-
-When a shard's flat buffer reaches `shardThreshold`, it automatically promotes to HNSW mode:
-
-1. **Calibrate SVASQ** from the flat buffer (in-place, single pass)
-2. **Build HNSW graph** with pre-calibrated SVASQ strategy (bulk insertion)
-3. **Null flat buffer** to reclaim heap memory
-4. **Volatile publication** — a `volatile` write to the `promoted` flag establishes a happens-before edge, guaranteeing the HNSW index is visible to all concurrent search threads
-
-The promotion is performed under an exclusive write-lock. In-flight flat scans hold the read-lock and complete before promotion begins; new searches arriving during promotion block on the read-lock.
-
-### 3.4 Translation-Invariant Cross-Shard Merge
-
-**This is the most critical correctness property of the architecture.**
-
-After searching $k_{\text{probe}}$ shards, the results must be merged into a global top-K. Each shard returns scores computed on **residuals** — vectors translated to different coordinate origins (centroids). For the merge to be correct, scores from different shards must be **comparable**.
-
-**L2 distance is translation-invariant:**
-
-$$\|(q - c) - (x - c)\|^2 = \|q - x\|^2$$
-
-The centroid $c$ cancels algebraically, so the residual L2 distance equals the original-space L2 distance regardless of which shard the vector resides in.
-
-**Cosine similarity is NOT translation-invariant:** $\cos(q - c_1, x - c_1) \neq \cos(q - c_2, y - c_2)$ in general. Using cosine for cross-shard merge produces incorrect rankings.
-
-> **Design rule:** SpectorIndex always uses **EUCLIDEAN distance** internally for residual search and global merge, regardless of the user's configured similarity function. This is consistent with FAISS's `IndexIVFFlat` and the SPANN architecture [[5]](#references).
-
-### 3.5 ADC for Graph Construction
-
-When promoting a shard, the HNSW graph must be wired correctly. For each new node, the algorithm finds its nearest existing neighbors. We use **Asymmetric Distance Computation (ADC)**:
-
-- **Incoming vector:** exact float32 residual (treated as a "query")
-- **Existing nodes:** already SVASQ-quantized
-
-The ADC distance between an exact float32 vector and a quantized vector is more accurate than the Symmetric Distance (SDC) between two quantized vectors, producing a higher-quality graph with better recall.
-
----
-
-## 4. Implementation: Java 21 + Project Panama
-
-### 4.1 SIMD Distance Kernels
-
-All distance computations use the Java Vector API (`jdk.incubator.vector`):
-
-```java
-FloatVector va = FloatVector.fromArray(SPECIES, a, offset);
-FloatVector vb = FloatVector.fromArray(SPECIES, b, offset);
-FloatVector diff = va.sub(vb);
-sum = diff.fma(diff, sum);  // fused multiply-add
-```
-
-The JIT compiler maps these to AVX2/AVX-512 instructions, achieving 8–16 float operations per clock cycle.
-
-### 4.2 Off-Heap Memory
-
-SVASQ-quantized vectors and HNSW graph edges are stored in Panama `MemorySegment` (off-heap), avoiding GC pressure during search. The `SvasqSimdKernel` reads INT8 codes directly from off-heap memory without any intermediate `byte[]` allocation.
-
-### 4.3 Zero-GC Flat Scan
-
-The flat scan uses array-based top-K tracking (parallel `float[]` scores and `int[]` indices) instead of `PriorityQueue`. No per-candidate object allocation occurs during the scan — only the final `ScoredResult[]` is allocated once per search.
-
-### 4.4 Virtual Thread Compatibility
-
-All locks use `ReentrantReadWriteLock`, which calls `LockSupport.park()` for blocking. This unmounts (not pins) virtual threads, making SpectorIndex safe for high-concurrency virtual thread workloads on Java 21+.
-
----
-
-## 5. Experimental Results
-
-### 5.1 L2 vs Cosine Residual Search Comparison
-
-We validated that L2 residual search produces perfect recall when all centroids are probed, compared to the incorrect use of cosine similarity for cross-shard merge:
-
-| Dataset | L2 Residual (nProbe=ALL) | Cosine Residual (nProbe=ALL) |
-|---------|-----------|--------------------------|
-| 10K (32 centroids) | **1.000** | 0.741 |
-| 50K (32 centroids) | **1.000** | 0.726 |
-| 100K (32 centroids) | **1.000** | 0.714 |
-
-The ~26% recall degradation with cosine similarity is caused by its lack of translation invariance — residual distances from different centroid origins are not directly comparable under cosine.
-
-### 5.2 Ingestion Throughput
-
-| Dataset Size | SpectorIndex | Standalone HNSW | Speedup |
-|-------------|-------------|-----------------|---------|
-| 10K | 130K docs/s | 4,677 docs/s | **28×** |
-| 50K | 140K docs/s | 2,483 docs/s | **56×** |
-| 100K | 150K docs/s | 1,535 docs/s | **98×** |
-| 500K | 246K docs/s | — | — |
-| 1M | 128K docs/s | — | — |
-
-### 5.3 Search Latency (128-dim random Gaussian vectors)
-
-| nProbe | 10K avg | 100K avg | 1M avg |
-|--------|---------|----------|--------|
-| 4 | 0.07ms | 0.33ms | 0.92ms |
-| 8 | 0.08ms | 0.70ms | 2.00ms |
-| 16 | 0.14ms | 1.5ms | 3.76ms |
-| 32 | 0.29ms | 3.2ms | 7.45ms |
-| 64 | — | — | 15.0ms |
-
-### 5.4 Real-Embedding Validation (Qwen3-embedding, 4096-dim)
-
-> [!NOTE]
-> For the comprehensive, empirical sweeps across multiple coarse partition configurations ($C \in \{32, 64, 128, 256\}$) and deep analyses of HNSW shard promotions, refer to the dedicated [Large-Scale Real-Embedding Benchmarks page](real-embedding-benchmarks.md).
-
-To validate the architecture with structured data, we embedded 10,000 diverse sentences (8 topic categories) using Qwen3-embedding (4096 dimensions) via local Ollama inference.
-
-**Result: recall@10 = 1.0000 across ALL configurations tested.**
-
-| nCentroids | nProbe | % Data Searched | Avg Latency | QPS | Recall@10 |
-|------------|--------|-----------------|-------------|-----|-----------|
-| **128** | **4** | **3.1%** | **0.46ms** | **2,173** | **1.0000** |
-| 128 | 8 | 6.3% | 0.73ms | 1,368 | 1.0000 |
-| 128 | 16 | 12.5% | 1.26ms | 792 | 1.0000 |
-| 64 | 4 | 6.3% | 0.62ms | 1,601 | 1.0000 |
-| 64 | 8 | 12.5% | 1.17ms | 856 | 1.0000 |
-| 32 | 4 | 12.5% | 1.17ms | 857 | 1.0000 |
-
-Even at `nProbe=4` with 128 centroids — searching only **3.1% of the data** — recall is perfect. This confirms that real embeddings form tight semantic clusters that IVF captures effectively. The random Gaussian results (Section 5.3) represent the worst-case scenario for IVF, not the typical production workload.
-
-**Comparison: random vs. real embeddings at nProbe=4, nCentroids=128:**
-
-| Metric | Random Gaussian (128-dim) | Real Qwen3 (4096-dim) |
-|--------|--------------------------|----------------------|
-| Recall@10 | 0.234 | **1.000** |
-| Latency | 1.05ms | 0.46ms |
-
-The 4.3× recall improvement and 2.3× latency improvement demonstrate that SpectorIndex is **designed for real workloads**, where data structure is the norm.
-
----
-
-## 6. Discussion
-
-### 6.1 Random vs. Structured Data
-
-Recall at practical nProbe values is lower with random Gaussian vectors than with real embeddings because random high-dimensional data has no natural cluster structure — true nearest neighbors are distributed uniformly across Voronoi cells. Real embedding models (BERT, Sentence-BERT, CLIP, etc.) produce vectors with strong topic-based clustering, where nearest neighbors tend to reside in the same or adjacent IVF cells.
-
-### 6.2 Scaling Analysis
-
-SpectorIndex's architecture suggests the following scaling behavior:
-
-- **Memory:** O(D × N) with ~4× compression via SVASQ
-- **Ingestion:** O(D × N) — dominated by residual computation and flat buffer appends
-- **Search:** O(D × N/C × nProbe) — linear in partition size, controlled by nProbe
-- **Optimal centroid count:** C ≈ √N minimizes the search cost × recall product
-
-### 6.3 Limitations
-
-1. **Training required:** K-Means training requires a representative sample. For streaming workloads, online centroid updates would be needed.
-2. **Static partitioning:** Once centroids are learned, vector distribution changes can cause partition imbalance. Periodic re-training addresses this.
-3. **No native deletion:** Removing vectors from HNSW shards is not implemented. A tombstone approach with periodic compaction is recommended.
-
----
-
-## 7. Related Work
-
-- **FAISS IndexIVFFlat** [[2]](#references): IVF with flat scan per partition. SpectorIndex adds adaptive HNSW promotion and SVASQ quantization.
-- **SPANN** [[5]](#references): Space-Partitioned ANN by Microsoft. Similar IVF + local graph concept; SpectorIndex adds SVASQ and adaptive flat/HNSW shard modes.
-- **ScaNN** [[6]](#references): Google's ANN library using anisotropic quantization. SVASQ achieves similar variance equalization via FWHT instead of learned rotations.
-- **DiskANN** [[7]](#references): SSD-optimized graph index. SpectorIndex is RAM-optimized with off-heap Panama memory.
-
----
-
-## 8. Conclusion
-
-SVASQ + SpectorIndex demonstrates that combining three orthogonal techniques — IVF partitioning, adaptive HNSW graphs, and FWHT-rotated scalar quantization — produces a vector index with:
-
-- **Ingestion speed** rivaling flat arrays (100K+ docs/s)
-- **Search recall** approaching exact brute-force (with sufficient nProbe)
-- **Memory efficiency** of 4× scalar quantization with near-lossless quality
-- **Implementation simplicity** on the JVM without native code or GPU dependencies
-
-The critical insight that L2 distance must be used for cross-shard merge (due to translation invariance) ensures correct global rankings — a property shared with all production IVF implementations.
-
----
-
-## References
-
-<a id="references"></a>
-
-1. Malkov, Y.A. and Yashunin, D.A. (2018). "Efficient and robust approximate nearest neighbor using Hierarchical Navigable Small World graphs." *IEEE TPAMI*, 42(4), 824-836.
-
-2. Jégou, H., Douze, M., and Schmid, C. (2011). "Product quantization for nearest neighbor search." *IEEE TPAMI*, 33(1), 117-128.
-
-3. Johnson, J., Douze, M., and Jégou, H. (2019). "Billion-scale similarity search with GPUs." *IEEE TBD*, 7(2), 535-547. (FAISS)
-
-4. Kovaleva, O., et al. (2019). "Revealing the Dark Secrets of BERT." *EMNLP 2019*. (Outlier dimensions in transformers)
-
-5. Chen, Q., et al. (2021). "SPANN: Highly-efficient Billion-scale Approximate Nearest Neighbor Search." *NeurIPS 2021*.
-
-6. Guo, R., et al. (2020). "Accelerating Large-Scale Inference with Anisotropic Vector Quantization." *ICML 2020*. (ScaNN)
-
-7. Subramanya, S.J., et al. (2019). "DiskANN: Fast Accurate Billion-point Nearest Neighbor Search on a Single Node." *NeurIPS 2019*.
diff --git a/docs/docs/deep-dives/turbo-quant.md b/docs/docs/deep-dives/turbo-quant.md
deleted file mode 100644
index a25878e..0000000
--- a/docs/docs/deep-dives/turbo-quant.md
+++ /dev/null
@@ -1,209 +0,0 @@
-# ⚡ TurboQuant: Near-Optimal Vector Quantization
-
-> **8× compression with ~97%+ recall — no heavy training required.** TurboQuant applies a random orthogonal rotation before scalar quantization, making per-coordinate quantization near-optimal for any data distribution.
-
----
-
-## 🧠 How It Works
-
-TurboQuant is a two-step quantization scheme:
-
-```mermaid
-flowchart LR
-    A["📄 Float32 Vector<br/>(384 dims × 4 bytes = 1536B)"] --> B["🔄 Random Rotation<br/>Orthogonal matrix × vector<br/>SIMD-accelerated"]
-    B --> C["📊 Scalar Quantization<br/>Per-coordinate to 4 bits<br/>Nibble-packed"]
-    C --> D["💾 Stored<br/>(384 dims × 0.5 bytes = 192B)<br/>8× compression"]
-```
-
-### Step 1: Random Orthogonal Rotation
-
-A fixed random orthogonal matrix R is applied to every vector before quantization. This:
-
-
-- **Isotropizes** the distribution — coordinates become near-independent
-
-- **Spreads information** uniformly across all dimensions
-
-- **Preserves distances** — orthogonal transforms don't change L2/cosine/IP
-
-The rotation matrix is generated once at calibration time from a deterministic seed.
-
-### Step 2: Per-Coordinate Scalar Quantization
-
-After rotation, each coordinate is quantized independently using linear min/max scaling to 4-bit values [0, 15]. Because the rotation made coordinates near-independent and uniformly distributed, this simple scalar quantization achieves near-optimal distortion rates.
-
----
-
-## 📊 Comparison with Other Quantization Methods
-
-| Method | Compression | Recall@10 | Training | SIMD-Friendly |
-|--------|-------------|-----------|----------|---------------|
-| Float32 (none) | 1× | 100% | None | ✅ |
-| Scalar INT8 | 4× | ~99.5% | Min/max calibration | ✅ |
-| **TurboQuant (4-bit)** | **8×** | **~97%+** | **Rotation + min/max** | **✅** |
-| Scalar INT4 | 8× | ~93% | Quantile calibration | ✅ |
-| Product Quantization | 32× | ~95% | K-Means (expensive) | ❌ |
-| Scalar INT2 | 16× | ~88% | Quantile calibration | ✅ |
-
-### Key Advantages over Standard SQ4
-
-Standard INT4 quantization has uneven distortion because embedding dimensions are correlated and non-uniform. TurboQuant's rotation decorrelates them first, resulting in:
-
-
-- **4-5% higher recall** at the same bit budget
-
-- **No quantile training** needed (just min/max in rotated space)
-
-- **Better theoretical guarantees** (matches rate-distortion bounds)
-
-### Key Advantages over Product Quantization
-
-
-- **No K-Means training** — PQ requires expensive clustering; TurboQuant is data-oblivious
-
-- **Simpler implementation** — No codebooks, no ADC lookup tables
-
-- **SIMD-friendly** — Packed 4-bit values use the same NibblePacker as standard SQ4
-
-- **Lower latency** — Direct scalar operations vs. table lookups
-
----
-
-## 🚀 SIMD-Accelerated Implementation
-
-The rotation (the most expensive step) uses the Java Vector API for hardware acceleration:
-
-```java
-// Inner dot product uses SIMD fused-multiply-add
-FloatVector mv = FloatVector.fromArray(SPECIES, matrixRow, j);
-FloatVector vv = FloatVector.fromArray(SPECIES, vector, j);
-acc = mv.fma(vv, acc);  // acc += mv * vv (single instruction)
-```
-
-### Memory Layout Optimizations
-
-| Optimization | Purpose |
-|--------------|---------|
-| Flat 1D array (not `float[][]`) | Sequential memory access, no pointer chasing |
-| Pre-transposed matrix for inverse | Cache-friendly row access during decode |
-| `System.arraycopy` for bulk ops | JVM intrinsic, bypasses bounds checks |
-| SIMD dot products in Gram-Schmidt | Faster calibration (one-time cost) |
-
-### Performance Characteristics
-
-| Operation | Complexity | SIMD Speedup |
-|-----------|-----------|--------------|
-| Rotation (384-dim) | O(n²) = 147K muls | ~4-8× via FMA lanes |
-| Scalar quantize | O(n) = 384 ops | Negligible cost |
-| Pack to nibbles | O(n) = 192 bytes | Memory-bound |
-| Distance computation | O(n) per vector | Same as scalar |
-
-> [!NOTE]
-> For 384-dim vectors, rotation takes ~20µs on modern hardware with AVX2. This is amortized across thousands of distance computations in a search query.
-
----
-
-## 💻 Usage
-
-### Calibration
-
-```java
-// Calibrate from a representative sample (100+ vectors recommended)
-float[][] sampleVectors = loadSampleVectors();
-TurboQuantizer tq = TurboQuantizer.calibrate(sampleVectors, 384, 4, 42L);
-//                                           samples    dims  bits seed
-```
-
-The calibration:
-1. Generates a random orthogonal matrix from the seed
-2. Rotates all sample vectors
-3. Computes per-dimension min/max in the rotated space (with 5% margin)
-
-### Encoding & Decoding
-
-```java
-// Encode a vector
-TurboQuantizer.TurboCode code = tq.encode(vector);
-// code.packed() → 192 bytes (384 dims × 4 bits / 8)
-// code.norm()   → original L2 norm (for cosine/IP reconstruction)
-
-// Decode (approximate reconstruction)
-float[] reconstructed = tq.decode(code);
-```
-
-### Distance Computation
-
-```java
-// Approximate distances in quantized space
-float l2dist = tq.approximateL2Distance(queryVector, code);
-float ip     = tq.approximateInnerProduct(queryVector, code);
-float cosine = tq.approximateCosineSimilarity(queryVector, code);
-```
-
-### Batch-Optimized Search
-
-```java
-// Rotate query once, then scan many database vectors
-float[] rotatedQuery = tq.rotateQuery(queryVector);
-
-for (byte[] dbVector : database) {
-    float dist = tq.distanceFromRotatedQuery(rotatedQuery, dbVector);
-    // ...
-}
-```
-
-### With QuantizedVectorStore
-
-```java
-// Create a TurboQuant-backed store
-var store = new QuantizedVectorStore(384, 100_000, turboQuantizer);
-
-// Store vectors (automatically rotated + quantized)
-store.put("doc-1", embedding);
-
-// Retrieve (automatically dequantized + inverse-rotated)
-float[] approx = store.getFloat(0);
-```
-
-### With SpectorEngine
-
-```java
-SpectorEngine engine = SpectorEngine.builder()
-    .dimensions(384)
-    .quantization(QuantizationType.TURBO_QUANT)
-    .build();
-```
-
----
-
-## 🔬 Mathematical Foundation
-
-TurboQuant is based on the observation that for a random orthogonal rotation R:
-
-1. If x has any distribution, then Rx has coordinates that are **near-independent**
-2. For near-independent coordinates, **per-coordinate scalar quantization** achieves the **rate-distortion bound**
-3. The rotation preserves all geometric relationships (L2, cosine, IP)
-
-This means:
-
-- **MSE** between original and reconstructed vectors is minimized
-
-- **Inner product estimation** is near-unbiased
-
-- **Nearest-neighbor search** quality matches the information-theoretic optimum for the given bit budget
-
-> [!TIP]
-> For most use cases, 4-bit TurboQuant is the sweet spot: 8× compression with recall loss under 3%. Use 8-bit for maximum quality (4× compression, <0.5% loss) or 2-bit for extreme compression (16×, ~8% loss).
-
----
-
-## 🔗 See Also
-
-
-- [Understanding Quantization](understanding-quantization.md) — Quantization theory and tradeoffs
-
-- [Quantization Comparison](quantization-comparison.md) — Benchmarks across all modes
-
-- [Architecture Overview](../architecture/overview.md) — How quantization fits in the stack
-
-- [Configuration Guide](../configuration/parameters.md) — Setting quantization parameters
diff --git a/docs/docs/deep-dives/understanding-quantization.md b/docs/docs/deep-dives/understanding-quantization.md
deleted file mode 100644
index 26ce823..0000000
--- a/docs/docs/deep-dives/understanding-quantization.md
+++ /dev/null
@@ -1,563 +0,0 @@
-# 🗜️ Understanding Quantization
-
-> **How search engines compress vectors to fit billions of embeddings in memory.** This page explains vector quantization from first principles — what it is, why it matters, and how different techniques trade off accuracy for efficiency.
-
----
-
-## 🤔 What is Quantization?
-
-Think of quantization like compressing a photo. A RAW image from your camera might be 25 MB — full precision, every detail preserved. Save it as JPEG and it drops to 2 MB. You lose some information, but for most purposes the image looks identical.
-
-Vector quantization does the same thing for embeddings. When a machine learning model encodes text or images, it produces a **vector** — a list of numbers (typically 128–1536 floating-point values) that captures meaning. These vectors are precise, but they're also *big*.
-
-```
-"The quick brown fox" → [0.0234, -0.1567, 0.4521, ..., 0.0891]
-                         ↑ 384 float32 values = 1,536 bytes per vector
-```
-
-Quantization reduces the precision of each number — or replaces groups of numbers with compact codes — so vectors take less space while still being "close enough" for similarity search.
-
-> [!NOTE]
-> **Quantization ≠ dimensionality reduction.** Dimensionality reduction (like PCA) removes dimensions entirely. Quantization keeps all dimensions but reduces the *precision* of each value.
-
----
-
-## 💰 Why Compress Vectors?
-
-Let's do the math. A typical embedding model produces 384-dimensional vectors in float32:
-
-```
-1 vector = 384 dimensions × 4 bytes = 1,536 bytes
-```
-
-Now scale that up:
-
-| Dataset Size | Memory (float32) | With 4× Compression | With 32× Compression |
-|-------------|-----------------|---------------------|----------------------|
-| 100K vectors | 146 MB | 37 MB | 4.6 MB |
-| 1M vectors | **1.5 GB** | 375 MB | 46 MB |
-| 10M vectors | **15 GB** | 3.7 GB | 460 MB |
-| 100M vectors | **150 GB** | 37 GB | 4.6 GB |
-| 1B vectors | **1.5 TB** | 375 GB | **46 GB** |
-
-At billion scale, full-precision vectors require **1.5 terabytes** of RAM — far beyond what typical servers provide. With 32× compression (Product Quantization), that same dataset fits in 46 GB — a single machine with a decent memory budget.
-
-> [!TIP]
-> Even at smaller scales, compression matters. Less memory means better cache utilization, which means faster search. A 4× compressed index that fits in L3 cache will outperform a full-precision index that spills to RAM.
-
----
-
-## 📊 Types of Quantization
-
-### 🔢 Scalar Quantization (INT8)
-
-The simplest approach: map each float32 value to an int8 (8-bit integer). This gives exactly **4× compression** — every 4-byte float becomes a 1-byte integer.
-
-#### How It Works
-
-For each dimension, find the min and max values across all vectors, then linearly scale every float into the [0, 255] range:
-
-```
-quantized_value = round(255 × (value - min) / (max - min))
-```
-
-To reconstruct (dequantize):
-
-```
-reconstructed = min + quantized_value × (max - min) / 255
-```
-
-#### Properties
-
-| Metric | Value |
-|--------|-------|
-| Compression ratio | **4×** |
-| Recall@10 | **≥ 95%** (often 98%+) |
-| Speed impact | Faster (smaller data = better cache) |
-| Complexity | Very low — simple min/max scaling |
-| Calibration | Linear (min/max per dimension) |
-
-> [!TIP]
-> Scalar INT8 is the "safe default" — you get meaningful memory savings with almost no recall loss. Start here unless you need more aggressive compression.
-
----
-
-### 🔢 Scalar Quantization (INT4) — Non-Uniform
-
-INT4 quantization maps each float32 value to a 4-bit integer (0–15), packed two values per byte. This gives **8× compression**. Unlike INT8's linear mapping, INT4 uses **non-uniform (quantile-based) calibration** to better preserve the data distribution.
-
-#### How It Works
-
-1. **Calibration:** Compute quantile-based boundaries per dimension from a representative sample. This creates 16 non-uniformly spaced buckets that match the actual data distribution.
-2. **Encoding:** Assign each dimension value to the nearest boundary interval (0–15).
-3. **Packing:** Store two 4-bit values per byte (nibble packing) — first value in bits 7–4, second in bits 3–0.
-
-```
-Original:    [0.23, -0.45, 0.67, 0.01]
-Encoded:     [9, 2, 14, 7]       (4-bit level per dimension)
-Packed:      [0x92, 0xE7]        (two nibbles per byte → 50% storage)
-```
-
-#### Properties
-
-| Metric | Value |
-|--------|-------|
-| Compression ratio | **8×** |
-| Recall@10 | **85–95%** (with rescore) |
-| Speed impact | Fast — SIMD-accelerated packed dot product |
-| Complexity | Medium — requires calibration on representative data |
-| Calibration | Non-uniform (quantile-based boundaries per dimension) |
-| Rescore default | 3× oversampling |
-
-> [!TIP]
-> INT4 hits the sweet spot between INT8 and IVF-PQ: **8× compression with 85–95% recall** when paired with the configurable rescore strategy. Ideal for 10M–100M vector workloads that can't afford full PQ training complexity.
-
----
-
-### 🔢 Scalar Quantization (INT2) — Non-Uniform
-
-INT2 quantization maps each float32 value to a 2-bit integer (0–3), packed four values per byte. This gives **16× compression** — the most aggressive scalar quantization before going to binary.
-
-#### How It Works
-
-1. **Calibration:** Same quantile-based approach as INT4, but with only 4 buckets per dimension.
-2. **Encoding:** Assign each dimension value to one of 4 levels.
-3. **Packing:** Store four 2-bit values per byte (crumb packing) — values stored in bits 7–6, 5–4, 3–2, 1–0.
-
-```
-Original:    [0.23, -0.45, 0.67, 0.01]
-Encoded:     [2, 0, 3, 1]        (2-bit level per dimension)
-Packed:      [0x8D]              (four crumbs per byte → 75% storage reduction)
-```
-
-#### Properties
-
-| Metric | Value |
-|--------|-------|
-| Compression ratio | **16×** |
-| Recall@10 | **75–90%** (with rescore) |
-| Speed impact | Fastest scalar — minimal data to scan |
-| Complexity | Medium — same calibration as INT4 |
-| Calibration | Non-uniform (quantile-based boundaries per dimension) |
-| Rescore default | 5× oversampling |
-
-> [!IMPORTANT]
-> INT2 is aggressive — only 4 levels per dimension. The higher default oversampling (5×) compensates by rescoring more candidates with exact float32 distances. Best suited for memory-constrained environments where you accept some recall trade-off.
-
----
-
-### 🔲 Binary Quantization (1-bit)
-
-The most aggressive approach: each float becomes a single bit — 0 if negative, 1 if positive. This gives **32× compression** (32 float32 values → 32 bits = 4 bytes).
-
-#### How It Works
-
-```
-bit = 1 if value > 0, else 0
-```
-
-A 384-dimensional vector becomes just 384 bits = **48 bytes** (down from 1,536 bytes).
-
-```mermaid
-graph LR
-    subgraph "Original floats"
-        V1["0.23"]
-        V2["-0.45"]
-        V3["0.01"]
-        V4["-0.89"]
-        V5["0.67"]
-        V6["-0.12"]
-        V7["0.34"]
-        V8["-0.56"]
-    end
-    
-    subgraph "Binary (sign bit)"
-        B1["1"]
-        B2["0"]
-        B3["1"]
-        B4["0"]
-        B5["1"]
-        B6["0"]
-        B7["1"]
-        B8["0"]
-    end
-    
-    V1 --> B1
-    V2 --> B2
-    V3 --> B3
-    V4 --> B4
-    V5 --> B5
-    V6 --> B6
-    V7 --> B7
-    V8 --> B8
-```
-
-#### Hamming Distance
-
-With binary vectors, similarity is measured using **Hamming distance** — just count how many bits differ. Modern CPUs have a hardware `POPCNT` instruction that makes this blazing fast:
-
-```
-vector_a = 10101010
-vector_b = 10100110
-XOR      = 00001100  → popcount = 2 (Hamming distance = 2)
-```
-
-#### Properties
-
-| Metric | Value |
-|--------|-------|
-| Compression ratio | **32×** |
-| Recall@10 | **60–80%** (varies by dataset) |
-| Speed impact | Extremely fast (bitwise ops + POPCNT) |
-| Complexity | Trivial — just sign extraction |
-
-> [!IMPORTANT]
-> Binary quantization loses significant information. It works best with **high-dimensional embeddings** (768+) where the sign pattern alone carries meaning. For 384-dim or lower, expect noticeable recall degradation. Always pair with rescoring (recompute exact distance on top candidates).
-
----
-
-### 🧩 Product Quantization (PQ)
-
-Product Quantization is the "sweet spot" — achieving **32× compression** while maintaining much higher recall than binary quantization. It's more complex, but the idea is elegant.
-
-#### The Core Idea
-
-Instead of compressing each number independently, PQ groups dimensions into **subspaces** and finds the best approximation for each group from a learned codebook.
-
-#### Step by Step
-
-```mermaid
-graph TD
-    subgraph "Step 1: Split vector into subspaces"
-        V["384-dim vector"]
-        V --> S1["Subspace 1<br/>dims 0-23"]
-        V --> S2["Subspace 2<br/>dims 24-47"]
-        V --> S3["Subspace 3<br/>dims 48-71"]
-        V --> SD["..."]
-        V --> S16["Subspace 16<br/>dims 360-383"]
-    end
-    
-    subgraph "Step 2: Quantize each subspace"
-        S1 --> C1["Centroid ID: 42"]
-        S2 --> C2["Centroid ID: 187"]
-        S3 --> C3["Centroid ID: 3"]
-        SD --> CD["..."]
-        S16 --> C16["Centroid ID: 201"]
-    end
-    
-    subgraph "Step 3: Store compact code"
-        C1 --> Code["[42, 187, 3, ..., 201]<br/>16 bytes total"]
-    end
-```
-
-**Training phase:**
-1. Split all vectors into M subspaces (e.g., 16 subspaces of 24 dims each)
-2. Run K-Means clustering on each subspace independently (K=256 centroids)
-3. Store the 16 codebooks (256 centroids × 24 dims × 4 bytes each)
-
-**Encoding phase:**
-1. For each vector, split into M subspaces
-2. Find the nearest centroid in each subspace's codebook
-3. Store M centroid indices (1 byte each) → **M bytes per vector**
-
-**Search phase (Asymmetric Distance Computation):**
-1. Compute distances from the *full-precision query* to all 256 centroids in each subspace → 256 × M lookup table
-2. For each stored code, sum up M table lookups → approximate distance
-3. Return top candidates (optionally rescore with full vectors)
-
-#### Properties
-
-| Metric | Value |
-|--------|-------|
-| Compression ratio | **32×** (with 16 subspaces) to **96×** (with 48 subspaces) |
-| Recall@10 | **80–92%** (depends on subspaces and dataset) |
-| Speed impact | Fast — table lookups instead of floating-point math |
-| Complexity | High — requires training codebooks on representative data |
-
-> [!NOTE]
-> The "product" in Product Quantization refers to the Cartesian product of subspace codebooks. Each subspace is quantized independently, and the full approximation is the product of these independent approximations.
-
----
-
-### 📂 IVF-PQ (Inverted File + Product Quantization)
-
-IVF-PQ combines two techniques for maximum efficiency at billion scale:
-
-1. **IVF (Inverted File):** Partition vectors into clusters using K-Means. At search time, only examine the nearest clusters.
-2. **PQ (Product Quantization):** Compress vectors within each cluster.
-
-#### Two-Level Search
-
-```mermaid
-graph TD
-    Q["Query vector"] --> Coarse["Stage 1: Coarse Search<br/>Find nprobe nearest clusters"]
-    
-    Coarse --> P1["Partition 1<br/>50K PQ codes"]
-    Coarse --> P2["Partition 2<br/>50K PQ codes"]
-    Coarse --> P3["Partition 3<br/>50K PQ codes"]
-    
-    P1 --> Fine["Stage 2: Fine Search<br/>ADC distance on PQ codes"]
-    P2 --> Fine
-    P3 --> Fine
-    
-    Fine --> Results["Top-K results<br/>(optionally rescore)"]
-```
-
-**How it reduces work:**
-
-- With 1000 partitions and `nprobe=10`, you only examine **1% of the dataset**
-
-- Within those partitions, PQ codes are tiny, so scanning is cache-friendly
-
-- Combined effect: search billions of vectors in milliseconds
-
-#### Properties
-
-| Metric | Value |
-|--------|-------|
-| Compression ratio | **32×** (same as PQ) |
-| Recall@10 | **75–90%** (depends on nprobe and PQ settings) |
-| Speed | Very fast — coarse filtering + compressed scan |
-| Scale | **Billions of vectors** on a single node |
-| Complexity | Requires training (K-Means for partitions + PQ codebooks) |
-
-> [!TIP]
-> **Tuning `nprobe`** is the key recall/speed knob. Higher nprobe = more partitions searched = higher recall but slower queries. Start with nprobe=10 and increase until you hit your recall target.
-
----
-
-## 📋 Comparison Table
-
-| Method | Compression | Recall@10 | Speed | Memory (1B × 384d) | Best For |
-|--------|------------|-----------|-------|---------------------|----------|
-| **Scalar INT8** | 4× | 95–99% | ⚡ Fast | 375 GB | High-recall, moderate scale |
-| **Scalar INT4** | 8× | 85–95% | ⚡ Fast | 188 GB | Balanced compression/recall |
-| **Scalar INT2** | 16× | 75–90% | ⚡⚡ Very Fast | 94 GB | Memory-constrained, pre-filter |
-| **Binary (1-bit)** | 32× | 60–80% | ⚡⚡ Fastest | 46 GB | First-pass candidate generation |
-| **Product Quantization** | 32–96× | 80–92% | ⚡ Fast | 46 GB (32×) | Large-scale with good recall |
-| **IVF-PQ** | 32–96× | 75–90% | ⚡⚡ Very Fast | 46 GB (32×) | Billion-scale, balanced |
-
----
-
-## 🎯 What Spector Uses
-
-Spector provides a full spectrum of scalar quantization plus IVF-PQ, covering every memory/recall trade-off:
-
-### Scalar INT8 — For High-Recall Scenarios
-
-When recall is critical (search quality matters more than memory), Scalar INT8 delivers:
-
-- **4× compression** with nearly lossless quality (≥ 95% recall)
-
-- Simple min/max calibration — no training phase needed
-
-- SIMD-friendly — int8 operations parallelize beautifully on modern CPUs
-
-- Ideal for datasets up to ~50M vectors on a 64 GB machine
-
-### Scalar INT4 — The Balanced Sweet Spot
-
-When you need more compression than INT8 but don't want the complexity of PQ:
-
-- **8× compression** with **85–95% recall** when paired with rescore
-
-- Non-uniform (quantile-based) calibration adapts to your data distribution
-
-- Nibble-packed storage (2 values/byte) with SIMD-accelerated distance
-
-- Default 3× oversampling rescore recovers recall lost to quantization
-
-- Ideal for 10M–100M vector workloads on moderate hardware
-
-### Scalar INT2 — Maximum Scalar Compression
-
-When memory is the primary constraint and you can tolerate some recall loss:
-
-- **16× compression** — just 4 levels per dimension
-
-- Same quantile-based calibration as INT4 for optimal bucket placement
-
-- Crumb-packed storage (4 values/byte) for minimal memory footprint
-
-- Default 5× oversampling rescore compensates for aggressive quantization
-
-- Ideal for memory-constrained environments or as a fast pre-filter
-
-### IVF-PQ — For Billion-Scale Scenarios
-
-When you need to search billions of vectors on commodity hardware:
-
-- **32× compression** brings 1B vectors down to ~46 GB
-
-- Two-level search (coarse IVF + fine PQ) keeps latency low
-
-- Trained codebooks preserve more information than binary quantization
-
-- `nprobe` parameter lets you dial recall vs. speed at query time
-
-### Configurable Rescore Strategy
-
-All quantization modes support an **oversampling-based rescore** to recover recall:
-1. Retrieve `oversamplingFactor × k` candidates using fast quantized distance
-2. Recompute exact float32 distances for those candidates
-3. Return the true top-K based on exact scores
-
-| Quantization | Default Oversampling | Effective Recall |
-|-------------|---------------------|-----------------|
-| INT8 | 1 (no rescore) | 95–99% |
-| INT4 | 3× | 85–95% |
-| INT2 | 5× | 75–90% |
-
-> [!NOTE]
-> Set oversampling to 1 to disable rescore entirely (faster but lower recall). GPU acceleration for INT4/INT2 requires dimensions to be a multiple of 32; otherwise Spector automatically falls back to CPU/SIMD.
-
-### The Full Spectrum
-
-```mermaid
-graph LR
-    subgraph "Spector Coverage"
-        INT8["Scalar INT8<br/>4× compression<br/>95-99% recall"]
-        INT4["Scalar INT4<br/>8× compression<br/>85-95% recall"]
-        INT2["Scalar INT2<br/>16× compression<br/>75-90% recall"]
-        IVFPQ["IVF-PQ<br/>32× compression<br/>75-90% recall"]
-    end
-    
-    INT8 ---|"Need more compression"| INT4
-    INT4 ---|"Need more compression"| INT2
-    INT2 ---|"Billion scale"| IVFPQ
-    
-    Small["1M-50M vectors<br/>Quality-first"] --> INT8
-    Medium["10M-100M vectors<br/>Balanced"] --> INT4
-    Constrained["Memory-limited<br/>50M-500M"] --> INT2
-    Large["100M-1B+ vectors<br/>Scale-first"] --> IVFPQ
-```
-
----
-
-## 💻 Code Examples
-
-### Configuring Scalar INT8 Quantization
-
-```java
-// Scalar INT8 — 4× compression, near-lossless recall
-var config = SpectorConfig.DEFAULT
-    .withDimensions(384)
-    .withCapacity(10_000_000)       // 10M vectors
-    .withQuantization(QuantizationType.SCALAR_INT8);
-
-try (var engine = new SpectorEngine(config)) {
-    // Ingest as normal — quantization happens automatically
-    engine.ingest("doc-1", "Vector search fundamentals", embedding);
-    
-    // Search uses quantized vectors for distance computation
-    // Recall remains ≥ 95% with 4× less memory
-    var results = engine.hybridSearch("vector compression", queryVector, 10);
-}
-```
-
-### Configuring Scalar INT4 (Non-Uniform, with Rescore)
-
-```java
-// Scalar INT4 — 8× compression, non-uniform calibration, rescore for recall
-var config = SpectorConfig.DEFAULT
-    .withDimensions(384)
-    .withCapacity(50_000_000)       // 50M vectors
-    .withQuantization(QuantizationType.SCALAR_INT4)
-    .withRescore(3);                // 3× oversampling (default for INT4)
-
-try (var engine = new SpectorEngine(config)) {
-    // Calibration happens automatically from ingested vectors
-    engine.ingestBulk(vectors);
-    
-    // Search: fast quantized distance → rescore top candidates with exact float32
-    // Effective recall: 85–95%
-    var results = engine.vectorSearch(queryVector, 10);
-}
-```
-
-### Configuring Scalar INT2 (Maximum Compression)
-
-```java
-// Scalar INT2 — 16× compression, aggressive but memory-efficient
-var config = SpectorConfig.DEFAULT
-    .withDimensions(384)
-    .withCapacity(100_000_000)      // 100M vectors
-    .withQuantization(QuantizationType.SCALAR_INT2)
-    .withRescore(5);                // 5× oversampling (default for INT2)
-
-try (var engine = new SpectorEngine(config)) {
-    engine.ingestBulk(vectors);
-    
-    // 16× less memory than float32 — fits large datasets in RAM
-    // Rescore compensates for aggressive quantization
-    var results = engine.vectorSearch(queryVector, 10);
-}
-```
-
-### Configuring IVF-PQ for Billion-Scale
-
-```java
-// IVF-PQ — 32× compression for billion-scale datasets
-var config = SpectorConfig.DEFAULT
-    .withDimensions(384)
-    .withCapacity(1_000_000_000)    // 1 billion vectors
-    .withQuantization(QuantizationType.IVF_PQ)
-    .withIvfPartitions(4096)        // Number of coarse clusters
-    .withPqSubspaces(32)            // Subspaces (384/32 = 12 dims each)
-    .withNprobe(16);                // Partitions to search (recall/speed knob)
-
-try (var engine = new SpectorEngine(config)) {
-    // Training happens automatically on first batch of vectors
-    engine.ingestBulk(trainingVectors);  // First batch trains codebooks
-    
-    // Subsequent ingestion uses trained codebooks
-    engine.ingestBulk(remainingVectors);
-    
-    // Search: coarse IVF lookup → PQ distance within partitions
-    var results = engine.vectorSearch(queryVector, 10);
-}
-```
-
-### REST API Configuration
-
-```bash
-# Start with Scalar INT4 + rescore
-curl -X PUT http://localhost:7070/api/v1/config \
-  -H "Content-Type: application/json" \
-  -d '{
-    "quantization": "scalar_int4",
-    "oversamplingFactor": 3
-  }'
-
-# Start with Scalar INT2 + higher rescore for better recall
-curl -X PUT http://localhost:7070/api/v1/config \
-  -H "Content-Type: application/json" \
-  -d '{
-    "quantization": "scalar_int2",
-    "oversamplingFactor": 5
-  }'
-
-# Start with IVF-PQ
-curl -X PUT http://localhost:7070/api/v1/config \
-  -H "Content-Type: application/json" \
-  -d '{
-    "quantization": "ivf_pq",
-    "ivfPartitions": 4096,
-    "pqSubspaces": 32,
-    "nprobe": 16
-  }'
-```
-
----
-
-## 🔗 See Also
-
-- [Core Concepts](../architecture/core-concepts.md) — HNSW, BM25, RRF, and SIMD fundamentals
-
-- [Quantization Comparison](quantization-comparison.md) — How different engines approach quantization
-
-- [Performance Tuning](../operations/performance-tuning.md) — Tuning quantization parameters for your workload
-
-- [Architecture Overview](../architecture/overview.md) — How quantization fits into the storage layer
-
-- [Configuration Guide](../configuration/parameters.md) — All quantization parameters and defaults
\ No newline at end of file
diff --git a/docs/docs/faq.md b/docs/docs/faq.md
deleted file mode 100644
index 50d560b..0000000
--- a/docs/docs/faq.md
+++ /dev/null
@@ -1,252 +0,0 @@
-# ❓ FAQ
-
-> **Quick answers to the most common questions about Spector.** Can't find what you're looking for? Check [GitHub Discussions](https://github.com/spectrayan/spector/discussions) or the specific wiki pages linked throughout.
-
----
-
-## 🌟 General
-
-### What Java version do I need?
-
-**JDK 25 or later.** Spector uses the Java Vector API (incubator module) for SIMD acceleration and Panama FFM for off-heap memory. [OpenJDK builds](https://jdk.java.net/) include these by default.
-
----
-
-### Does it work without a GPU?
-
-**Yes, completely.** GPU is optional. Without a GPU, Spector uses CPU SIMD acceleration (AVX2/AVX-512/NEON) which delivers sub-millisecond search at 100K documents. GPU helps primarily for high-concurrency batch workloads.
-
-> [!TIP]
-> See [GPU Acceleration](architecture/gpu-acceleration.md) for details on when GPU adds value (spoiler: batch sizes > 32).
-
----
-
-### Can I use it as an embedded library?
-
-**Absolutely!** Spector runs in two modes:
-
-| Mode | Description | Overhead |
-|------|-------------|----------|
-| **Embedded** | Add JAR to classpath, create `SpectorEngine` | Zero network overhead |
-| **Server** | REST API with auth, CORS, metrics | HTTP overhead |
-
-```java
-try (var engine = new SpectorEngine(SpectorConfig.DEFAULT.withDimensions(384))) {
-    engine.ingest("id", "content", vector);
-    var results = engine.hybridSearch("query", queryVector, 10);
-}
-```
-
----
-
-### What about persistence? Do I lose data on restart?
-
-**No!** Spector supports persistence through memory-mapped files. The HNSW index uses a page-aligned binary format that loads instantly via `mmap` — no deserialization needed. Vector data survives restarts.
-
----
-
-### How does it compare to Elasticsearch?
-
-| Aspect | ⚡ Spector | Elasticsearch |
-|--------|---------------|--------------|
-| Vector search latency | **0.13 ms** (100K, in-process) | 2–10 ms |
-| Hybrid search latency | **1.01 ms** (100K, in-process) | 10–30 ms |
-| Deployment | Embedded JAR or server | Cluster only |
-| Dependencies | **Zero** (JDK only) | JVM + heavy stack |
-| GPU support | ✅ CUDA | ❌ |
-| IVF-PQ compression | ✅ 32× | ❌ |
-
-> Elasticsearch excels at distributed full-text search with a mature query language and ecosystem. Spector excels at raw in-process performance, embedded use, and modern JVM features. The latency advantage is largest for in-process embedded use; network-bound deployments narrow the gap.
-
----
-
-### Does it support filtering/metadata queries?
-
-**Yes.** The Spring AI integration supports filter expressions:
-
-```java
-vectorStore.similaritySearch(
-    SearchRequest.query("search algorithms")
-        .withFilterExpression("category == 'indexing' && version > 2")
-);
-```
-
----
-
-### What embedding models work with Spector?
-
-Any model that produces float32 vectors. Set `dimensions` to match:
-
-| Model | Dimensions | Provider |
-|-------|-----------|----------|
-| all-MiniLM-L6-v2 | 384 | Sentence Transformers / Ollama |
-| e5-base-v2 | 768 | Sentence Transformers |
-| text-embedding-ada-002 | 1536 | OpenAI |
-| nomic-embed-text | 768 | Ollama |
-| mxbai-embed-large | 1024 | Ollama |
-
-> [!NOTE]
-> Spector includes an Ollama embedding provider out of the box. Implement the `EmbeddingProvider` SPI for any other source.
-
----
-
-## 🔧 Technical
-
-### What similarity functions are supported?
-
-| Function | Best For |
-|----------|----------|
-| **COSINE** (default) | Normalized embeddings (most models) |
-| **DOT_PRODUCT** | Unnormalized embeddings, magnitude matters |
-| **EUCLIDEAN** | Spatial/geometric data |
-
----
-
-### What's the maximum dataset size?
-
-| Mode | Scale |
-|------|-------|
-| Single node | Up to 10 million documents |
-| IVF-PQ mode | Billions of vectors (32× compression) |
-| Distributed mode | Scale horizontally (2–256 shards) |
-
----
-
-### How does the LLM re-ranking work?
-
-```mermaid
-flowchart LR
-    A["🔍 Search<br/>Top-N candidates"] --> B["🤖 LLM (Ollama)<br/>Listwise scoring"]
-    B --> C["✨ Re-ranked<br/>Top-K results"]
-```
-
-1. Vector/hybrid search retrieves top-N candidates (default: 20)
-2. Candidates sent to Ollama for listwise relevance scoring
-3. LLM reorders based on semantic relevance
-4. Final top-K results reflect LLM judgment
-
-> [!WARNING]
-> Adds 100–500ms latency but significantly improves precision for ambiguous queries.
-
----
-
-### What are virtual threads and why do they matter?
-
-Virtual threads (Project Loom) are lightweight threads that don't map 1:1 to OS threads:
-
-- ✅ Handle millions of concurrent requests without pool tuning
-
-- ✅ No `synchronized` blocks that pin platform threads
-
-- ✅ Near-zero scheduling overhead
-
-- ✅ Linear scaling (4.5× at 16 threads measured)
-
----
-
-### How does zero-copy storage work?
-
-Vectors are stored in memory-mapped files using Panama's `MemorySegment`:
-
-- OS maps file directly into process address space
-
-- SIMD kernels read vectors without copying to Java heap
-
-- Zero garbage collection pressure
-
-- Instant startup (no deserialization)
-
-- Supports datasets larger than available RAM
-
----
-
-### What's the difference between HNSW and IVF-PQ?
-
-| Aspect | 🌐 HNSW | 🗜️ IVF-PQ |
-|--------|------|--------|
-| Speed | Fastest (0.05ms) | Fast (nprobe-dependent) |
-| Memory | Full vectors (1.5KB/vec @ 384-dim) | 32× compressed (48 bytes/vec) |
-| Recall | High (configurable) | Moderate (nprobe-dependent) |
-| Scale | Up to millions | Up to billions |
-| Use case | Default for most workloads | Memory-constrained, billion-scale |
-
----
-
-### Can I run benchmarks in CI?
-
-**Yes!** JSON output + baseline regression detection:
-
-```bash
-mvn -pl spector-bench exec:java -Dexec.args="-rf json -rff results.json"
-```
-
----
-
-## ⚙️ Operations
-
-### What ports does Spector use?
-
-| Port | Protocol | Purpose |
-|------|----------|---------|
-| 7070 | HTTP | REST API (configurable) |
-| 9090 | gRPC | Cluster communication (distributed mode) |
-
----
-
-### How do I monitor Spector?
-
-```bash
-curl http://localhost:7070/health          # Health check
-curl http://localhost:7070/api/v1/status    # Engine status
-curl http://localhost:7070/api/v1/metrics   # Request metrics
-```
-
----
-
-### What JVM arguments should I use in production?
-
-```bash
-java \
-  --add-modules jdk.incubator.vector \
-  --enable-native-access=ALL-UNNAMED \
-  -XX:+UseZGC -XX:+ZGenerational \
-  -Xmx4g -Xms4g \
-  -jar spector-node.jar
-```
-
----
-
-### How do I upgrade without downtime?
-
-**Distributed mode:**
-1. Drain one node (stop routing requests)
-2. Upgrade the node binary
-3. Restart and wait for replica sync
-4. Repeat for each node
-
-**Embedded mode:** Standard application deployment with new Spector version.
-
----
-
-### Is there authentication?
-
-**Yes.** Set an API key at server startup:
-
-```bash
-mvn exec:java -pl spector-node \
-  -Dexec.args="7070 384 my-secret-key"
-```
-
-Clients include `X-API-Key: my-secret-key` in requests. Without a key configured, all requests are allowed.
-
----
-
-## 🔗 See Also
-
-- [Getting Started](getting-started/quickstart.md) — Quick start guide
-
-- [What is Spector](about.md) — Product overview
-
-- [Configuration Guide](configuration/parameters.md) — All parameters
-
-- [Performance Tuning](operations/performance-tuning.md) — Optimization strategies
\ No newline at end of file
diff --git a/docs/docs/getting-started/installation.md b/docs/docs/getting-started/installation.md
index 3dfa9c5..865577d 100644
--- a/docs/docs/getting-started/installation.md
+++ b/docs/docs/getting-started/installation.md
@@ -12,19 +12,19 @@
 ## Building from Source
 
 ```bash
-git clone https://github.com/spectrayan/spector.git
-cd spector
+git clone https://github.com/spectrayan/spector-search.git
+cd spector-search
 mvn clean install -DskipTests
 ```
 
 ## Running with JVM Flags
 
-Spector uses incubator modules. The required JVM flags are configured in `pom.xml`, but if running manually:
+Spector Search uses incubator modules. The required JVM flags are configured in `pom.xml`, but if running manually:
 
 ```bash
 java --add-modules jdk.incubator.vector \
      --enable-native-access=ALL-UNNAMED \
-     -jar spector-node/target/spector-node.jar
+     -jar spector-server/target/spector-server.jar
 ```
 
 ## Server Configuration
@@ -32,8 +32,8 @@ java --add-modules jdk.incubator.vector \
 Start with custom port, dimensions, and API key:
 
 ```bash
-mvn exec:java -pl spector-node \
-  -Dexec.mainClass="com.spectrayan.spector.server.SpectorNode" \
+mvn exec:java -pl spector-server \
+  -Dexec.mainClass="com.spectrayan.spector.server.SpectorServer" \
   -Dexec.args="7070 384 my-secret-key"
 ```
 
@@ -44,9 +44,7 @@ Arguments: `<port> <dimensions> [api-key]`
 GPU acceleration requires:
 
 - NVIDIA GPU with CUDA support
-
 - CUDA toolkit installed
-
 - Set `gpuEnabled=true` in configuration
 
 The system falls back to CPU SIMD automatically when GPU is unavailable.
@@ -57,4 +55,4 @@ Spector ships with an Ollama embedding provider. To enable auto-embedding:
 
 1. Install [Ollama](https://ollama.ai)
 2. Pull an embedding model: `ollama pull nomic-embed-text`
-3. Configure the embedding endpoint in your application
\ No newline at end of file
+3. Configure the embedding endpoint in your application
diff --git a/docs/docs/getting-started/jdk-api-status.md b/docs/docs/getting-started/jdk-api-status.md
deleted file mode 100644
index d773ccd..0000000
--- a/docs/docs/getting-started/jdk-api-status.md
+++ /dev/null
@@ -1,199 +0,0 @@
-# ☕ JDK API Status & Compatibility
-
-> **Spector deliberately adopts the latest JDK innovations for maximum hardware utilization.** This page explains which APIs are finalized, which are still incubating or in preview, what that means in practice, and how to handle the required JVM flags.
-
----
-
-## API Status Summary
-
-| API | JDK Status | Since | JVM Flag | Risk Level |
-|:---|:---|:---|:---|:---|
-| **Panama FFM** (MemorySegment, Arena) | ✅ **Finalized** | JDK 22 (JEP 454) | `--enable-native-access` | **None** — stable, production-ready |
-| **Virtual Threads** (Project Loom) | ✅ **Finalized** | JDK 21 (JEP 444) | None | **None** — stable, production-ready |
-| **Vector API** (`jdk.incubator.vector`) | 🔬 **Incubator** | JDK 16 (JEP 338) | `--add-modules jdk.incubator.vector` | **Low** — API stable across 10 rounds |
-| **Structured Concurrency** | 🔬 **Preview** | JDK 21 (JEP 505) | `--enable-preview` | **Low** — Spector has fallback mode |
-
-> [!IMPORTANT]
-> **Two of Spector's four core JDK technologies are already finalized** — Panama FFM (off-heap memory) and Virtual Threads (concurrency). The remaining two (Vector API, Structured Concurrency) are in incubator/preview but have been stable in practice.
-
----
-
-## What "Incubator" and "Preview" Mean
-
-### Incubator Modules
-
-Incubator modules are **non-final APIs** shipped in the JDK for real-world feedback. They:
-
-- Require an explicit opt-in flag: `--add-modules jdk.incubator.vector`
-- Emit a startup warning: `WARNING: Using incubator modules: jdk.incubator.vector`
-- May change API surface between JDK releases
-- Are **not enabled by default** — they won't interfere with other applications
-
-### Preview Features
-
-Preview features are **language or VM features** that are functionally complete but seeking final feedback. They:
-
-- Require `--enable-preview` at both compile and runtime
-- Are expected to be finalized in a near-future JDK release
-- May have minor signature changes before finalization
-
-> [!NOTE]
-> Both incubator and preview APIs are **fully functional and performant** — they are not experimental prototypes. The designation means the API surface could evolve, not that the implementation is unreliable.
-
----
-
-## Vector API — Detailed Assessment
-
-The Vector API (`jdk.incubator.vector`) has been incubating since **JDK 16 (March 2021)** — over 5 years and 10 incubation rounds. Despite its incubator status, it is the most mature incubator module in JDK history.
-
-### Why It's Still Incubating
-
-The Vector API's finalization is blocked by **Project Valhalla** (value types). The JDK team wants `FloatVector`, `IntVector`, etc. to be value types for optimal JIT behavior. Until Valhalla delivers value types, the Vector API remains in incubator — not because of instability, but because the JDK team wants the finalized version to have optimal memory layout.
-
-### Stability in Practice
-
-| Aspect | Assessment |
-|:---|:---|
-| **API surface** | Stable since JDK 19. No breaking changes in 6+ rounds. |
-| **Performance** | Fully JIT-optimized. HotSpot intrinsics compile to native AVX/NEON. |
-| **Adoption** | Used internally by OpenJDK itself and major open-source projects. |
-| **ISA support** | AVX2, AVX-512, NEON — all production-grade. |
-
-### Spector's Usage Pattern
-
-Spector uses the **most stable subset** of the Vector API:
-
-```java
-// ISA-agnostic — works on any platform
-FloatVector.SPECIES_PREFERRED
-
-// Standard operations — unlikely to change
-vector.mul(other).reduceLanes(VectorOperators.ADD)
-```
-
-We avoid experimental or niche operations, sticking to arithmetic (mul, add, sub, fma) and reductions (reduceLanes) — the core operations that have been stable across all incubation rounds.
-
-### Migration Path When Finalized
-
-When the Vector API is finalized (expected when Project Valhalla matures):
-
-1. Remove `--add-modules jdk.incubator.vector` from JVM flags
-2. Change imports from `jdk.incubator.vector` to `java.util.vector` (or wherever the final package lands)
-3. No algorithmic changes expected — the math operations are stable
-
-> [!TIP]
-> Spector centralizes all Vector API usage in `spector-core`, so migration will require changes in a single module.
-
----
-
-## Structured Concurrency — Detailed Assessment
-
-Structured Concurrency (JEP 505) is a **preview feature** that Spector uses for safe parallel task management. It has been in preview since JDK 21.
-
-### Spector's Fallback Mode
-
-Spector includes a **runtime fallback** to classic virtual threads:
-
-```bash
-# Use structured concurrency (default)
-java --enable-preview -jar spector.jar
-
-# Fall back to classic ExecutorService + virtual threads
-java -Dspector.concurrency.structured=false -jar spector.jar
-```
-
-The fallback mode uses `Executors.newVirtualThreadPerTaskExecutor()` — fully finalized, production-ready, and functionally equivalent for all Spector use cases.
-
-### Where Spector Uses Structured Concurrency
-
-| Site | Module | Benefit |
-|:---|:---|:---|
-| Hybrid search fan-out | spector-query | Auto-cancel sibling on failure |
-| Distributed shard fan-out | spector-node | Auto-cancel all on shard failure |
-| Batch embedding | spector-embed-api | Scope-per-call lifecycle |
-| PQ subspace training | spector-index | All-or-nothing structured scope |
-| BM25 parallel scoring | spector-index | Auto-cancel with sequential fallback |
-
-> [!NOTE]
-> All structured concurrency usage is centralized in `ConcurrentTasks` (spector-commons). When the API finalizes, updates are needed in a single file.
-
----
-
-## Panama FFM — Finalized ✅
-
-The Foreign Function & Memory API was **finalized in JDK 22** (JEP 454). This is the foundation of Spector's off-heap memory management.
-
-The `--enable-native-access=ALL-UNNAMED` flag is still recommended to suppress warnings about native memory access, but the API itself is stable and will not change.
-
-| Component | Used For |
-|:---|:---|
-| `MemorySegment` | Off-heap vector storage (zero-copy, zero-GC) |
-| `Arena` | Scoped memory lifecycle management |
-| `ValueLayout.JAVA_FLOAT` | Type-safe memory access for vector data |
-| `MemorySegment.ofBuffer()` | Memory-mapped file I/O |
-
----
-
-## Virtual Threads — Finalized ✅
-
-Virtual Threads (Project Loom) were **finalized in JDK 21** (JEP 444). Spector uses them throughout:
-
-- REST API request handling (one virtual thread per request)
-- MCP server tool dispatch
-- Hybrid search fan-out
-- Bulk ingestion pipelines
-
-No JVM flags are required — virtual threads are a standard JDK feature.
-
----
-
-## Required JVM Flags
-
-Here is the complete set of JVM flags Spector requires and why:
-
-```bash
-java \
-  --add-modules jdk.incubator.vector \     # Vector API (incubator)
-  --enable-native-access=ALL-UNNAMED \     # Panama FFM native access (finalized, but flag suppresses warnings)
-  --enable-preview \                        # Structured Concurrency (preview)
-  -jar spector.jar
-```
-
-### Flag Compatibility Matrix
-
-| Flag | Required? | What Happens Without It |
-|:---|:---|:---|
-| `--add-modules jdk.incubator.vector` | ✅ Required | `ClassNotFoundException` — Vector API classes not available |
-| `--enable-native-access=ALL-UNNAMED` | ⚠️ Recommended | Works, but emits native access warnings on stderr |
-| `--enable-preview` | ⚠️ Optional | Works if `spector.concurrency.structured=false` (fallback mode) |
-
-> [!TIP]
-> **Minimum viable flags:** If you want to avoid preview features entirely, you can run with just `--add-modules jdk.incubator.vector` and `-Dspector.concurrency.structured=false`. This disables structured concurrency but everything else works normally.
-
----
-
-## FAQ
-
-### Is it safe to use incubator modules in production?
-
-Yes, with awareness. The "incubator" label means the API *surface* could change, not that the implementation is unstable. The Vector API has been functionally stable across 10 JDK releases. Many organizations run incubator modules in production.
-
-### What happens when I upgrade JDK versions?
-
-When upgrading from one JDK version to the next, check the release notes for Vector API changes. In practice, no breaking changes have occurred since JDK 19. Spector's test suite (331+ tests) will catch any issues during a JDK upgrade.
-
-### Will the startup warnings affect my application?
-
-No. The `WARNING: Using incubator modules: jdk.incubator.vector` message goes to stderr and has zero performance impact. It's purely informational. In MCP mode, all logging goes to stderr by design, so the warning doesn't affect the JSON-RPC protocol stream.
-
-### Can I use Spector without any incubator/preview features?
-
-Not currently — the Vector API is fundamental to Spector's SIMD acceleration. However, you can avoid preview features by using the structured concurrency fallback (`-Dspector.concurrency.structured=false`).
-
----
-
-## See Also
-
-- [Quick Start](quickstart.md) — Build and run with all required JVM flags
-- [Installation](installation.md) — JDK setup and verification
-- [Architecture Overview](../architecture/overview.md) — How these APIs fit into the architecture
diff --git a/docs/docs/getting-started/quickstart.md b/docs/docs/getting-started/quickstart.md
index ea53d8b..fb810a4 100644
--- a/docs/docs/getting-started/quickstart.md
+++ b/docs/docs/getting-started/quickstart.md
@@ -1,250 +1,55 @@
-# 🚀 Getting Started
+# Quick Start
 
-> **Go from zero to your first search result in under 5 minutes.** This guide walks you through building Spector from source, starting the server, ingesting documents, and running your first hybrid search.
+Get Spector Search running and execute your first search in under 5 minutes.
 
----
+## Prerequisites
 
-## 📋 Prerequisites
+- **JDK 25+** (OpenJDK with Vector API incubator)
+- **Maven 3.9+**
 
-| Tool | Version | How to Check |
-|------|---------|-------------|
-| ☕ JDK | 25+ | `java -version` |
-| 📦 Maven | 3.9+ | `mvn --version` |
-| 🔧 Git | 2.40+ | `git --version` |
-
-> [!IMPORTANT]
-> Spector requires **JDK 25 or later** with the Vector API incubator module. [OpenJDK builds](https://jdk.java.net/) include this by default.
-
----
-
-## 🏗️ Clone and Build
+## Build
 
 ```bash
-# Clone the repository
-git clone https://github.com/spectrayan/spector.git
-cd spector
-
-# Build all modules (includes 316+ tests)
+git clone https://github.com/spectrayan/spector-search.git
+cd spector-search
 mvn clean test
-
-# Build without tests (faster)
-mvn clean package -DskipTests
-```
-
-> [!TIP]
-> The full test suite runs 316+ tests across all modules. Expect ~2 minutes on a modern machine.
-
----
-
-## 🔬 Verify SIMD Support
-
-Confirm your hardware's SIMD acceleration level:
-
-```bash
-java --add-modules jdk.incubator.vector -cp spector-core/target/classes \
-  com.spectrayan.spector.core.SimdCapability
-```
-
-Expected output (varies by hardware):
-```
-SIMD Species: S_256_BIT (AVX2, 8 float lanes)
-```
-
----
-
-## 🖥️ Start the Server
-
-```bash
-# Start on default port 7070 with 384 dimensions
-mvn exec:java -pl spector-node \
-  -Dexec.mainClass="com.spectrayan.spector.server.SpectorNode"
-
-# Start with custom port, dimensions, and API key
-mvn exec:java -pl spector-node \
-  -Dexec.mainClass="com.spectrayan.spector.server.SpectorNode" \
-  -Dexec.args="7070 384 my-secret-key"
 ```
 
-Verify it's running:
+## Start the Server
 
 ```bash
-curl http://localhost:7070/health
+mvn exec:java -pl spector-server \
+  -Dexec.mainClass="com.spectrayan.spector.server.SpectorServer"
 ```
 
-```json
-{"status": "UP"}
-```
-
-> [!NOTE]
-> The server starts on virtual threads — it can handle thousands of concurrent requests out of the box with no thread pool configuration needed.
-
----
+The server starts on port 7070 by default.
 
-## 📄 Ingest Your First Document
+## Ingest a Document
 
 ```bash
 curl -X POST http://localhost:7070/api/v1/ingest \
   -H "Content-Type: application/json" \
   -d '{
     "id": "doc-1",
-    "title": "Introduction to Vector Search",
-    "content": "Vector search finds similar items by comparing their mathematical representations called embeddings.",
-    "vector": [0.12, 0.45, 0.78, 0.23, 0.91, 0.34, 0.67, 0.55, 0.11, 0.89]
+    "title": "Java Vector API",
+    "content": "SIMD-accelerated search engine on modern JVM",
+    "vector": [0.1, 0.2, 0.3, 0.4, 0.5]
   }'
 ```
 
-```json
-{"id": "doc-1", "status": "indexed"}
-```
-
-### 🤖 Ingest with Auto-Embedding
-
-If you have Ollama running with an embedding model:
-
-```bash
-curl -X POST http://localhost:7070/api/v1/ingest/auto \
-  -H "Content-Type: application/json" \
-  -d '{
-    "id": "doc-2",
-    "title": "HNSW Algorithm",
-    "content": "Hierarchical Navigable Small World graphs enable fast approximate nearest neighbor search."
-  }'
-```
-
-### 📦 Bulk Ingest
-
-```bash
-curl -X POST http://localhost:7070/api/v1/ingest/bulk \
-  -H "Content-Type: application/json" \
-  -d '{
-    "documents": [
-      {"id": "d1", "content": "BM25 keyword scoring uses term frequency and document length.", "vector": [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0]},
-      {"id": "d2", "content": "Reciprocal Rank Fusion combines multiple ranked lists.", "vector": [0.5, 0.4, 0.3, 0.2, 0.1, 0.9, 0.8, 0.7, 0.6, 0.5]}
-    ]
-  }'
-```
-
----
-
-## 🔍 Run Your First Search
-
-### 🧬 Hybrid Search (keyword + vector)
+## Search
 
 ```bash
 curl -X POST http://localhost:7070/api/v1/search \
   -H "Content-Type: application/json" \
   -d '{
-    "text": "nearest neighbor search",
-    "vector": [0.15, 0.42, 0.73, 0.28, 0.88, 0.31, 0.62, 0.51, 0.14, 0.85],
-    "topK": 5
+    "text": "vector search",
+    "topK": 10
   }'
 ```
 
-```json
-{
-  "results": [
-    {
-      "id": "doc-1",
-      "score": 0.9234,
-      "title": "Introduction to Vector Search",
-      "content": "Vector search finds similar items..."
-    }
-  ],
-  "searchMode": "HYBRID",
-  "latencyMs": 0.31
-}
-```
-
-### 📝 Keyword-Only Search
-
-```bash
-curl -X POST http://localhost:7070/api/v1/search \
-  -H "Content-Type: application/json" \
-  -d '{"text": "BM25 scoring", "topK": 10}'
-```
-
-### 🧠 Vector-Only Search
-
-```bash
-curl -X POST http://localhost:7070/api/v1/search \
-  -H "Content-Type: application/json" \
-  -d '{"vector": [0.15, 0.42, 0.73, 0.28, 0.88, 0.31, 0.62, 0.51, 0.14, 0.85], "topK": 10}'
-```
-
----
-
-## 📊 Check Engine Status
-
-```bash
-curl http://localhost:7070/api/v1/status
-```
-
-```json
-{
-  "status": "RUNNING",
-  "simd": "AVX2 (256-bit, 8 lanes)",
-  "gpuAvailable": false,
-  "rerankerEnabled": false,
-  "documentCount": 3,
-  "dimensions": 384
-}
-```
-
----
-
-## 💻 Use as an Embedded Library
-
-No server needed — use Spector directly in your Java application:
-
-```java
-import com.spectrayan.spector.engine.SpectorEngine;
-import com.spectrayan.spector.engine.SpectorConfig;
-
-var config = SpectorConfig.DEFAULT
-    .withDimensions(384)
-    .withCapacity(100_000);
-
-try (var engine = new SpectorEngine(config)) {
-    // Ingest
-    engine.ingest("doc-1", "Hello world", new float[]{0.1f, 0.2f, ...});
-
-    // Search
-    var results = engine.hybridSearch("hello", queryVector, 10);
-
-    for (var result : results.results()) {
-        System.out.printf("%s → %.4f%n", result.id(), result.score());
-    }
-}
-```
-
-> [!TIP]
-> Embedded mode has **zero network overhead** — perfect for microservices, desktop apps, and edge deployments.
-
----
-
-## 🎉 What You've Accomplished
-
-In just a few minutes, you've:
-
-- ✅ Built Spector from source
-
-- ✅ Verified SIMD hardware acceleration
-
-- ✅ Started a search server
-
-- ✅ Ingested documents
-
-- ✅ Run hybrid search queries
-
----
-
-## 🚀 Next Steps
+## Next Steps
 
-| What to explore | Page |
-|----------------|------|
-| Full API documentation | [REST API Reference](../api-reference/rest-endpoints.md) |
-| Type-safe Java client | [Java SDK Guide](../sdk-usage/java-client.md) |
-| Tune for your workload | [Configuration Guide](../configuration/parameters.md) |
-| Command-line management | [CLI Reference](../cli-reference/spectorctl.md) |
-| Understand the internals | [Architecture Overview](../architecture/overview.md) |
-| Spring AI integration | [Spring AI Integration](../sdk-usage/spring-ai.md) |
\ No newline at end of file
+- [Installation guide](installation.md) for detailed setup options
+- [API Reference](../api-reference/overview.md) for all endpoints
+- [Java SDK](../sdk-usage/java-client.md) for programmatic access
diff --git a/docs/docs/index.md b/docs/docs/index.md
index 5751df6..9ab627b 100644
--- a/docs/docs/index.md
+++ b/docs/docs/index.md
@@ -1,109 +1,33 @@
-# ⚡ Welcome to Spector
+# Spector Search
 
-> **The Zero-Overhead, Agent-Ready AI Memory Backbone.**
+**Ultra-fast, SIMD-accelerated semantic search engine built on Java Vector API + modern JVM technologies.**
 
-Welcome to the Spector documentation — your central hub for the high-performance, agent-native AI search engine. Whether you're connecting AI agents via MCP, building RAG pipelines, powering recommendation systems, or need sub-millisecond search with zero infrastructure, you're in the right place.
+## What is Spector Search?
 
----
+Spector Search is a high-performance vector search engine written in Java 25 that leverages:
 
-## 🔥 Why Spector?
+- **Java Vector API** (jdk.incubator.vector) for SIMD-accelerated similarity kernels
+- **Panama FFM** for zero-copy memory-mapped storage and GPU interop
+- **Virtual Threads** for massive concurrency in ingestion, embedding, and query execution
+- **Memory-mapped ANN indexes** for instant startup and zero-GC-pressure search
 
-| Metric | Value |
-|--------|-------|
-| 🤖 MCP Tools | **6 agent-ready tools** (semantic, hybrid, RAG, ingest, delete, status) |
-| ⚡ Vector Search Latency | **0.05 ms** avg @ 10K docs (128-dim) |
-| 🔍 Keyword Search Latency | **0.98 ms** avg @ 100K docs |
-| 🧬 Hybrid Search Latency | **0.17 ms** avg @ 10K docs |
-| 🚀 Vector Throughput | **18,800 queries/sec** @ 10K |
-| 🧵 Concurrent Hybrid | **14,000+ ops/sec** @ 16 threads (384-dim) |
-| 🗜️ IVF-PQ + TurboQuant | **8–32× memory reduction** |
-| ✅ Test Suite | **331+ tests**, all passing |
-| 📦 Dependencies | **Zero** (JDK only) |
+## Key Features
 
----
+| Feature | Description |
+|---------|-------------|
+| Sub-millisecond queries | HNSW vector search at 0.05ms avg latency |
+| Hybrid search | Combines semantic + keyword search via RRF |
+| Multi-level quantization | INT8 (4×), INT4 (8×), INT2 (16×) with configurable rescore |
+| GPU acceleration | CUDA kernels via Panama FFM |
+| IVF-PQ compression | 32× memory reduction for billion-scale |
+| Distributed search | gRPC fan-out with consistent hash sharding |
+| Zero dependencies | Pure JDK, drop-in JAR |
 
-## 🗺️ Quick Navigation
+## Quick Links
 
-### 🚀 Getting Started
-
-| Page | Description |
-|------|-------------|
-| [Getting Started](getting-started/quickstart.md) | Build, run, and search in 5 minutes |
-| [What is Spector](about.md) | Product overview, use cases, and comparisons |
-| [JDK API Status](getting-started/jdk-api-status.md) | Vector API, Panama FFM, and preview feature compatibility |
-| [FAQ](faq.md) | Common questions answered |
-
-### 🤖 Agent Integration (MCP)
-
-| Page | Description |
-|------|-------------|
-| [MCP Integration Architecture](architecture/mcp-integration.md) | How the MCP server works under the hood |
-| [MCP Server Guide](sdk-usage/mcp-server.md) | Setup for Claude Desktop, Cursor, and custom agents |
-
-### 🏗️ Architecture & Concepts
-
-| Page | Description |
-|------|-------------|
-| [Architecture Overview](architecture/overview.md) | Module diagram, data flow, threading model |
-| [Core Concepts](architecture/core-concepts.md) | HNSW, IVF-PQ, BM25, RRF, SIMD deep-dives |
-| [Ingestion Pipeline](architecture/ingestion-pipeline.md) | Document → chunk → embed → index pipeline |
-| [RAG Pipeline](architecture/rag-pipeline.md) | End-to-end retrieval-augmented generation |
-| [Distributed Mode](architecture/distributed-mode.md) | Clustering, sharding, and replication |
-| [GPU Acceleration](architecture/gpu-acceleration.md) | CUDA setup and kernel details |
-
-### 📖 Reference
-
-| Page | Description |
-|------|-------------|
-| [REST API Reference](api-reference/rest-endpoints.md) | All endpoints with curl examples |
-| [Java SDK Guide](sdk-usage/java-client.md) | Programmatic usage (client + embedded) |
-| [Spring AI Integration](sdk-usage/spring-ai.md) | Spring AI VectorStore adapter |
-| [CLI Reference](cli-reference/spectorctl.md) | `spectorctl` commands |
-| [Configuration Guide](configuration/parameters.md) | All parameters with tuning advice |
-
-### ⚙️ Operations & Community
-
-| Page | Description |
-|------|-------------|
-| [Performance Tuning](operations/performance-tuning.md) | Benchmarks and optimization strategies |
-| [Contributing](operations/contributing.md) | Development setup and PR process |
-
----
-
-## 💡 Highlights at a Glance
-
-```mermaid
-graph LR
-    A["🤖 AI Agent"] --> B["📡 MCP Server"]
-    B --> C["⚡ SpectorEngine"]
-    C --> D["🧠 Hybrid Search"]
-    D --> E["🎯 RRF Fusion"]
-    E --> F["🤖 LLM Re-ranking"]
-    F --> G["✨ Results"]
-    
-    H["📄 Document"] --> I["🧩 Chunking"]
-    I --> J["🧬 Embedding"]
-    J --> C
-```
-
-> [!TIP]
-> New here? Start with [Getting Started](getting-started/quickstart.md) to build and run your first search in under 5 minutes. Want to connect an AI agent? See the [MCP Server Guide](sdk-usage/mcp-server.md).
-
----
-
-## 🌟 Project Stats
-
-| | |
-|---|---|
-| **Language** | Java 25 |
-| **License** | Apache 2.0 · [BSL 1.1](https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE) (memory module) |
-| **Modules** | 18 Maven modules |
-| **Dependencies** | Zero (JDK only) |
-| **SIMD** | AVX2 / AVX-512 / NEON |
-| **GPU** | CUDA via Panama FFM |
-| **MCP** | Built-in, 6 agent-ready tools |
-| **Distributed** | gRPC fan-out + consistent hashing |
-
----
-
-**Built with ⚡ by [Spectrayan](https://www.spectrayan.com/)** · [GitHub](https://github.com/spectrayan/spector) · [Apache 2.0](https://github.com/spectrayan/spector/blob/main/LICENSE) · [BSL 1.1 (memory)](https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE)
\ No newline at end of file
+- [Getting Started](getting-started/quickstart.md) — Build, run, and search in 5 minutes
+- [API Reference](api-reference/overview.md) — All REST endpoints documented
+- [Configuration](configuration/parameters.md) — Tune Spector for your workload
+- [Architecture](architecture/overview.md) — Understand the system design
+- [Java SDK](sdk-usage/java-client.md) — Programmatic access from Java
+- [CLI Reference](cli-reference/spectorctl.md) — Command-line management
diff --git a/docs/docs/javascripts/mathjax.js b/docs/docs/javascripts/mathjax.js
deleted file mode 100644
index 30180ed..0000000
--- a/docs/docs/javascripts/mathjax.js
+++ /dev/null
@@ -1,18 +0,0 @@
-window.MathJax = {
-  tex: {
-    inlineMath: [["\\(", "\\)"]],
-    displayMath: [["\\[", "\\]"]],
-    processEscapes: true,
-    processEnvironments: true
-  },
-  options: {
-    ignoreHtmlClass: ".*",
-    processHtmlClass: "arithmatex"
-  }
-};
-
-document$.subscribe(() => {
-  if (typeof MathJax !== "undefined" && MathJax.typesetPromise) {
-    MathJax.typesetPromise();
-  }
-});
diff --git a/docs/docs/javascripts/mermaid-init.js b/docs/docs/javascripts/mermaid-init.js
deleted file mode 100644
index 9a66f72..0000000
--- a/docs/docs/javascripts/mermaid-init.js
+++ /dev/null
@@ -1,30 +0,0 @@
-// Initialize mermaid with theme that respects dark/light mode
-document.addEventListener('DOMContentLoaded', function() {
-  const observer = new MutationObserver(function() {
-    const scheme = document.body.getAttribute('data-md-color-scheme');
-    const isDark = scheme === 'slate';
-    
-    if (window.mermaid) {
-      window.mermaid.initialize({
-        theme: isDark ? 'dark' : 'default',
-        themeVariables: isDark ? {
-          primaryColor: '#1e1e2e',
-          primaryTextColor: '#cdd6f4',
-          primaryBorderColor: '#6c6c8a',
-          lineColor: '#6c6c8a',
-          secondaryColor: '#313244',
-          tertiaryColor: '#181825',
-          background: '#1e1e2e',
-          mainBkg: '#1e1e2e',
-          nodeBorder: '#6c6c8a',
-          clusterBkg: '#181825',
-          clusterBorder: '#45475a',
-          titleColor: '#cdd6f4',
-          edgeLabelBackground: '#1e1e2e'
-        } : {}
-      });
-    }
-  });
-  
-  observer.observe(document.body, { attributes: true, attributeFilter: ['data-md-color-scheme'] });
-});
diff --git a/docs/docs/labs/roadmap.md b/docs/docs/labs/roadmap.md
deleted file mode 100644
index dd278a2..0000000
--- a/docs/docs/labs/roadmap.md
+++ /dev/null
@@ -1,555 +0,0 @@
----
-title: "Labs — Experimental Features"
-description: "Research roadmap for Spector's experimental cognitive features: Neuromodulatory Gain Control, Executive Dysfunction Profile, Two-Factor Memory Strength, and Dynamic Quantization Stepping."
----
-
-# 🔬 Labs — Experimental Features
-
-> **Status**: Research / Future Work
->
-> These features are under active research and planned for implementation
-> in the `labs` branch. They are not yet available in the main release.
-
----
-
-## Neuromodulatory Gain Control
-
-### Concept
-
-Dynamic retrieval tuning via simulated neurotransmitter modulation. Rather than using static cognitive profiles, the system would maintain a **runtime neuromodulatory state** that continuously adjusts retrieval parameters based on the agent's recent activity, outcomes, and context.
-
-### Biological Basis
-
-The brain's retrieval characteristics aren't fixed — they shift moment-to-moment based on neuromodulatory tone. A developer who just encountered a production outage has elevated norepinephrine, which sharpens recency bias and narrows attention. A developer brainstorming during a design review has elevated serotonin, which broadens associative scope.
-
-Currently, Spector models this via discrete [Cognitive Profiles](../memory/cognitive-profiles.md) (DEBUGGING, EXPLORING, etc.). Neuromodulatory Gain Control would replace discrete switching with **continuous, gradient modulation**.
-
-### Proposed Architecture
-
-```mermaid
-flowchart TD
-    subgraph "Neuromodulatory State"
-        ACh["Acetylcholine<br/>attention sharpness"]
-        5HT["Serotonin<br/>retrieval breadth"]
-        DA["Dopamine<br/>novelty seeking"]
-        NE["Norepinephrine<br/>urgency bias"]
-    end
-
-    subgraph "Retrieval Modulation"
-        TM["Tag Match Strictness"]
-        LS["Lateral Scope"]
-        NW["Novelty Weight"]
-        RB["Recency Bias"]
-    end
-
-    ACh --> TM
-    5HT --> LS
-    DA --> NW
-    NE --> RB
-
-    subgraph "Inputs"
-        O["Outcome Feedback<br/>(reinforce calls)"]
-        C["Context Signals<br/>(tags, valence)"]
-        T["Temporal Patterns<br/>(query rate, errors)"]
-    end
-
-    O --> DA
-    O --> NE
-    C --> ACh
-    C --> 5HT
-    T --> NE
-    T --> DA
-```
-
-### Modulation Parameters
-
-| Neurotransmitter | Parameter Affected | Low Level Effect | High Level Effect |
-|:---|:---|:---|:---|
-| Acetylcholine (ACh) | `tagMatchStrictness` | Loose tag gating (any overlap passes) | Strict tag gating (all bits must match) |
-| Serotonin (5-HT) | `lateralDistanceThreshold` | Narrow scope (close matches only) | Wide scope (cross-domain retrieval active) |
-| Dopamine (DA) | `noveltyWeight` in ICNU | Familiar memories preferred | Novel/surprising memories preferred |
-| Norepinephrine (NE) | `recencyBias` | All ages equal | Strong recency bias (last hour dominates) |
-
-### State Update Model
-
-Each neurotransmitter level $n_i(t)$ follows an exponential decay toward a baseline, with spikes driven by events:
-
-$$
-n_i(t + \Delta t) = n_i^{\text{base}} + \left(n_i(t) - n_i^{\text{base}}\right) \cdot e^{-\Delta t / \tau_i} + \sum_{\text{events}} \Delta n_i
-$$
-
-Where:
-
-- $n_i^{\text{base}}$ — resting level for neurotransmitter $i$ (profile-dependent)
-- $\tau_i$ — decay constant (how quickly it returns to baseline after a spike)
-- $\Delta n_i$ — event-driven spike (e.g., negative reinforcement → +NE, +ACh)
-
-**Example decay constants:**
-
-| Neurotransmitter | $\tau$ | Rationale |
-|:---|:---|:---|
-| ACh | 5 minutes | Attention shifts are fast |
-| 5-HT | 30 minutes | Mood/scope changes are slow |
-| DA | 10 minutes | Novelty-seeking is moderate |
-| NE | 2 minutes | Urgency is very transient |
-
-### Event-to-Spike Mapping
-
-| Event | ACh | 5-HT | DA | NE |
-|:---|:---:|:---:|:---:|:---:|
-| Negative reinforcement (bug found) | +0.3 | -0.1 | — | +0.5 |
-| Positive reinforcement (solution worked) | — | +0.2 | +0.3 | -0.2 |
-| High recall latency (slow query) | +0.1 | — | — | +0.2 |
-| Lateral result selected by agent | — | +0.3 | +0.2 | — |
-| Repeated query (same topic, 3rd time) | +0.4 | -0.2 | -0.1 | — |
-| No results found | — | +0.2 | +0.4 | +0.1 |
-
-### Implementation Sketch
-
-```java
-public final class NeuromodulatoryState {
-    
-    private volatile float acetylcholine = 0.5f;  // baseline
-    private volatile float serotonin = 0.5f;
-    private volatile float dopamine = 0.5f;
-    private volatile float norepinephrine = 0.3f;
-    
-    private volatile long lastUpdateMs = System.currentTimeMillis();
-    
-    /**
-     * Applies exponential decay toward baseline, then adds event spikes.
-     */
-    public synchronized void update(NeuroEvent... events) {
-        long now = System.currentTimeMillis();
-        float dtSeconds = (now - lastUpdateMs) / 1000f;
-        
-        // Exponential decay toward baseline
-        acetylcholine = decayToward(acetylcholine, 0.5f, dtSeconds, TAU_ACH);
-        serotonin = decayToward(serotonin, 0.5f, dtSeconds, TAU_5HT);
-        dopamine = decayToward(dopamine, 0.5f, dtSeconds, TAU_DA);
-        norepinephrine = decayToward(norepinephrine, 0.3f, dtSeconds, TAU_NE);
-        
-        // Apply event spikes
-        for (var event : events) {
-            acetylcholine = clamp(acetylcholine + event.deltaACh());
-            serotonin = clamp(serotonin + event.delta5HT());
-            dopamine = clamp(dopamine + event.deltaDA());
-            norepinephrine = clamp(norepinephrine + event.deltaNE());
-        }
-        
-        lastUpdateMs = now;
-    }
-    
-    /**
-     * Modulates RecallOptions based on current neuromodulatory state.
-     */
-    public RecallOptions modulate(RecallOptions base) {
-        return base.toBuilder()
-            .lateralDistanceThreshold(base.lateralDistanceThreshold() * (2.0f * serotonin))
-            .hyperfocusBoost(base.hyperfocusBoost() * (1.0f + acetylcholine))
-            // ... other modulations
-            .build();
-    }
-}
-```
-
-### Dependencies & Complexity
-
-- **Dependencies:** CognitiveProfile extensions, configurable ICNU weights
-- **Complexity:** High — requires runtime state management, thread-safe neuromodulatory state, and careful calibration of decay constants and spike magnitudes
-- **Risk:** Over-tuning can create oscillatory behavior (agent flip-flops between modes)
-
----
-
-## Executive Dysfunction Profile
-
-### Concept
-
-A Hebbian-first recall path that bypasses vector similarity entirely. When the agent can't formulate a clear query (analogous to executive dysfunction), it falls back to associative recall: "what have I been thinking about recently?"
-
-### Biological Basis
-
-In executive dysfunction, the prefrontal cortex struggles with **top-down, goal-directed retrieval** — the ability to say "I need to find X" and systematically search for it. However, **bottom-up, associative recall** remains intact — memories surface via association chains rather than directed search.
-
-This is common in ADHD: you can't remember the specific thing you were looking for, but a tangential mention triggers a cascade of related memories. The [STDP infrastructure](../memory/hebbian.md#offheapedgetable--directed-stdp-edges) now makes this possible — directed causal edges encode "thinking about A leads to thinking about B."
-
-### Proposed Architecture
-
-```mermaid
-flowchart TD
-    Q["Query: 'I was working on something...'"] --> D{"Executive<br/>Dysfunction<br/>Profile?"}
-    D -->|No| VS["Standard: Vector Search"]
-    D -->|Yes| STDP["STDP Edge Lookup"]
-    
-    STDP --> CT["Get context tags from<br/>recent recall history"]
-    CT --> CE["Follow causal edges<br/>(predictive strength > 0.3)"]
-    CE --> R1["Memory: database config"]
-    CE --> R2["Memory: connection pool tuning"]
-    CE --> R3["Memory: timeout settings"]
-    
-    VS --> S["6-Phase Scoring Pipeline"]
-    
-    R1 --> M["Merge & Rank"]
-    R2 --> M
-    R3 --> M
-    S --> M
-    M --> F["Final Results"]
-
-    style STDP fill:#e74c3c,color:white
-    style CE fill:#e74c3c,color:white
-```
-
-### Recall Algorithm
-
-1. **Collect context tags** from the last N recall results (default N=10)
-2. **Query STDP edges** for all causal predictions from those context tags
-3. **Filter edges** by predictive strength threshold (default > 0.3)
-4. **Retrieve memories** whose synaptic tags match the predicted tags
-5. **Rank by STDP weight** instead of vector similarity
-6. **Optionally blend** with a low-weight vector search for hybrid results
-
-### Key Differences from Standard Recall
-
-| Aspect | Standard Recall | Executive Dysfunction |
-|:---|:---|:---|
-| Primary signal | Vector similarity | STDP causal edges |
-| Query requirement | Clear, specific query | Vague or absent query |
-| Scoring formula | $\alpha \cdot sim + \beta \cdot imp \cdot decay$ | $stdp\_weight \cdot recency$ |
-| Tag usage | Bloom filter pre-screen | Primary retrieval key |
-| Lateral mode | Optional (DIVERGENT) | Always enabled |
-
-### Implementation Sketch
-
-```java
-public List<CognitiveResult> recallAssociative(RecallOptions options) {
-    // Step 1: Collect recent context tags
-    Set<String> contextTags = recallHistory.recentTags(10);
-    
-    // Step 2: Query STDP for causal predictions
-    Map<String, Float> predictions = new LinkedHashMap<>();
-    for (String tag : contextTags) {
-        tracker.getStdpEdgesFrom(tag).forEach((targetTag, weight) -> {
-            if (weight.weight() > 0.3f) {
-                predictions.merge(targetTag, weight.weight(), Math::max);
-            }
-        });
-    }
-    
-    // Step 3: Encode predicted tags as a synaptic mask
-    long predictedMask = SynapticTagEncoder.encode(
-        predictions.keySet().toArray(String[]::new));
-    
-    // Step 4: Scan with STDP-weighted scoring
-    var modifiedOptions = options.toBuilder()
-        .synapticTagMask(predictedMask)
-        .alpha(0.1f)   // minimal vector similarity
-        .beta(0.9f)    // importance-dominated
-        .build();
-    
-    return recallPipeline.execute(queryVector, modifiedOptions);
-}
-```
-
-### Dependencies & Complexity
-
-- **Dependencies:** Full STDP (Stage 3) ✅ **Complete** — directed, timestamped edges are live in `CoActivationTracker`
-- **Complexity:** Medium — the STDP infrastructure is the hard part (done). Remaining work is the bypass routing logic and recall history tracking.
-- **Risk:** Cold-start problem — STDP edges are empty until the agent has sufficient recall history
-
----
-
-## Two-Factor Memory Strength (Bjork & Bjork, 1992)
-
-### Concept
-
-Separate **retrieval strength** R(t) from **storage strength** S(t). Currently, Spector uses a single decay curve based on age. The Two-Factor model captures a deeper truth: a memory's *accessibility* (can I recall it now?) and its *durability* (will it survive long-term?) are independent dimensions.
-
-### Biological Basis
-
-The New Theory of Disuse (Bjork & Bjork, 1992) explains several well-known memory phenomena:
-
-| Phenomenon | Explanation via R(t) and S(t) |
-|:---|:---|
-| **Spacing effect** | Spaced retrieval at low R(t) produces higher ΔS than massed retrieval at high R(t) |
-| **Testing effect** | Active retrieval (low R(t)) boosts S(t) more than passive re-study |
-| **Savings in relearning** | High S(t) memory with low R(t) relearns faster than a genuinely new memory |
-| **Tip-of-the-tongue** | High S(t), very low R(t) — the memory is stored but temporarily inaccessible |
-
-### Mathematical Model
-
-**Retrieval strength** decays with time since last access:
-
-$$
-R(t) = e^{-\lambda / S(t) \cdot (t - t_{\text{last}})}
-$$
-
-Where $\lambda$ is the base decay rate (currently modeled by `DecayStrategy.ageToBucket()`).
-
-**Storage strength** increases at each retrieval, with the boost inversely proportional to R(t):
-
-$$
-\Delta S = S_{\text{gain}} \times (1 - R(t))
-$$
-
-This creates the spacing effect: when R(t) is near 0 (memory is hard to retrieve), the storage boost is maximal. When R(t) is near 1 (memory is easily retrieved), the storage boost is minimal.
-
-### Visual Model
-
-```mermaid
-graph LR
-    subgraph "Easy Retrieval (High R)"
-        E1["R(t) = 0.9"] --> E2["ΔS = 0.1 × S_gain"]
-        E2 --> E3["Low storage boost"]
-    end
-    
-    subgraph "Hard Retrieval (Low R)"
-        H1["R(t) = 0.1"] --> H2["ΔS = 0.9 × S_gain"]
-        H2 --> H3["High storage boost"]
-    end
-
-    style E3 fill:#f39c12,color:white
-    style H3 fill:#27ae60,color:white
-```
-
-### Integration with Existing Header Layout
-
-The `storage_strength` field is already present in the V2 (48B) and V3 (64B) header layouts:
-
-```
-V2 Header Layout (48 bytes):
-  [32B core]                     — shared with V1
-  [1B  arousal]        Offset 32 — emotional intensity
-  [3B  padding]        Offset 33 — alignment
-  [4B  storage_str]    Offset 36 — S(t) ← THIS FIELD
-  [8B  reserved]       Offset 40 — future use
-```
-
-**Current default:** `storage_strength = 1.0f` for all new memories. The field is written and read but not yet used in scoring.
-
-### Proposed Scoring Integration
-
-The current scoring formula:
-
-$$
-\text{score} = \alpha \cdot \text{similarity} + \beta \cdot \text{importance} \cdot \text{decay}(t)
-$$
-
-Would become:
-
-$$
-\text{score} = \alpha \cdot \text{similarity} + \beta \cdot \text{importance} \cdot R(t) \cdot S(t)^{0.3}
-$$
-
-Where $S(t)^{0.3}$ provides a gentle boost for well-stored memories without dominating the score.
-
-### Wiring into `reinforce()`
-
-The `reinforce()` path in `DefaultSpectorMemory` already updates valence and recall count. The Two-Factor update would add:
-
-```java
-public void reinforce(String memoryId, byte valence) {
-    MemoryLocation loc = index.lookup(memoryId);
-    MemorySegment segment = tierRouter.segmentFor(loc.type());
-    long offset = loc.offset();
-    
-    // Existing: update valence
-    segment.set(LAYOUT_VALENCE, offset + OFFSET_VALENCE, valence);
-    
-    // Existing: increment recall count (atomic CAS)
-    int recallCount = incrementRecallCount(segment, offset);
-    
-    // NEW: Two-Factor update
-    if (layout.headerLayout().headerBytes() >= 48) {  // V2+
-        long timestamp = segment.get(LAYOUT_TIMESTAMP, offset + OFFSET_TIMESTAMP);
-        float currentS = segment.get(LAYOUT_STORAGE_STRENGTH, offset + OFFSET_STORAGE_STRENGTH);
-        
-        // Compute current R(t)
-        float ageFraction = DecayStrategy.decay(
-            DecayStrategy.ageToBucket(timestamp, System.currentTimeMillis()));
-        
-        // ΔS = S_gain × (1 - R(t)) — maximum boost when retrieval is hard
-        float deltaS = S_GAIN * (1.0f - ageFraction);
-        float newS = Math.min(currentS + deltaS, MAX_STORAGE_STRENGTH);
-        
-        segment.set(LAYOUT_STORAGE_STRENGTH, offset + OFFSET_STORAGE_STRENGTH, newS);
-    }
-}
-```
-
-### Calibration Challenges
-
-| Parameter | Proposed Default | Notes |
-|:---|:---|:---|
-| $S_{\text{gain}}$ | 0.1 | Per-retrieval storage increment |
-| $S_{\text{max}}$ | 5.0 | Cap to prevent runaway storage strength |
-| $\lambda$ | 0.1 | Base decay rate |
-| S(t) exponent in scoring | 0.3 | Gentle boost, prevents S domination |
-
-These need empirical calibration with real agent workloads. The key question: how quickly should storage strength accumulate to produce meaningful behavioral differences?
-
-### Dependencies & Complexity
-
-- **Dependencies:** V2+ header layout (`storage_strength` field) ✅ **Ready** — field exists and is read/written
-- **Complexity:** Medium — formula is simple, calibration is the hard part
-- **Risk:** Miscalibrated S_gain can cause "immortal" memories that never decay
-
----
-
-## Dynamic Quantization Stepping
-
-### Concept
-
-Auto-downgrade vector precision under memory pressure. When off-heap memory usage exceeds a configurable threshold, the system progressively reduces vector quantization from SQ8 (8-bit scalar) to SQ4 (4-bit scalar), trading a small amount of recall accuracy for 2× memory savings.
-
-### Biological Basis
-
-The brain performs a similar optimization — older memories are stored with less perceptual detail (lower precision) but retain their gist (semantic meaning). You remember *that* you had a great dinner, but not the exact flavors. The gist is sufficient for retrieval; the sensory detail is pruned.
-
-### Quantization Precision Impact
-
-| Format | Bits/Dim | Memory/Vector (768d) | Recall@10 Impact |
-|:---|:---:|:---:|:---|
-| FP32 | 32 | 3,072 bytes | Baseline |
-| SQ8 (current) | 8 | 768 bytes | ~0.5% degradation |
-| SQ4 (proposed) | 4 | 384 bytes | ~2-3% degradation |
-| Binary | 1 | 96 bytes | ~8-12% degradation |
-
-### Pressure-Based Stepping
-
-```mermaid
-flowchart TD
-    M["Monitor: off-heap usage"] --> C{"Usage > threshold?"}
-    C -->|"< 70%"| OK["Phase 0: Normal (SQ8)"]
-    C -->|"70-85%"| P1["Phase 1: SQ4 oldest 25%"]
-    C -->|"85-95%"| P2["Phase 2: SQ4 all non-pinned"]
-    C -->|"> 95%"| P3["Phase 3: Deep Sleep + aggressive prune"]
-
-    P1 -.- S1["~12% memory saved<br/>~0.5% recall impact"]
-    P2 -.- S2["~50% memory saved<br/>~2% recall impact"]
-    P3 -.- S3["Variable savings<br/>memories permanently lost"]
-
-    style OK fill:#27ae60,color:white
-    style P1 fill:#f39c12,color:white
-    style P2 fill:#e67e22,color:white
-    style P3 fill:#e74c3c,color:white
-```
-
-### SQ4 Encoding
-
-SQ4 packs two dimensions into a single byte using 4-bit uniform quantization:
-
-$$
-q_4(x) = \text{round}\left(\frac{x - \min}{\max - \min} \times 15\right)
-$$
-
-```java
-/**
- * Encodes two float values into a single byte (4 bits each).
- */
-static byte encodeSQ4Pair(float v1, float v2, float min, float scale) {
-    int q1 = Math.clamp(Math.round((v1 - min) / scale * 15f), 0, 15);
-    int q2 = Math.clamp(Math.round((v2 - min) / scale * 15f), 0, 15);
-    return (byte) ((q1 << 4) | q2);
-}
-
-/**
- * Decodes a byte back to two approximate float values.
- */
-static float[] decodeSQ4Pair(byte packed, float min, float scale) {
-    int q1 = (packed >> 4) & 0x0F;
-    int q2 = packed & 0x0F;
-    return new float[]{
-        min + (q1 / 15f) * scale,
-        min + (q2 / 15f) * scale
-    };
-}
-```
-
-### Online Re-Quantization
-
-The critical engineering challenge: re-quantizing vectors **without locking the store**. The proposed approach:
-
-1. **Shadow copy:** Create a parallel SQ4 segment alongside the existing SQ8 segment
-2. **Background conversion:** A background Virtual Thread re-quantizes records in batches of 1,000
-3. **Atomic swap:** Once complete, atomically update the `CognitiveRecordLayout` stride to use SQ4 offsets
-4. **Lazy cleanup:** The old SQ8 bytes become dead space, reclaimed at next compaction
-
-```java
-/**
- * Re-quantizes a batch of records from SQ8 to SQ4 in-place.
- * 
- * Thread safety: uses compare-and-swap on a "quantization version" byte
- * in the header flags to prevent double-conversion.
- */
-public int requantizeBatch(MemorySegment segment, int startRecord, 
-                            int batchSize, CognitiveRecordLayout layout) {
-    int converted = 0;
-    for (int i = startRecord; i < startRecord + batchSize; i++) {
-        long offset = (long) i * layout.stride();
-        byte flags = segment.get(LAYOUT_FLAGS, offset + OFFSET_FLAGS);
-        
-        // Skip pinned, already-SQ4, or tombstoned
-        if (isPinned(flags) || isSQ4(flags) || isTombstoned(flags)) continue;
-        
-        // Read SQ8 vector, re-quantize to SQ4
-        byte[] sq8 = readVector(segment, offset, layout);
-        byte[] sq4 = convertSQ8toSQ4(sq8);
-        
-        // Write SQ4 in-place (half the space)
-        writeVectorSQ4(segment, offset, layout, sq4);
-        
-        // Mark as SQ4 in flags (atomic CAS)
-        setQuantizationFlag(segment, offset, QUANT_SQ4);
-        converted++;
-    }
-    return converted;
-}
-```
-
-### Mixed-Precision Scoring
-
-The `CognitiveScorer` must handle mixed SQ8/SQ4 segments:
-
-```java
-// Phase 5: Vector distance — check quantization format per-record
-byte flags = segment.get(LAYOUT_FLAGS, offset + OFFSET_FLAGS);
-float l2dist;
-if (isSQ4(flags)) {
-    l2dist = SimilarityFunction.EUCLIDEAN.computeSQ4FromSegment(
-        queryVector, segment, layout.vectorOffset(offset),
-        effectiveMins, effectiveScales, layout.quantizedVecBytes() / 2);
-} else {
-    l2dist = SimilarityFunction.EUCLIDEAN.computeQuantizedFromSegment(
-        queryVector, segment, layout.vectorOffset(offset),
-        effectiveMins, effectiveScales, layout.quantizedVecBytes());
-}
-```
-
-### Dependencies & Complexity
-
-- **Dependencies:** ReflectDaemon Phase 0 (memory pressure monitoring), ScalarQuantizer SQ4 support (new)
-- **Complexity:** High — online re-quantization without locking, mixed-precision scoring in the hot loop, SIMD kernel for SQ4 distance computation
-- **Risk:** SQ4 distance computation is not yet SIMD-optimized; 4-bit unpacking adds ~30% overhead per distance call until a dedicated SIMD kernel is written
-
----
-
-## Priority Matrix
-
-| Feature | Value | Complexity | Dependencies Ready? | Estimated Effort |
-|:---|:---:|:---:|:---:|:---|
-| Two-Factor Memory (R+S) | 🟢 High | Medium | ✅ | 1-2 weeks |
-| Executive Dysfunction | 🟡 Medium | Medium | ✅ | 1-2 weeks |
-| Neuromodulatory Gain | 🟡 Medium | High | ⏳ | 3-4 weeks |
-| Dynamic Quantization | 🟡 Medium | High | ⏳ | 4-6 weeks |
-
----
-
-## Contributing to Labs
-
-Labs features are developed on `labs/*` branches and are not merged to `main` until they graduate from experimental status. If you're interested in contributing:
-
-1. Check the [Contributing Guide](../operations/contributing.md)
-2. Open an issue with the `labs` label describing which feature and your proposed approach
-3. Branch from `main` as `labs/feature-name`
-4. Labs branches have relaxed test coverage requirements (60% vs 80% for main)
-5. Features graduate to `main` after passing a design review + benchmark validation
diff --git a/docs/docs/memory/amygdala.md b/docs/docs/memory/amygdala.md
deleted file mode 100644
index 963eec8..0000000
--- a/docs/docs/memory/amygdala.md
+++ /dev/null
@@ -1,139 +0,0 @@
----
-title: "Amygdala — Emotional Valence"
-description: "How ValenceTracker adds emotional coloring to memories — enabling agents to recall by mood, sentiment, and outcome quality."
----
-
-# 😱 Amygdala — Emotional Valence
-
-> **Package**: `com.spectrayan.spector.memory.amygdala`
->
-> **Biological Analog**: The **amygdala** is the brain's emotional processor. It assigns emotional significance to experiences — fear, joy, anger, relief — which profoundly influences how memories are encoded, stored, and retrieved. Emotionally charged memories are remembered more vividly and last longer.
-
----
-
-## The Concept
-
-Every memory in Spector carries a **valence score** — a single byte (`-128` to `+127`) representing its emotional coloring:
-
-| Range | Meaning | Examples |
-|---|---|---|
-| `-128` to `-50` | **Strongly negative** | Critical errors, data loss, security breaches |
-| `-50` to `-10` | **Mildly negative** | Warnings, slow performance, minor bugs |
-| `-10` to `+10` | **Neutral** | Factual information, routine operations |
-| `+10` to `+50` | **Mildly positive** | Successful deployments, optimizations |
-| `+50` to `+127` | **Strongly positive** | Major breakthroughs, user praise, goals achieved |
-
----
-
-## ValenceTracker
-
-The `ValenceTracker` manages emotional coloring of memories:
-
-```java
-public final class ValenceTracker {
-    
-    /**
-     * Computes valence from text content analysis.
-     * Uses keyword-based sentiment detection with configurable weights.
-     */
-    public byte computeValence(String text, MemorySource source) {
-        float score = 0f;
-        
-        // Source-based bias
-        if (source == MemorySource.PROCEDURAL) score += 0.1f;  // Rules are slightly positive
-        if (source == MemorySource.OBSERVED && containsError(text)) score -= 0.5f;
-        
-        // Content-based sentiment
-        score += sentimentScore(text);
-        
-        // Clamp and convert to byte range
-        return (byte) Math.max(-128, Math.min(127, (int)(score * 127)));
-    }
-}
-```
-
----
-
-## Valence-Filtered Recall
-
-The most powerful use of valence is in **recall filtering**. The `RecallOptions` builder supports valence range filtering:
-
-```java
-// Recall only negative-outcome memories (for debugging)
-List<CognitiveResult> errors = memory.recall("database connection",
-    RecallOptions.builder()
-        .topK(10)
-        .maxValence((byte) -10)     // Only negative memories
-        .build());
-
-// Recall only positive outcomes (for best practices)
-List<CognitiveResult> successes = memory.recall("deployment strategy",
-    RecallOptions.builder()
-        .topK(5)
-        .minValence((byte) 10)      // Only positive memories
-        .build());
-```
-
-### Phase 3 — Valence Filter in CognitiveScorer
-
-Valence filtering happens at **Phase 3** of the scoring pipeline — before the expensive SIMD vector math:
-
-```java
-// Phase 3: Valence Filter (~2 cycles)
-byte valence = segment.get(LAYOUT_VALENCE, offset + OFFSET_VALENCE);
-if (valence < minValence || valence > maxValence) continue;
-```
-
-**Cost**: 2 CPU cycles — a single byte read and two comparisons. Records outside the valence range are eliminated before Phase 5's ~200-cycle SIMD computation.
-
----
-
-## Use Cases
-
-### 1. Debugging: "What Went Wrong?"
-
-An agent can filter for negative-valence memories when debugging:
-
-```java
-// "Show me only memories associated with failures"
-memory.recall("connection timeout",
-    RecallOptions.builder()
-        .maxValence((byte) -10)
-        .synapticFilter("database", "error")
-        .build());
-```
-
-### 2. Best Practices: "What Worked Well?"
-
-```java
-// "Show me successful approaches"
-memory.recall("deployment strategy",
-    RecallOptions.builder()
-        .minValence((byte) 10)
-        .synapticFilter("deployment")
-        .build());
-```
-
-### 3. Balanced Recall: Full Emotional Range
-
-By default, no valence filter is applied — the agent sees the full emotional spectrum. The valence still influences recall indirectly because the `FlashbulbPolicy` pins emotionally intense memories at higher importance.
-
----
-
-## Storage
-
-Valence is stored in the 32-byte synaptic header at **offset 30** as a single signed byte:
-
-```
-Offset 30: [1B valence] — signed byte [-128 to +127]
-```
-
-This costs exactly **1 byte per memory** — negligible overhead for a powerful filtering dimension.
-
----
-
-## Next Steps
-
-- :material-link: [**Hebbian — Association Learning**](hebbian.md) — "neurons that fire together wire together"
-- :material-head-cog: [**Dopamine — Surprise Detection**](dopamine.md) — auto-importance scoring
-- :material-lightning-bolt: [**6-Phase Scoring Pipeline**](scoring-pipeline.md) — where valence filtering happens
diff --git a/docs/docs/memory/api-reference.md b/docs/docs/memory/api-reference.md
deleted file mode 100644
index 5fe4e96..0000000
--- a/docs/docs/memory/api-reference.md
+++ /dev/null
@@ -1,243 +0,0 @@
----
-title: API Reference
-description: "Complete API reference for SpectorMemory, RecallOptions, CognitiveResult, and related types."
----
-
-# 📖 API Reference
-
----
-
-## SpectorMemory
-
-The main façade for all cognitive memory operations.
-
-### Builder
-
-```java
-SpectorMemory memory = SpectorMemory.builder()
-    .dimensions(int)                        // Vector dimensionality (required)
-    .embeddingProvider(EmbeddingProvider)    // Embedding provider (required)
-    .workingCapacity(int)                   // Working memory slots (default: 100)
-    .episodicPartitionCapacity(int)         // Records per episodic partition (default: 10,000)
-    .semanticCapacity(int)                  // Semantic memory slots (default: 5,000)
-    .proceduralCapacity(int)                // Procedural memory slots (default: 500)
-    .quantizer(ScalarQuantizer)             // Custom quantizer (default: identity)
-    .persistenceDir(Path)                   // Episodic mmap directory (default: temp dir)
-    .build();
-```
-
-### Core Methods
-
-| Method | Return Type | Description |
-|---|---|---|
-| `remember(id, text, type, source, tags...)` | `CompletableFuture<Void>` | Async ingestion — embeds, quantizes, stores, indexes |
-| `recall(queryText, options)` | `List<CognitiveResult>` | Parallel SIMD-accelerated recall with cognitive scoring |
-| `forget(id)` | `void` | Tombstones a memory (permanent, excluded from all scans) |
-| `suppress(id, reason)` | `void` | Suppresses from recall results (reversible) |
-| `unsuppress(id)` | `void` | Removes suppression |
-| `totalMemories()` | `int` | Total record count across all tiers |
-| `introspect()` | `MemoryIntrospector` | Memory health analytics |
-| `close()` | `void` | Releases all off-heap memory and file handles |
-
----
-
-## RecallOptions
-
-Builder for recall query configuration.
-
-```java
-RecallOptions options = RecallOptions.builder()
-    .topK(int)                              // Max results (default: 10)
-    .synapticFilter(String... tags)         // Bloom filter pre-screen
-    .minImportance(float)                   // Minimum importance [0.0-1.0] (default: 0.0)
-    .memoryTypes(MemoryType... types)       // Tier filter (default: all)
-    .minValence(byte)                       // Min emotional valence (default: -128)
-    .maxValence(byte)                       // Max emotional valence (default: +127)
-    .alpha(float)                           // Similarity weight (default: 0.6)
-    .beta(float)                            // Importance × decay weight (default: 0.4)
-    .build();
-```
-
-### Default Options
-
-```java
-RecallOptions.DEFAULT  // topK=10, no filters, alpha=0.6, beta=0.4
-```
-
-### Scoring Formula
-
-$$\text{FinalScore} = \alpha \cdot \text{Similarity} + \beta \cdot \text{Importance} \cdot \text{Decay}$$
-
-Where:
-
-- **Similarity** = `1 / (1 + L2_distance)` — semantic relevance
-- **Importance** = `[0.0 - 1.0]` — computed by SurpriseDetector at ingestion
-- **Decay** = precomputed bucket lookup based on memory age
-
----
-
-## CognitiveResult
-
-Immutable record returned by `recall()`:
-
-```java
-public record CognitiveResult(
-    String id,                // Unique memory identifier
-    String text,              // Raw text content
-    float score,              // Final cognitive score (after habituation)
-    float importance,         // Original importance at ingestion
-    float ageDays,            // Age in fractional days
-    short recallCount,        // Times previously recalled
-    byte valence,             // Emotional coloring [-128 to +127]
-    MemoryType memoryType,    // Cognitive tier (WORKING/EPISODIC/SEMANTIC/PROCEDURAL)
-    MemorySource source,      // Provenance (USER_STATED/OBSERVED/PROCEDURAL/...)
-    String[] synapticTags,    // Decoded tag labels
-    float decayFactor,        // Current temporal decay multiplier
-    float ltpAdjustedDecay    // Decay after reconsolidation adjustment
-) {}
-```
-
----
-
-## MemoryType
-
-Enum representing the four cognitive tiers:
-
-```java
-public enum MemoryType {
-    WORKING,      // Prefrontal Cortex — volatile circular buffer
-    EPISODIC,     // Hippocampus — time-partitioned mmap
-    SEMANTIC,     // Neocortex — permanent knowledge
-    PROCEDURAL    // Basal Ganglia — learned procedures
-}
-```
-
----
-
-## MemorySource
-
-Provenance tracking for memory origin:
-
-```java
-public enum MemorySource {
-    USER_STATED,   // Explicit user input
-    OBSERVED,      // System observation (logs, events)
-    INFERRED,      // AI inference
-    PROCEDURAL,    // Rule or procedure
-    CONSOLIDATED   // Created by sleep consolidation (ReflectDaemon)
-}
-```
-
----
-
-## SynapticTagEncoder
-
-64-bit inline Bloom filter encoder:
-
-```java
-// Encode tags into a Bloom filter
-long mask = SynapticTagEncoder.encode("java", "debugging", "performance");
-
-// Check if a record matches (containment check)
-long recordTags = layout.readSynapticTags(segment, offset);
-boolean matches = (recordTags & mask) == mask;
-
-// Match individual tag
-boolean hasJava = SynapticTagEncoder.matches(recordTags, "java");
-```
-
----
-
-## CognitiveRecordLayout
-
-Binary layout for the 32-byte header + quantized vector:
-
-```java
-CognitiveRecordLayout layout = new CognitiveRecordLayout(quantizedVecBytes);
-
-// Record stride (header + vector)
-int stride = layout.stride();            // e.g., 800 for 768-dim INT8
-
-// Read/write header
-CognitiveHeader header = layout.readHeader(segment, offset);
-layout.writeHeader(segment, offset, header);
-
-// Read individual fields
-long tags = layout.readSynapticTags(segment, offset);
-float importance = layout.readImportance(segment, offset);
-
-// Merge tags (OR operation for co-activation)
-layout.mergeSynapticTags(segment, offset, additionalTags);
-```
-
-### CognitiveHeader
-
-```java
-public record CognitiveHeader(
-    long timestampMs,       // Unix epoch milliseconds
-    long synapticTags,      // 64-bit Bloom filter
-    float exactNorm,        // L2 norm of original float vector
-    float importance,       // Cognitive importance [0.0 – 1.0]
-    int centroidId,         // IVF centroid assignment
-    short recallCount,      // Reconsolidation counter
-    byte valence,           // Emotional coloring
-    byte flags              // Bit flags: [0] tombstone, [1] pinned
-) {}
-```
-
----
-
-## ReflectReport
-
-Summary of a sleep consolidation cycle:
-
-```java
-public record ReflectReport(
-    int partitionsProcessed,
-    int memoriesConsolidated,
-    int semanticMemoriesCreated,
-    long durationMs
-) {}
-```
-
----
-
-## EpisodicPartition
-
-A single time-partitioned episodic memory file:
-
-```java
-// Access partition data
-int count = partition.count();
-int tombstoneCount = partition.tombstoneCount();
-float tombstoneRatio = partition.tombstoneRatio();
-PartitionState state = partition.state();
-MemorySegment segment = partition.segment();
-CognitiveRecordLayout layout = partition.layout();
-
-// Lifecycle operations
-partition.seal();                          // Prevent further writes
-partition.setState(PartitionState.REFLECTABLE);
-partition.force();                          // Flush to disk
-partition.close();                          // Release resources
-```
-
-### PartitionState
-
-```java
-public enum PartitionState {
-    ACTIVE,       // Accepting writes
-    SEALED,       // Read-only, awaiting consolidation
-    REFLECTABLE,  // Consolidation complete, eligible for pruning
-    TOMBSTONED,   // High tombstone ratio, queued for compaction
-    COMPACTED     // Rebuilt as dense partition
-}
-```
-
----
-
-## Next Steps
-
-- :material-rocket: [**Getting Started**](getting-started.md) — set up in 5 minutes
-- :material-brain: [**Architecture**](architecture.md) — how it all fits together
-- :material-speedometer: [**Performance**](performance.md) — benchmark results
diff --git a/docs/docs/memory/architecture.md b/docs/docs/memory/architecture.md
deleted file mode 100644
index 630b686..0000000
--- a/docs/docs/memory/architecture.md
+++ /dev/null
@@ -1,263 +0,0 @@
----
-title: System Architecture
-description: "Package hierarchy, data flow, and extensibility model for Spector Memory."
----
-
-# System Architecture
-
-Spector Memory is organized around a **biological metaphor** where each Java package corresponds to a brain region or cognitive mechanism. This isn't just naming — the architecture genuinely mirrors how biological memory systems interact.
-
----
-
-## Extensibility
-
-| Component | Extension point | What you can customize |
-|---|---|---|
-| `SpectorMemory` | Single entry point for all operations | Configure tiers, capacities, embedding providers |
-| `TierStore` interface | Add new memory tiers | Implement the interface + register in `TierRouter` — no other changes needed |
-| `AbstractTierStore` | Common tier lifecycle | Extend for new off-heap tier stores with Arena/segment management |
-| `RecallListener` | Post-recall hooks | Add async listeners for co-activation tracking, logging, metrics |
-| `CognitiveIngestionTarget` / `RecallPipeline` | Discrete processing steps | Each step is independently testable and replaceable |
-
----
-
-## Data Flow: Ingestion
-
-The ingestion pipeline is split across two layers:
-
-- **`IngestionPipeline`** (in `spector-ingestion`) — handles step 1 (embed) and chunking for large documents
-- **`CognitiveIngestionTarget`** (in `spector-memory`) — handles steps 2–9 (synaptic encoding → WAL)
-
-```mermaid
-sequenceDiagram
-    participant App as Application
-    participant SM as SpectorMemory
-    participant CT as CognitiveIngestionTarget
-    participant EP as EmbeddingProvider
-    participant SD as SurpriseDetector
-    participant FP as FlashbulbPolicy
-    participant SQ as ScalarQuantizer
-    participant TR as TierRouter
-    participant MI as MemoryIndex
-    participant WAL as MemoryWal
-    participant HG as HebbianGraph
-    participant TC as TemporalChain
-    participant EG as EntityGraph
-
-    App->>SM: remember(id, text, type, tags)
-    SM->>CT: ingestCognitive(id, text, vector, type, tags, ...)
-    
-    Note over CT: Step 1: Embed (done by unified IngestionPipeline)
-    Note over CT: or via CognitiveIngestionTarget.ingestCognitive()
-    CT->>EP: embed(text)
-    EP-->>CT: float[4096]
-    
-    Note over CT: Step 2: Encode tags
-    CT->>CT: SynapticTagEncoder.encode(tags) → 64-bit Bloom
-    
-    Note over CT: Step 3: Surprise detection
-    CT->>SD: computeImportance(l2Norm)
-    SD-->>CT: importance (0.0 – 1.0)
-    
-    Note over CT: Step 4: Flashbulb check
-    CT->>FP: evaluate(zScore)
-    FP-->>CT: flashbulb? → pin + max importance
-    
-    Note over CT: Step 5: Quantize
-    CT->>SQ: encode(float[]) → byte[]
-    
-    Note over CT: Step 6: Build header
-    CT->>CT: CognitiveHeader(timestamp, tags, importance, ...)
-    
-    Note over CT: Step 7: Route & write
-    CT->>TR: write(type, header, quantized)
-    TR-->>CT: byte offset
-    
-    Note over CT: Step 8: Index
-    CT->>MI: register(id, location, text, source, tags)
-    
-    Note over CT: Step 9a: WAL
-    CT->>WAL: appendRemember(id, quantized)
-    
-    Note over CT: Step 9b: Hebbian edge strengthening
-    CT->>HG: strengthen(currentIdx, previousIdx, 1.0f)
-    
-    Note over CT: Step 9c: Temporal chain linking
-    CT->>TC: link(currentIdx, lastIdx, sessionId)
-    
-    Note over CT: Step 9d: Entity extraction & graph population
-    CT->>EG: addEntity() + linkToMemory() + addRelation()
-    
-    Note over CT: Step 10: Circadian check
-    CT->>CT: triggerReflectIfDue()
-```
-
-> [!NOTE]
-> When ingestion comes through the unified `IngestionPipeline` (e.g., file ingestion), embedding (step 1) is handled by the pipeline itself. `CognitiveIngestionTarget.ingest()` receives a pre-embedded vector and executes steps 2–9. When called via `SpectorMemory.remember()`, `CognitiveIngestionTarget.ingestCognitive()` handles embedding internally.
-
-> [!NOTE]
-> Steps 9b–9d are **gracefully degrading**: if any graph component is null (not configured) or throws, the step is skipped with a `log.warn()` and ingestion continues normally.
-
----
-
-## Data Flow: Recall
-
-The recall pipeline executes parallel tier scans using Virtual Threads:
-
-```mermaid
-sequenceDiagram
-    participant App as Application
-    participant RP as RecallPipeline
-    participant EP as EmbeddingProvider
-    participant PS as ProspectiveScheduler
-    participant CT as ConcurrentTasks
-    participant CS as CognitiveScorer
-    participant SS as SuppressionSet
-    participant HP as HabituationPenalty
-    participant HG as HebbianGraph
-    participant TC as TemporalChain
-    participant EG as EntityGraph
-
-    App->>RP: recall("query", options)
-    
-    Note over RP: Step 1: Embed query
-    RP->>EP: embed("query")
-    EP-->>RP: float[4096]
-    
-    Note over RP: Step 2: Prospective reminders
-    RP->>PS: collectDue()
-    PS-->>RP: due reminders
-    
-    Note over RP: Step 3: Parallel tier scanning
-    RP->>CT: forkJoinAll(scanTasks)
-    
-    par Working Memory
-        CT->>CS: score(workingSegment, ...)
-    and Episodic Partition 1
-        CT->>CS: score(partition1, ...)
-    and Episodic Partition 2
-        CT->>CS: score(partition2, ...)
-    and Semantic
-        CT->>CS: score(semanticSlab, ...)
-    and Procedural
-        CT->>CS: score(proceduralSegment, ...)
-    end
-    
-    CS-->>RP: List<ScoredRecord>
-    
-    Note over RP: Step 4: Filter suppressed
-    RP->>SS: isSuppressed(id)?
-    
-    Note over RP: Step 5a: Habituation penalty
-    RP->>HP: recordAndComputePenalty(id)
-    
-    Note over RP: Step 5b: STDP causal boost
-    RP->>RP: CoActivationTracker.getPredictiveStrength()
-    
-    Note over RP: Step 5c: Hebbian spreading activation
-    RP->>HG: activateNeighbors(seedIdx, depth=2)
-    HG-->>RP: graph-activated memory indices
-    
-    Note over RP: Step 5d: Temporal chain extension
-    RP->>TC: followForward/Backward(idx, maxHops=3)
-    TC-->>RP: temporally-linked memory indices
-    
-    Note over RP: Step 5e: Entity graph traversal
-    RP->>EG: extract query entities → BFS 2-hop
-    EG-->>RP: entity-linked memory indices
-    
-    Note over RP: Step 6: Merge, dedup, sort → final top-K
-    RP-->>App: List<CognitiveResult>
-    
-    Note over RP: Step 7: Async listeners (Virtual Thread)
-    RP->>RP: notify(HebbianListener, LtpListener)
-```
-
----
-
-## Package Dependency Graph
-
-```mermaid
-graph LR
-    SM[SpectorMemory<br/>Façade] --> CT[pipeline/<br/>CognitiveIngestionTarget]
-    SM --> RP[pipeline/<br/>RecallPipeline]
-    SM --> TR[cortex/<br/>TierRouter]
-    SM --> MI[index/<br/>MemoryIndex]
-    
-    CT --> EP[embed-api/<br/>EmbeddingProvider]
-    CT --> SQ[core/<br/>ScalarQuantizer]
-    CT --> SD[dopamine/<br/>SurpriseDetector]
-    CT --> TR
-    CT --> MI
-    CT --> WAL[sync/<br/>MemoryWal]
-    CT --> HG[hebbian/<br/>HebbianGraph]
-    CT --> TC[temporal/<br/>TemporalChain]
-    CT --> EG[graph/<br/>EntityGraph]
-    CT --> EX[graph/<br/>EntityExtractor]
-    
-    RP --> EP
-    RP --> CS[synapse/<br/>CognitiveScorer]
-    RP --> TR
-    RP --> MI
-    RP --> SS[inhibition/<br/>SuppressionSet]
-    RP --> HP[habituation/<br/>HabituationPenalty]
-    RP --> HG
-    RP --> TC
-    RP --> EG
-    
-    CS --> SF[core/<br/>SimilarityFunction]
-    CS --> DS[synapse/<br/>DecayStrategy]
-    
-    TR --> WM[cortex/<br/>WorkingMemoryStore]
-    TR --> EM[cortex/<br/>EpisodicMemoryStore]
-    TR --> SE[cortex/<br/>SemanticMemoryStore]
-    TR --> PR[cortex/<br/>ProceduralMemoryStore]
-    
-    RP -.->|async| HL[pipeline/<br/>HebbianListener]
-    RP -.->|async| LL[pipeline/<br/>LtpListener]
-    
-    style SM fill:#4a90d9,color:white
-    style CS fill:#e74c3c,color:white
-    style TR fill:#2ecc71,color:white
-    style HG fill:#e74c3c,color:white
-    style EG fill:#9b59b6,color:white
-    style TC fill:#f39c12,color:white
-```
-
----
-
-## The 32-Byte Cognitive Record
-
-Every memory is stored as a fixed-size binary record in off-heap memory:
-
-```
-┌──────────────────────────────────────────────────────────┐
-│                   32-Byte Synaptic Header                 │
-├────────────┬──────────┬──────────┬────────┬──────────────┤
-│ timestamp  │ synaptic │ exactNorm│ import │ centroidId   │
-│ 8 bytes    │ tags     │ 4 bytes  │ ance   │ 4 bytes      │
-│ (offset 0) │ 8 bytes  │ (off 16) │ 4 bytes│ (offset 24)  │
-│            │ (off 8)  │          │(off 20)│              │
-├────────────┴──────────┴──────────┴────────┼──────┬───┬───┤
-│                                           │recall│val│flg│
-│              (continued)                  │count │enc│s  │
-│                                           │2B    │1B │1B │
-│                                           │off 28│o30│o31│
-├───────────────────────────────────────────┴──────┴───┴───┤
-│              Quantized Vector (N bytes)                   │
-│              INT8 values, 32-byte aligned                 │
-└──────────────────────────────────────────────────────────┘
-```
-
-**Total record size** = 32 (header) + N (quantized vector bytes), aligned to 32 bytes.
-
-At 768 dimensions (INT8): **32 + 768 = 800 bytes/memory** — 50,000 memories fit in 40 MB of off-heap RAM.
-
----
-
-## Next Steps
-
-- :material-lightning-bolt: [**6-Phase Scoring Pipeline**](scoring-pipeline.md) — the SIMD hot-loop that makes it fast
-- :material-share-variant: [**3-Layer Cognitive Graph**](hebbian.md) — Hebbian, Entity, and Temporal graphs
-- :material-brain: [**Cortex — Tier Stores**](cortex.md) — the 4-tier memory architecture
-- :material-memory: [**Off-Heap Panama Design**](panama-design.md) — zero-GC binary layout
diff --git a/docs/docs/memory/biological-systems.md b/docs/docs/memory/biological-systems.md
deleted file mode 100644
index c9c2ba4..0000000
--- a/docs/docs/memory/biological-systems.md
+++ /dev/null
@@ -1,230 +0,0 @@
----
-title: "Biological Systems — Overview"
-description: "How Spector Memory maps neuroscience concepts to code — a guided tour of the 12 cognitive subsystems and their biological foundations."
----
-
-# 🧬 Biological Systems — Overview
-
-Spector Memory doesn't just borrow neuroscience *terminology* — it implements the actual **computational principles** behind biological memory. Each package in `spector-memory` corresponds to a distinct brain region or cognitive mechanism, implementing the mathematical models that neuroscientists have validated over decades of research.
-
----
-
-## The Brain–Code Mapping
-
-```mermaid
-graph TB
-    subgraph "Encoding & Storage"
-        STE["🧩 Synapse<br/>Synaptic Tags & Scoring<br/><i>Bloom filter + binary layout</i>"]
-        CT["🧠 Cortex<br/>4-Tier Memory Stores<br/><i>Working → Episodic → Semantic → Procedural</i>"]
-    end
-
-    subgraph "Emotional & Importance Modulation"
-        DA["⚡ Dopamine<br/>Surprise Detection<br/><i>Welford Z-score → importance</i>"]
-        AM["❤️ Amygdala<br/>Emotional Valence<br/><i>-128 to +127 coloring</i>"]
-    end
-
-    subgraph "Retrieval Dynamics"
-        HB["🛑 Habituation<br/>Anti-Filter Bubble<br/><i>Repetition penalty</i>"]
-        IN["🚫 Inhibition<br/>Suppression Set<br/><i>Inhibition of return</i>"]
-        IF["🔀 Interference<br/>Deduplication<br/><i>Proactive/retroactive</i>"]
-    end
-
-    subgraph "Association & Learning"
-        HE["🔗 3-Layer Cognitive Graph<br/>Hebbian + Entity + Temporal<br/><i>Off-heap graph structures</i>"]
-    end
-
-    subgraph "Consolidation & Planning"
-        HP["💤 Hippocampus<br/>Sleep Consolidation<br/><i>ReflectDaemon cycle</i>"]
-        PR["📋 Prospective<br/>Future Intents<br/><i>Scheduled reminders</i>"]
-        MM["🔍 Metamemory<br/>Self-Reflection<br/><i>Confidence calibration</i>"]
-    end
-
-    DA --> STE
-    AM --> STE
-    STE --> CT
-    CT --> HE
-    HE --> HP
-
-    style HE fill:#e74c3c,color:white
-    style DA fill:#f39c12,color:white
-    style HP fill:#9b59b6,color:white
-```
-
----
-
-## Systems at a Glance
-
-| System | Brain Region | Key Concept | Spector Implementation | Reference |
-|---|---|---|---|---|
-| [**Cortex**](cortex.md) | Prefrontal, Hippocampus, Neocortex, Basal Ganglia | Multi-store memory model | 4-tier off-heap stores (Working, Episodic, Semantic, Procedural) | Atkinson & Shiffrin, 1968[^1] |
-| [**Synapse**](synapse.md) | Synaptic junction | Synaptic tagging & capture | 64-bit Bloom filter tag encoding, 32B binary header | Frey & Morris, 1997[^2] |
-| [**Dopamine**](dopamine.md) | Ventral tegmental area | Prediction error signaling | Welford Z-score surprise detection, flashbulb encoding | Schultz, 1997[^3] |
-| [**Amygdala**](amygdala.md) | Amygdala | Emotional memory modulation | Signed valence byte (-128 to +127), emotional filtering | McGaugh, 2004[^4] |
-| [**3-Layer Graph**](hebbian.md) | Cortical networks, Hippocampus | Hebbian learning, STDP, episodic sequences | Off-heap HebbianGraph, EntityGraph, TemporalChain | Hebb, 1949[^5]; Bi & Poo, 2001[^6] |
-| [**Habituation**](habituation.md) | Sensory cortex | Response decrement to repetition | Exponential penalty on repeated recall | Thompson & Spencer, 1966[^7] |
-| [**Inhibition**](inhibition.md) | Prefrontal cortex | Inhibition of return | SuppressionSet with TTL-based suppression windows | Klein, 2000[^8] |
-| [**Interference**](interference.md) | Hippocampus | Proactive/retroactive interference | Similarity-based deduplication during ingestion | Underwood, 1957[^9] |
-| [**Hippocampus**](hippocampus.md) | Hippocampus | Sleep consolidation & replay | ReflectDaemon: decay, compaction, episodic→semantic promotion | Rasch & Born, 2013[^10] |
-| [**Prospective**](prospective.md) | Prefrontal cortex | Prospective memory | Scheduled future intent reminders | Einstein & McDaniel, 1990[^11] |
-| [**Metamemory**](metamemory.md) | Prefrontal cortex | Metacognitive monitoring | Confidence calibration, recall quality estimation | Nelson & Narens, 1990[^12] |
-| [**Sync**](sync.md) | — (engineering) | Persistence & replication | WAL + mmap-backed partitions | — |
-
----
-
-## Key Mathematical Models
-
-### Temporal Decay (Ebbinghaus Forgetting Curve)
-
-Spector approximates the exponential forgetting curve using precomputed decay buckets — avoiding expensive `Math.exp()` calls in the hot loop:
-
-$$R(t) = e^{-\lambda t / S}$$
-
-Where $R(t)$ is retrieval strength, $\lambda$ is the decay rate, $t$ is time since encoding, and $S$ is storage strength. Spector discretizes this into 9 buckets (see [Scoring Pipeline](scoring-pipeline.md)).
-
-> **Reference**: Ebbinghaus, H. (1885). *Über das Gedächtnis*[^13]
-
-### Reconsolidation (Spacing Effect)
-
-Each recall shifts the decay bucket backward, simulating how retrieved memories become more durable:
-
-$$\text{adjustedBucket} = \text{rawBucket} - \lfloor \text{recallCount} / 3 \rfloor$$
-
-> **Reference**: Bjork & Bjork (1992). *A New Theory of Disuse*[^14]
-
-### Surprise Detection (Dopamine Prediction Error)
-
-The importance signal uses a Z-score from Welford's online statistics:
-
-$$\text{importance} = \alpha \cdot \sigma\left(\frac{x - \mu}{\sigma}\right) + \beta \cdot \text{temporalNovelty}$$
-
-Where $\sigma()$ is the sigmoid function, $\alpha = 0.6$, $\beta = 0.4$.
-
-> **Reference**: Schultz, W. (1997). *A neural substrate of prediction and reward*[^3]
-
-### Hebbian Edge Strengthening
-
-Co-ingested memories strengthen their bidirectional edge:
-
-$$w_{ij}(t+1) = w_{ij}(t) + \Delta w$$
-
-With decay during consolidation: $w_{ij}(t+1) = 0.9 \cdot w_{ij}(t)$
-
-> **Reference**: Hebb, D.O. (1949). *The Organization of Behavior*[^5]
-
-### STDP — Spike-Timing Dependent Plasticity
-
-Directed causal edges are strengthened when tag A is recalled *before* tag B:
-
-$$\Delta w = \begin{cases} A_+ \cdot e^{-\Delta t / \tau_+} & \text{if } \Delta t > 0 \text{ (causal)} \\ -A_- \cdot e^{\Delta t / \tau_-} & \text{if } \Delta t < 0 \text{ (anti-causal)} \end{cases}$$
-
-> **Reference**: Bi & Poo (2001). *Synaptic modification by correlated activity*[^6]
-
-### Habituation Penalty
-
-Repeated recall of the same memory incurs an exponentially increasing penalty:
-
-$$\text{penalty}(n) = 1 - e^{-\gamma \cdot n}$$
-
-Where $n$ is the number of times the memory appeared in recent results and $\gamma$ controls penalty steepness.
-
-> **Reference**: Thompson & Spencer (1966). *Habituation: A model phenomenon*[^7]
-
----
-
-## Design Principles
-
-1. **Fidelity to neuroscience**: Each system implements a real cognitive mechanism, not just a metaphor. The mathematical models are drawn from peer-reviewed research.
-
-2. **Independent testability**: Each biological system is a standalone package with its own unit tests. Systems compose via dependency injection, not inheritance.
-
-3. **Graceful degradation**: Every system is optional. Disabling surprise detection, habituation, or graph augmentation produces a functional (if less intelligent) memory system.
-
-4. **Performance-first biology**: Biological accuracy is constrained by microsecond latency requirements. Where exact models are too expensive (e.g., continuous exponential decay), we use precomputed approximations (decay buckets, Bloom filter tags).
-
----
-
-## Explore Each System
-
-<div class="grid cards" markdown>
-
--   :material-brain:{ .lg .middle } **Cortex — Tier Stores**
-
-    ---
-
-    Working, Episodic, Semantic, and Procedural memory tiers
-
-    [:octicons-arrow-right-24: Cortex](cortex.md)
-
--   :material-flash:{ .lg .middle } **Synapse — Tags & Scoring**
-
-    ---
-
-    Bloom filter encoding, binary layout, 6-phase scorer
-
-    [:octicons-arrow-right-24: Synapse](synapse.md)
-
--   :material-head-lightning-bolt:{ .lg .middle } **Dopamine — Surprise**
-
-    ---
-
-    Welford Z-score, flashbulb encoding, importance scoring
-
-    [:octicons-arrow-right-24: Dopamine](dopamine.md)
-
--   :material-heart:{ .lg .middle } **Amygdala — Valence**
-
-    ---
-
-    Emotional coloring, valence-based filtering
-
-    [:octicons-arrow-right-24: Amygdala](amygdala.md)
-
--   :material-share-variant:{ .lg .middle } **3-Layer Cognitive Graph**
-
-    ---
-
-    Hebbian, Entity-Relationship, and Temporal Causal graphs
-
-    [:octicons-arrow-right-24: Cognitive Graph](hebbian.md)
-
--   :material-sleep:{ .lg .middle } **Hippocampus — Consolidation**
-
-    ---
-
-    Sleep cycles, decay, episodic-to-semantic promotion
-
-    [:octicons-arrow-right-24: Hippocampus](hippocampus.md)
-
-</div>
-
----
-
-## References
-
-[^1]: Atkinson, R.C. & Shiffrin, R.M. (1968). Human memory: A proposed system and its control processes. In *Psychology of Learning and Motivation*, 2, 89–195. [doi:10.1016/S0079-7421(08)60422-3](https://doi.org/10.1016/S0079-7421(08)60422-3)
-
-[^2]: Frey, U. & Morris, R.G.M. (1997). Synaptic tagging and long-term potentiation. *Nature*, 385, 533–536. [doi:10.1038/385533a0](https://doi.org/10.1038/385533a0)
-
-[^3]: Schultz, W. (1997). A neural substrate of prediction and reward. *Science*, 275(5306), 1593–1599. [doi:10.1126/science.275.5306.1593](https://doi.org/10.1126/science.275.5306.1593)
-
-[^4]: McGaugh, J.L. (2004). The amygdala modulates the consolidation of memories of emotionally arousing experiences. *Annual Review of Neuroscience*, 27, 1–28. [doi:10.1146/annurev.neuro.27.070203.144157](https://doi.org/10.1146/annurev.neuro.27.070203.144157)
-
-[^5]: Hebb, D.O. (1949). *The Organization of Behavior: A Neuropsychological Theory*. New York: Wiley.
-
-[^6]: Bi, G. & Poo, M. (2001). Synaptic modification by correlated activity: Hebb's postulate revisited. *Annual Review of Neuroscience*, 24, 139–166. [doi:10.1146/annurev.neuro.24.1.139](https://doi.org/10.1146/annurev.neuro.24.1.139)
-
-[^7]: Thompson, R.F. & Spencer, W.A. (1966). Habituation: A model phenomenon for the study of neuronal substrates of behavior. *Psychological Review*, 73(1), 16–43. [doi:10.1037/h0022681](https://doi.org/10.1037/h0022681)
-
-[^8]: Klein, R.M. (2000). Inhibition of return. *Trends in Cognitive Sciences*, 4(4), 138–147. [doi:10.1016/S1364-6613(00)01452-2](https://doi.org/10.1016/S1364-6613(00)01452-2)
-
-[^9]: Underwood, B.J. (1957). Interference and forgetting. *Psychological Review*, 64(1), 49–60. [doi:10.1037/h0044616](https://doi.org/10.1037/h0044616)
-
-[^10]: Rasch, B. & Born, J. (2013). About sleep's role in memory. *Physiological Reviews*, 93(2), 681–766. [doi:10.1152/physrev.00032.2012](https://doi.org/10.1152/physrev.00032.2012)
-
-[^11]: Einstein, G.O. & McDaniel, M.A. (1990). Normal aging and prospective memory. *Journal of Experimental Psychology: Learning, Memory, and Cognition*, 16(4), 717–726. [doi:10.1037/0278-7393.16.4.717](https://doi.org/10.1037/0278-7393.16.4.717)
-
-[^12]: Nelson, T.O. & Narens, L. (1990). Metamemory: A theoretical framework and new findings. In *Psychology of Learning and Motivation*, 26, 125–173. [doi:10.1016/S0079-7421(08)60053-5](https://doi.org/10.1016/S0079-7421(08)60053-5)
-
-[^13]: Ebbinghaus, H. (1885). *Über das Gedächtnis: Untersuchungen zur experimentellen Psychologie*. Leipzig: Duncker & Humblot. English translation: *Memory: A Contribution to Experimental Psychology* (1913).
-
-[^14]: Bjork, R.A. & Bjork, E.L. (1992). A new theory of disuse and an old theory of stimulus fluctuation. In *From Learning Processes to Cognitive Processes: Essays in Honor of William K. Estes*, 2, 35–67.
diff --git a/docs/docs/memory/cognitive-profiles.md b/docs/docs/memory/cognitive-profiles.md
deleted file mode 100644
index e3b90e4..0000000
--- a/docs/docs/memory/cognitive-profiles.md
+++ /dev/null
@@ -1,266 +0,0 @@
-# Cognitive Profiles
-
-Cognitive profiles are **pre-configured scoring presets** that modulate how the memory system prioritizes, retrieves, and consolidates information. They act as a thalamic filter — adjusting the balance between similarity-driven and importance-driven recall to match different task contexts.
-
-## How Profiles Work
-
-Every recall query is scored using the **fused cognitive score** formula:
-
-$$
-\text{score} = \alpha \cdot \text{similarity} + \beta \cdot \text{importance} \cdot \text{decay}
-$$
-
-Where:
-
-- **α (alpha)** — Weight on vector similarity (how close is this memory to the query?)
-- **β (beta)** — Weight on learned importance (how important was this memory at ingestion?)
-- **α + β = 1.0** — Always normalized
-
-A profile sets α, β, and optional modifiers (hyperfocus boost, lateral mode, episode pinning) to bias the scoring pipeline for a specific cognitive strategy.
-
-## Built-in Profiles
-
-### Standard Profiles
-
-| Profile | α | β | Valence Filter | Best For |
-|:---|:---:|:---:|:---:|:---|
-| `BALANCED` | 0.6 | 0.4 | All | General-purpose recall |
-| `EXPLORING` | 0.8 | 0.2 | All | Broad discovery, creative exploration |
-| `DEBUGGING` | 0.3 | 0.7 | Negative only (≤ -10) | Precise error-matching, diagnostic search |
-| `RECALLING` | 0.4 | 0.6 | Positive only (≥ +10) | Retrieving proven solutions and successes |
-| `CRITICAL` | 0.2 | 0.8 | All | Security audits, compliance checks, high-stakes |
-
-### Advanced Profiles — Neurodivergent
-
-These profiles go beyond α/β tuning — they activate specialized scoring mechanics in the [6-Phase Pipeline](scoring-pipeline.md) and model specific neurocognitive patterns.
-
-| Profile | α | β | Biological Analog | Special Mechanics |
-|:---|:---:|:---:|:---|:---|
-| `HYPERFOCUS` | 1.0 | 0.0 | Monotropism | [Focus Mode](focus-mode.md) — Zero decay, strict tag gate, boost multiplier |
-| `SYSTEMATIZER` | 0.3 | 0.7 | Bottom-up processing (autism) | [Systemizer](focus-mode.md#systemizer) — Pins source episodes during consolidation |
-| `DIVERGENT` | 0.8 | 0.2 | Reduced Latent Inhibition (ADHD) | [Explorer](lateral-retrieval.md) — Lateral cross-domain retrieval |
-| `PARANOID_SENTINEL` | 0.2 | 0.8 | Amygdala threat-detection | Negative-only valence, mood-congruent threat recall |
-| `THE_EXECUTOR` | 0.3 | 0.7 | Prefrontal executive function | Heaviside Cliff (strictness=10.0), no lateral retrieval |
-| `HIGHLY_SENSITIVE` | 0.7 | 0.3 | Sensory Processing Sensitivity | Low flashbulb threshold, strong lateral inhibition |
-| `DEFAULT_MODE_NETWORK` | 0.2 | 0.8 | Brain's resting state network | Skips Working + Episodic, Semantic + Procedural only |
-
----
-
-## New Profile Deep Dives
-
-### PARANOID_SENTINEL — Amygdala Threat Detection
-
-**Biological analog:** The amygdala's threat-detection circuitry, which filters sensory input for potential dangers and amplifies recall of negative experiences (mood-congruent memory bias).
-
-**Use case:** SRE agents, security auditors, compliance monitors. Only surfaces memories associated with negative outcomes — errors, failures, security incidents, regressions.
-
-```java
-PARANOID_SENTINEL(0.2f, 0.8f, Byte.MIN_VALUE, (byte) -1)
-//                 α      β    minValence     maxValence
-```
-
-**How it works:**
-
-- **Valence range [-128, -1]:** Only negative memories pass the valence filter in Phase 3 of the scorer. Successes, neutral logs, and positive outcomes are invisible.
-- **α=0.2, β=0.8:** Importance-dominated — the severity of the past failure matters more than how closely it matches the current query.
-- **Valence alignment:** Query valence is set to -128 (maximum threat), triggering mood-congruent recall amplification.
-
-!!! example "Scenario"
-    Agent query: "deployment configuration" → BALANCED returns general config docs. PARANOID_SENTINEL returns only the config-related incidents: the time a bad config caused a 4-hour outage, the security CVE from an exposed config file, the memory leak from misconfigured thread pool.
-
-### THE_EXECUTOR — Prefrontal Executive Function
-
-**Biological analog:** The prefrontal cortex in full executive function mode — goal-directed, no tangential exploration, pure task completion.
-
-**Use case:** Devin-style agentic task runners. Combined with Zeigarnik Effect (`markUnresolved()`) for tracking open tasks that resist decay.
-
-```java
-THE_EXECUTOR(0.3f, 0.7f, Byte.MIN_VALUE, Byte.MAX_VALUE)
-// + strictnessCoefficient = 10.0
-// + lateralMode = false
-```
-
-**How it works:**
-
-- **Heaviside Cliff scoring:** The strictness coefficient reshapes the similarity curve into a cliff function:
-
-$$
-\text{similarity} = \frac{1}{1 + d_{L2} \times 10.0}
-$$
-
-At strictness=1.0 (default), this is a gentle hyperbola. At strictness=10.0, it's a **cliff** — 95% of candidates score near zero, and only the closest matches survive.
-
-- **Lateral retrieval disabled:** No DIVERGENT-style cross-domain exploration. Results must be directly relevant.
-- **Zeigarnik integration:** Unresolved tasks (flagged via `markUnresolved()`) resist time-decay entirely — their decay bucket is clamped to 0.
-
-### HIGHLY_SENSITIVE — Sensory Processing Sensitivity
-
-**Biological analog:** Enhanced sensory processing depth (Aron & Aron, 1997). The highly sensitive brain processes stimuli more deeply, captures finer environmental details, and has a lower threshold for emotional activation.
-
-```java
-HIGHLY_SENSITIVE(0.7f, 0.3f, Byte.MIN_VALUE, Byte.MAX_VALUE)
-// + flashbulbThreshold = 2.0 (default: 3.0)
-// + inhibitionFloor = 0.3 (stronger lateral inhibition)
-// + minImportance = 0.01
-```
-
-**How it works:**
-
-- **Lower flashbulb threshold (2.0 vs 3.0):** Captures more "important" moments as flashbulb memories. Events that BALANCED would consider routine, HIGHLY_SENSITIVE pins permanently.
-- **Stronger lateral inhibition (0.3 floor):** Less interference between memories. Each memory maintains its distinctiveness rather than blurring with similar neighbors.
-- **minImportance=0.01:** Nothing is too small to remember. Subtle signals that other profiles would round down to zero are preserved.
-- **α=0.7:** Similarity-leaning — captures nuanced matches that importance-dominated profiles would miss.
-
-!!! tip "Ideal for"
-    Medical reasoning, quality assurance, code review, accessibility testing — anywhere subtle signals could be critical.
-
-### DEFAULT_MODE_NETWORK — "Shower Thoughts"
-
-**Biological analog:** The brain's default mode network (DMN), which activates during rest, mind-wandering, and unfocused cognition. The DMN surfaces deep, consolidated knowledge rather than recent events.
-
-```java
-DEFAULT_MODE_NETWORK(0.2f, 0.8f, Byte.MIN_VALUE, Byte.MAX_VALUE)
-// + memoryTypes = {SEMANTIC, PROCEDURAL}
-// + skipTiers = {WORKING, EPISODIC}
-```
-
-**How it works:**
-
-- **Skips Working and Episodic tiers entirely.** Only Semantic (consolidated facts) and Procedural (learned procedures) are searched.
-- **α=0.2, β=0.8:** Importance-dominated. The DMN isn't looking for direct matches — it surfaces whatever the agent "knows deeply" about a topic.
-- **No recency bias:** Since Episodic is skipped, all results are from long-term consolidated memory. No "what happened today" noise.
-
-!!! example "Scenario"
-    Agent is stuck on a performance problem → switches to DEFAULT_MODE_NETWORK → surfaces a deep architectural principle from 3 months ago that reframes the problem entirely. This is the computational equivalent of "sleeping on it."
-
----
-
-## Usage
-
-### Via CognitiveProfile Enum
-
-```java
-// Simple: use a profile preset
-List<CognitiveResult> results = memory.recall("database deadlock", CognitiveProfile.HYPERFOCUS);
-```
-
-### Via RecallOptions Builder
-
-```java
-// Advanced: profile + custom overrides
-var options = RecallOptions.builder()
-    .profile(CognitiveProfile.DIVERGENT)
-    .topK(20)
-    .lateralDistanceThreshold(1.5f)  // override default
-    .build();
-
-List<CognitiveResult> results = memory.recall("performance optimization", options);
-```
-
-### Via MCP Tool
-
-The `recall_context` MCP tool accepts a `profile` parameter:
-
-```json
-{
-  "name": "recall_context",
-  "arguments": {
-    "query": "database deadlock",
-    "profile": "HYPERFOCUS",
-    "top_k": 10
-  }
-}
-```
-
----
-
-## Profile Selection Guide
-
-```mermaid
-flowchart TD
-    A["What is the agent doing?"] --> B{"Focused on\none topic?"}
-    B -->|Yes| C{"Need encyclopedic\ndetail?"}
-    C -->|Yes| D["SYSTEMATIZER"]
-    C -->|No| E["HYPERFOCUS"]
-    B -->|No| F{"Exploring new\nterritory?"}
-    F -->|Yes| G{"Want cross-domain\ninsights?"}
-    G -->|Yes| H["DIVERGENT"]
-    G -->|No| I["EXPLORING"]
-    F -->|No| J{"Task execution\nor debugging?"}
-    J -->|"Executing tasks"| J2["THE_EXECUTOR"]
-    J -->|"Debugging"| K["DEBUGGING"]
-    J -->|"Threat hunting"| M["PARANOID_SENTINEL"]
-    J -->|"Need deep insight"| N["DEFAULT_MODE_NETWORK"]
-    J -->|"Detail-sensitive"| O["HIGHLY_SENSITIVE"]
-    J -->|No| L["BALANCED"]
-```
-
----
-
-## Agent Self-Extension
-
-Agents can dynamically switch profiles during a conversation:
-
-1. **Start with `BALANCED`** for general context
-2. **Switch to `HYPERFOCUS`** when a specific topic is identified (e.g., user mentions "database deadlock")
-3. **Switch to `DIVERGENT`** when stuck — lateral results may surface unexpected solutions
-4. **Switch to `SYSTEMATIZER`** when building a comprehensive knowledge base
-
-The `HyperfocusState` object supports TTL-based activation with agent self-extension:
-
-```java
-// Agent detects a focused topic
-memory.hyperfocusState().activateFromTags("database", "deadlock");
-
-// Agent extends focus when the topic continues
-memory.hyperfocusState().extend();
-
-// Focus automatically expires after TTL (default: 30 minutes)
-```
-
----
-
-## Custom Profiles
-
-You can create custom profiles by using `RecallOptions.builder()` directly:
-
-```java
-var customProfile = RecallOptions.builder()
-    .alpha(0.9f)
-    .beta(0.1f)
-    .hyperfocusMask("java", "concurrency")
-    .hyperfocusBoost(2.0f)
-    .lateralMode(false)
-    .build();
-```
-
----
-
-## Result Metadata
-
-Each `CognitiveResult` carries a `RetrievalMode` indicating how it was retrieved:
-
-| Mode | Meaning |
-|:---|:---|
-| `STANDARD` | Normal similarity + importance scoring |
-| `LATERAL` | Cross-domain retrieval via the Explorer dual-heap |
-| `HYPERFOCUS` | Tag-matched with zero decay and boost multiplier |
-
-```java
-for (CognitiveResult r : results) {
-    if (r.isLateral()) {
-        // Cross-domain insight — consider carefully
-    } else if (r.isHyperfocused()) {
-        // Focused match — high confidence
-    }
-}
-```
-
-## What's Next
-
-- [Focus Mode](focus-mode.md) — Deep dive on HYPERFOCUS and SYSTEMATIZER
-- [Explorer — Lateral Retrieval](lateral-retrieval.md) — Cross-domain dual-heap mechanics
-- [Importance Fusion (ICNU)](importance-fusion.md) — Sigmoid-gated importance with dopaminergic I×N interaction
-- [Synapse — Tags & Scoring](synapse.md) — Versioned header layouts (V1/V2/V3) and arousal-modulated decay
-- [Hebbian — Association Learning](hebbian.md) — STDP with directed causal edges
-- [Labs — Research Roadmap](../labs/roadmap.md) — Neuromodulatory Gain, Executive Dysfunction Profile
diff --git a/docs/docs/memory/cortex.md b/docs/docs/memory/cortex.md
deleted file mode 100644
index 59ef66c..0000000
--- a/docs/docs/memory/cortex.md
+++ /dev/null
@@ -1,223 +0,0 @@
----
-title: "Cortex — Tier Stores"
-description: "The 4-tier cognitive memory architecture: Working, Episodic, Semantic, and Procedural — each modeled after a brain region."
----
-
-# 🧠 Cortex — Tier Stores
-
-> **Package**: `com.spectrayan.spector.memory.cortex`
->
-> **Biological Analog**: The **Cerebral Cortex** — the outer layer of the brain responsible for higher-order cognitive functions. Different cortical regions specialize in different types of memory.
-
----
-
-## The 4-Tier Architecture
-
-Human memory is not a single system. Cognitive science identifies distinct memory systems with different characteristics, durations, and purposes. Spector mirrors this with four tier stores:
-
-```mermaid
-graph TB
-    subgraph "TierRouter — Polymorphic Registry"
-        direction TB
-        TR["TierStore interface"]
-    end
-    
-    TR --> WM["🧪 Working Memory<br/>WorkingMemoryStore<br/>━━━━━━━━━━━━━━━━━<br/>Prefrontal Cortex<br/>Volatile circular buffer<br/>~100 records"]
-    TR --> EM["📝 Episodic Memory<br/>EpisodicMemoryStore<br/>━━━━━━━━━━━━━━━━━<br/>Hippocampus<br/>Time-partitioned mmap<br/>Unbounded"]
-    TR --> SE["🧬 Semantic Memory<br/>SemanticMemoryStore<br/>━━━━━━━━━━━━━━━━━<br/>Neocortex<br/>Permanent knowledge<br/>~5,000 records"]
-    TR --> PR["⚙️ Procedural Memory<br/>ProceduralMemoryStore<br/>━━━━━━━━━━━━━━━━━<br/>Basal Ganglia<br/>Learned procedures<br/>~500 records"]
-    
-    style WM fill:#e74c3c,color:white
-    style EM fill:#3498db,color:white
-    style SE fill:#2ecc71,color:white
-    style PR fill:#9b59b6,color:white
-```
-
----
-
-## TierStore Interface
-
-All four stores implement a common `TierStore` interface, enabling polymorphic dispatch in the router:
-
-```java
-public interface TierStore extends AutoCloseable {
-    MemoryType type();
-    int size();
-    CognitiveRecordLayout layout();
-    MemorySegment primarySegment();
-    long write(CognitiveHeader header, byte[] quantizedVec);
-}
-```
-
-The `TierRouter` holds an `EnumMap<MemoryType, TierStore>` and dispatches all operations polymorphically:
-
-```java
-// Zero switch statements — polymorphic dispatch
-public long write(MemoryType type, CognitiveHeader header, byte[] quantized) {
-    return get(type).write(header, quantized);
-}
-```
-
-> Adding a new tier (e.g., `FLASH` for ultra-fast scratch memory) requires only: (1) implement `TierStore`, (2) register in `TierRouter`. No changes needed in `SpectorMemory`, `RecallPipeline`, or `CognitiveIngestionTarget`.
-
----
-
-## AbstractTierStore
-
-Three of the four stores (Working, Semantic, Procedural) extend `AbstractTierStore`, which provides:
-
-- **Arena lifecycle**: `Arena.ofShared()` for thread-safe off-heap access
-- **Segment allocation**: 32-byte aligned via `arena.allocate(bytes, 32)`
-- **Layout creation** from quantized vector byte count
-- **Capacity tracking** and size reporting
-- **Close/cleanup** lifecycle
-
-`EpisodicMemoryStore` implements `TierStore` directly because it uses mmap-backed partitions rather than a single Arena-allocated segment.
-
----
-
-## 🧪 Working Memory (Prefrontal Cortex)
-
-**Biological Analog**: The **Prefrontal Cortex** maintains a limited workspace for active processing. It holds ~7±2 items in biological systems.
-
-| Property | Value |
-|---|---|
-| Storage | `Arena.ofShared()` volatile segment |
-| Capacity | Configurable (default: 100) |
-| Eviction | Circular buffer — oldest entries overwritten |
-| Persistence | **None** — lost on JVM shutdown |
-| Use case | Current task context, recent conversation |
-
-```java
-// Circular buffer write
-public long write(CognitiveHeader header, byte[] quantizedVec) {
-    long offset = (long) (count % capacity) * layout.stride();
-    layout.writeHeader(segment, offset, header);
-    MemorySegment.copy(MemorySegment.ofArray(quantizedVec), 0,
-        segment, layout.vectorOffset(offset), quantizedVec.length);
-    count++;
-    return offset;
-}
-```
-
-**Special capability**: Synaptic tag search without vector math. WorkingMemoryStore supports a `findByTag(mask)` method that scans only the 64-bit Bloom filter field — useful for fast context lookups.
-
----
-
-## 📝 Episodic Memory (Hippocampus)
-
-**Biological Analog**: The **Hippocampus** encodes autobiographical events as time-ordered traces. New events are appended rapidly (one-trial learning), and during sleep the hippocampus replays sequences for consolidation into cortical memory.
-
-| Property | Value |
-|---|---|
-| Storage | `FileChannel.map()` mmap-backed files |
-| Capacity | Unbounded (1 partition per day, each up to 10,000 records) |
-| Eviction | Tombstone + compaction |
-| Persistence | **Full** — survives JVM restarts |
-| Use case | "What error did we debug yesterday?", "What did the user say last week?" |
-
-### Partition Lifecycle
-
-Each episodic partition is a memory-mapped file with a 64-byte metadata header:
-
-```
-┌─── Partition File ─────────────────────────────────────────┐
-│ [64B Metadata Header]                                       │
-│   ├── 4B magic (0x45504943 = "EPIC")                       │
-│   ├── 4B version (1)                                        │
-│   ├── 4B count (live records)                               │
-│   ├── 4B tombstoneCount                                     │
-│   ├── 4B capacity                                           │
-│   ├── 4B state (ACTIVE/SEALED/REFLECTABLE/TOMBSTONED/...)  │
-│   ├── 4B stride                                             │
-│   └── 36B reserved                                          │
-├── [Record 0: 32B header + NB vector] ──────────────────────┤
-├── [Record 1: 32B header + NB vector] ──────────────────────┤
-│   ...                                                       │
-└── [Record N-1]  ───────────────────────────────────────────┘
-```
-
-**Partition state machine**:
-
-```mermaid
-stateDiagram-v2
-    [*] --> ACTIVE: Create partition
-    ACTIVE --> SEALED: Day rolls over
-    SEALED --> REFLECTABLE: ReflectDaemon marks eligible
-    REFLECTABLE --> TOMBSTONED: High tombstone ratio
-    TOMBSTONED --> COMPACTED: TombstoneCompactor rebuilds
-    COMPACTED --> [*]: Old partition swapped out
-```
-
----
-
-## 🧬 Semantic Memory (Neocortex)
-
-**Biological Analog**: The **Neocortex** stores distilled, permanent world knowledge — facts, concepts, and generalized rules extracted from repeated experience.
-
-| Property | Value |
-|---|---|
-| Storage | Header-only slab (`Arena.ofShared()`) |
-| Capacity | Configurable (default: 5,000) |
-| Eviction | None (permanent) |
-| Persistence | Via WAL replay |
-| Use case | "The user prefers dark mode", "Java uses garbage collection" |
-
-!!! info "Header-Only Storage"
-    Semantic memories store only the 32-byte synaptic header, not the full quantized vector. This enables fast metadata scans (tag match, importance, valence) at minimal memory cost. For vector similarity, the text is re-embedded at query time when needed.
-
-**Creation**: Semantic memories are created either:
-
-1. **Directly** by the user (`MemoryType.SEMANTIC`)
-2. **By consolidation** — the `ReflectDaemon` clusters similar episodic memories during "sleep" and promotes the cluster centroid to semantic memory
-
----
-
-## ⚙️ Procedural Memory (Basal Ganglia)
-
-**Biological Analog**: The **Basal Ganglia** stores learned motor programs and habitual behaviors — "how to ride a bicycle" type knowledge that operates below conscious awareness.
-
-| Property | Value |
-|---|---|
-| Storage | `Arena.ofShared()` linear segment |
-| Capacity | Configurable (default: 500) |
-| Eviction | None (append-only) |
-| Persistence | Via WAL replay |
-| Use case | "Always use exponential backoff", "Format SQL with uppercase keywords" |
-
-Procedural memories represent **rules and patterns** that the agent has internalized. They are typically higher-importance, persistent, and rarely forgotten.
-
----
-
-## TierRouter
-
-The `TierRouter` dispatches all operations to the appropriate store via an `EnumMap`:
-
-```java
-public final class TierRouter implements AutoCloseable {
-    private final EnumMap<MemoryType, TierStore> stores = new EnumMap<>(MemoryType.class);
-    
-    // Polymorphic dispatch — zero switch statements
-    public long write(MemoryType type, CognitiveHeader header, byte[] quantized) {
-        return get(type).write(header, quantized);
-    }
-    
-    public MemorySegment segmentFor(MemoryType type) {
-        return get(type).primarySegment();
-    }
-    
-    public static boolean shouldScan(MemoryType type, MemoryType[] targetTypes) {
-        if (targetTypes == null || targetTypes.length == 0) return true;
-        for (MemoryType t : targetTypes) if (t == type) return true;
-        return false;
-    }
-}
-```
-
----
-
-## Next Steps
-
-- :material-sleep: [**Hippocampus — Sleep Consolidation**](hippocampus.md) — how episodic memories are consolidated into semantic knowledge
-- :material-flash: [**Synapse — Tags & Scoring**](synapse.md) — the 32-byte header and Bloom filter
-- :material-lightning-bolt: [**6-Phase Scoring Pipeline**](scoring-pipeline.md) — the SIMD hot-loop
diff --git a/docs/docs/memory/dopamine.md b/docs/docs/memory/dopamine.md
deleted file mode 100644
index bd461ed..0000000
--- a/docs/docs/memory/dopamine.md
+++ /dev/null
@@ -1,163 +0,0 @@
----
-title: "Dopamine — Surprise Detection"
-description: "How SurpriseDetector uses Welford online statistics to automatically score memory importance based on novelty."
----
-
-# ⚡ Dopamine — Surprise Detection
-
-> **Package**: `com.spectrayan.spector.memory.dopamine`
->
-> **Biological Analog**: The **dopaminergic system** signals prediction error — the difference between what the brain expected and what actually happened. When a stimulus is surprising (high prediction error), dopamine release strengthens memory encoding. This is why we vividly remember surprising events (flashbulb memories) but quickly forget routine ones.
-
----
-
-## The Problem
-
-Without surprise detection, an AI agent treats all memories as equally important. A routine "code compiled successfully" gets the same importance as "production database corrupted." This leads to:
-
-- Important memories drowning in noise
-- Critical errors being forgotten as quickly as routine events
-- No adaptive importance — every memory starts at the same baseline
-
----
-
-## SurpriseDetector
-
-The `SurpriseDetector` maintains a running statistical model of "normal" memory vectors using **Welford's online algorithm** (numerically stable one-pass mean/variance). When a new memory arrives, its L2 distance from the running centroid is converted to a Z-score:
-
-```mermaid
-graph LR
-    A["New Memory<br/>L2 norm = 3.7"] --> B["Welford Stats<br/>μ=2.1, σ=0.6"]
-    B --> C["Z-score<br/>(3.7 - 2.1) / 0.6 = 2.67"]
-    C -->|"Z > 2.0"| D["⚡ Surprising!<br/>importance = 0.85"]
-    C -->|"Z < 0.5"| E["😐 Normal<br/>importance = 0.4"]
-    
-    style D fill:#e74c3c,color:white
-    style E fill:#95a5a6,color:white
-```
-
-### Dual Importance Formula
-
-```java
-public float computeDualImportance(float distanceToNearest, long synapticTags,
-                                    float spatialWeight, float temporalWeight) {
-    // Spatial surprise: how far is this from the running centroid?
-    float zScore = welford.zScore(distanceToNearest);
-    float spatialSurprise = sigmoid(zScore);
-    
-    // Temporal surprise: how long since we saw this tag pattern?
-    Long lastSeen = lastSeenByTags.put(synapticTags, nowMs);
-    float temporalSurprise = lastSeen == null ? 1.0f 
-        : Math.min(1.0f, (nowMs - lastSeen) / (float) DAY_MS);
-    
-    // Fused importance
-    return spatialWeight * spatialSurprise + temporalWeight * temporalSurprise;
-}
-```
-
-Two dimensions of surprise:
-
-| Dimension | Signal | Weight |
-|---|---|---|
-| **Spatial surprise** | Z-score of L2 norm vs. running statistics | 0.6 (default) |
-| **Temporal surprise** | Time since last memory with matching tags | 0.4 (default) |
-
----
-
-## WelfordStats — Online Statistics
-
-`WelfordStats` implements Welford's algorithm for numerically stable online mean and variance computation:
-
-```java
-public final class WelfordStats {
-    private long count = 0;
-    private double mean = 0.0;
-    private double m2 = 0.0;  // Sum of squared differences
-    
-    public synchronized void update(double value) {
-        count++;
-        double delta = value - mean;
-        mean += delta / count;
-        double delta2 = value - mean;
-        m2 += delta * delta2;
-    }
-    
-    public double variance() {
-        return count < 2 ? 0.0 : m2 / (count - 1);
-    }
-    
-    public float zScore(double value) {
-        double stdDev = Math.sqrt(variance());
-        return stdDev < 1e-9 ? 0f : (float) ((value - mean) / stdDev);
-    }
-}
-```
-
-!!! tip "Why Welford?"
-    Naive variance computation (`Σ(x-μ)²/n`) requires two passes or suffers from catastrophic cancellation with floating-point arithmetic. Welford's algorithm maintains numerical stability with a single pass — critical for an always-running system that processes millions of memories over its lifetime.
-
----
-
-## FlashbulbPolicy — Extreme Surprise
-
-**Biological analog**: **Flashbulb memories** are vivid, long-lasting memories formed during moments of extreme surprise or emotional intensity (e.g., hearing about a major world event). The amygdala signals the hippocampus to strengthen encoding.
-
-When the Z-score exceeds a threshold (default: 3.0), the `FlashbulbPolicy` kicks in:
-
-```java
-public FlashbulbDecision evaluate(float zScore, float baseImportance) {
-    if (zScore >= flashbulbThreshold) {
-        return new FlashbulbDecision(
-            true,     // isFlashbulb
-            1.0f,     // maxImportance
-            true      // pinned (exempt from decay)
-        );
-    }
-    return FlashbulbDecision.NORMAL;
-}
-```
-
-**Effects**:
-
-- Importance is set to **1.0** (maximum)
-- The **pinned flag** (bit 1 of flags byte) is set — this memory is exempt from temporal decay in Phase 4 of the scoring pipeline
-- The memory will persist indefinitely unless explicitly `forget()`'d
-
-!!! example "Use Case"
-    An AI coding agent encounters `OutOfMemoryError` for the first time (Z-score: 4.2). This triggers flashbulb encoding — the error memory is pinned at maximum importance and will always surface when the agent encounters memory-related issues.
-
----
-
-## Integration with Ingestion Pipeline
-
-The surprise detection happens at **Step 3** of the ingestion pipeline:
-
-```java
-// In CognitiveIngestionTarget.ingestCognitive()
-
-// Step 1: Embed
-float[] vector = embeddingProvider.embed(text).vector();
-float l2Norm = VectorOps.l2Norm(vector);
-
-// Step 2: Encode tags
-long synapticTags = SynapticTagEncoder.encode(tags);
-
-// Step 3: Surprise detection
-float importance = surpriseDetector.computeDualImportance(l2Norm, synapticTags);
-
-// Step 4: Flashbulb check
-FlashbulbDecision flashbulb = flashbulbPolicy.evaluate(
-    surpriseDetector.lastZScore(), importance);
-if (flashbulb.isFlashbulb()) {
-    importance = 1.0f;
-    flags |= FLAG_PINNED;
-}
-```
-
----
-
-## Next Steps
-
-- :material-emoticon: [**Amygdala — Emotional Valence**](amygdala.md) — emotional coloring of memories
-- :material-flash: [**Synapse — Tags & Scoring**](synapse.md) — the 32-byte header
-- :material-sleep: [**Hippocampus — Sleep Consolidation**](hippocampus.md) — what happens to important memories
diff --git a/docs/docs/memory/focus-mode.md b/docs/docs/memory/focus-mode.md
deleted file mode 100644
index dfcd8c0..0000000
--- a/docs/docs/memory/focus-mode.md
+++ /dev/null
@@ -1,137 +0,0 @@
-# Focus Mode
-
-Focus Mode is a specialized cognitive scoring strategy that simulates **sustained attention** — the ability to deeply concentrate on a single topic while filtering out irrelevant information.
-
-Two profiles use focus-oriented mechanics: **HYPERFOCUS** (strict retrieval tunnel) and **SYSTEMATIZER** (lossless knowledge accumulation).
-
----
-
-## HYPERFOCUS — Strict Retrieval Tunnel
-
-When an agent activates Focus Mode, three things change in the [6-Phase Scoring Pipeline](scoring-pipeline.md):
-
-### 1. Strict Tag Gate (Phase 2)
-
-Only memories whose synaptic tags **exactly match** the focus mask pass through. This is a bitwise AND check:
-
-```
-if (recordTags & hyperfocusMask) != hyperfocusMask → SKIP
-```
-
-Unlike normal tag filtering (which accepts partial overlap), Focus Mode requires **all** focus tags to be present. This creates a narrow retrieval tunnel — only deeply relevant memories survive.
-
-### 2. Zero Decay (Phase 4)
-
-For tag-matched memories, the time decay factor is clamped to **1.0**:
-
-```
-adjustedBucket = 0  // no time decay for focused memories
-```
-
-This means old memories about the focused topic are treated as if they were just created. A 6-month-old memory about "database deadlocks" is equally accessible as one from today — as long as the tags match.
-
-### 3. Post-Score Boost (Phase 6)
-
-After the standard cognitive score is computed, focus-matched memories receive a configurable multiplier:
-
-```
-finalScore = score × hyperfocusBoost  // default: 1.5×
-```
-
-This ensures focused memories consistently outrank non-focused ones in the final result list.
-
-### Configuration
-
-```java
-// Via profile preset
-var results = memory.recall("database deadlock", CognitiveProfile.HYPERFOCUS);
-
-// Via explicit options
-var options = RecallOptions.builder()
-    .profile(CognitiveProfile.HYPERFOCUS)
-    .hyperfocusMask("database", "deadlock")  // Bloom filter encoded
-    .hyperfocusBoost(2.0f)                   // custom boost
-    .build();
-```
-
-### TTL and Self-Extension
-
-Focus Mode is governed by `HyperfocusState`, a TTL-based state machine:
-
-```java
-// Activate focus for 30 minutes (default)
-memory.hyperfocusState().activateFromTags("database", "deadlock");
-
-// Agent extends focus when topic continues
-memory.hyperfocusState().extend();         // adds another 30 minutes
-memory.hyperfocusState().extend(60_000L);  // adds 1 minute
-
-// Check status
-memory.hyperfocusState().isActive();       // true
-memory.hyperfocusState().remainingMs();    // milliseconds remaining
-
-// Deactivate manually (or wait for TTL expiry)
-memory.hyperfocusState().deactivate();
-```
-
-!!! tip "Agent Self-Extension"
-    The `extend()` method is designed to be called by the agent itself. When the agent detects that the conversation is still focused on the same topic, it extends the TTL. When the topic naturally shifts, the TTL expires and Focus Mode deactivates automatically.
-
----
-
-## SYSTEMATIZER — Lossless Knowledge Accumulation {#systemizer}
-
-The Systematizer profile is designed for agents that need to build **comprehensive knowledge bases** — where losing detail during consolidation is unacceptable.
-
-### Scoring Weights
-
-| Parameter | Value | Rationale |
-|:---|:---:|:---|
-| α (similarity) | 0.3 | Low — details matter more than semantic similarity |
-| β (importance) | 0.7 | High — prioritizes learned importance |
-
-### Persistent Memory Pinning
-
-The key feature of SYSTEMATIZER is **lossless consolidation**. During the [sleep consolidation cycle](hippocampus.md) (REM sleep), the system normally clusters similar episodic memories and promotes a summary to semantic memory. The source episodes may then be tombstoned.
-
-With SYSTEMATIZER, source episodes are **pinned** — they receive the `FLAG_PINNED` bit in their record header, which prevents tombstoning:
-
-```
-Episodic: [mem-1] [mem-2] [mem-3] → Cluster → Semantic summary created
-                                   ↓
-                        Standard: mem-1, mem-2, mem-3 tombstoned
-                        Systemizer: mem-1, mem-2, mem-3 PINNED ✓
-```
-
-### Quota Management
-
-To prevent unbounded memory growth, pinning is governed by a configurable quota:
-
-```java
-var memory = SpectorMemory.builder()
-    .pinSourceEpisodes(true)   // enable pinning
-    .pinnedQuota(10_000)       // max pinned records (default)
-    .build();
-```
-
-When the quota is reached, the oldest pinned records are eligible for tombstoning during the next consolidation cycle.
-
-### Use Cases
-
-- **Legal/compliance agents** that must retain all original evidence
-- **Research agents** building encyclopedic knowledge bases
-- **Audit trails** where summarization must not lose detail
-
----
-
-## Performance Impact
-
-!!! note "Zero Overhead When Disabled"
-    All Focus Mode mechanics are gated by `hyperfocusMask != 0` in the hot loop. When no focus is active (the default), the code paths are identical to standard scoring — zero additional cost.
-
-| Mechanic | Hot-Loop Cost | When Active |
-|:---|:---|:---|
-| Tag gate | ~2 cycles (bitwise AND) | Only when `hyperfocusMask != 0` |
-| Decay clamp | ~1 cycle (conditional) | Only for tag-matched records |
-| Boost multiply | ~1 cycle (float multiply) | Only for tag-matched records |
-| Episode pinning | 0 (off hot loop) | During consolidation only |
diff --git a/docs/docs/memory/getting-started.md b/docs/docs/memory/getting-started.md
deleted file mode 100644
index fe66def..0000000
--- a/docs/docs/memory/getting-started.md
+++ /dev/null
@@ -1,227 +0,0 @@
----
-title: Getting Started
-description: "Set up Spector Memory in 5 minutes — from Maven dependency to your first remember/recall cycle."
----
-
-# Getting Started
-
-Get cognitive memory running in your Java application in under 5 minutes.
-
----
-
-## Prerequisites
-
-| Requirement | Version | Notes |
-|---|---|---|
-| **JDK** | 25+ | OpenJDK with Vector API incubator |
-| **Maven** | 3.9+ | Build tool |
-| **Ollama** | Latest | For real embeddings (optional — mock provider works for testing) |
-
-## Maven Dependency
-
-```xml
-<dependency>
-    <groupId>com.spectrayan</groupId>
-    <artifactId>spector-memory</artifactId>
-    <version>0.1.0-SNAPSHOT</version>
-</dependency>
-
-<!-- Ollama embedding provider (optional) -->
-<dependency>
-    <groupId>com.spectrayan</groupId>
-    <artifactId>spector-embed-ollama</artifactId>
-    <version>0.1.0-SNAPSHOT</version>
-</dependency>
-```
-
-## JVM Flags
-
-Spector Memory uses the Vector API (incubator) for SIMD acceleration:
-
-```bash
-java --add-modules jdk.incubator.vector \
-     --enable-native-access=ALL-UNNAMED \
-     --enable-preview \
-     -jar your-app.jar
-```
-
-!!! tip "Maven Surefire"
-    These flags are already configured in the parent `pom.xml`. Tests run out of the box with `mvn test`.
-
----
-
-## Minimal Example
-
-### With Mock Embeddings (No Ollama Required)
-
-```java
-import com.spectrayan.spector.memory.*;
-import com.spectrayan.spector.memory.cortex.MemorySource;
-
-// Create a mock embedding provider for testing
-EmbeddingProvider mock = text -> {
-    float[] vec = new float[128];
-    // Deterministic hash-based vector for reproducibility
-    var rng = new java.util.Random(text.hashCode());
-    for (int i = 0; i < 128; i++) vec[i] = rng.nextFloat() - 0.5f;
-    return new EmbeddingResult(vec, text.split("\\s+").length, "mock");
-};
-
-try (SpectorMemory memory = SpectorMemory.builder()
-        .dimensions(128)
-        .embeddingProvider(mock)
-        .build()) {
-    
-    // Remember
-    memory.remember("fact-1", 
-        "The user prefers dark mode in all editors.",
-        MemoryType.EPISODIC, MemorySource.USER_STATED,
-        "preferences", "ui").get();
-    
-    // Recall
-    List<CognitiveResult> results = memory.recall("dark theme settings",
-        RecallOptions.builder().topK(5).build());
-    
-    results.forEach(r -> 
-        System.out.printf("%.4f [%s] %s%n", r.score(), r.memoryType(), r.text()));
-}
-```
-
-### With Real Ollama Embeddings
-
-```java
-import com.spectrayan.spector.embed.ollama.OllamaEmbeddingProvider;
-
-// Pull the model first: ollama pull qwen3-embedding
-var embedder = OllamaEmbeddingProvider.create("qwen3-embedding");
-
-try (SpectorMemory memory = SpectorMemory.builder()
-        .dimensions(embedder.dimensions())  // Auto-detect: 4096 for qwen3-embedding
-        .embeddingProvider(embedder)
-        .workingCapacity(100)
-        .episodicPartitionCapacity(10_000)
-        .semanticCapacity(5_000)
-        .proceduralCapacity(500)
-        .build()) {
-    
-    // Ingest diverse memories
-    memory.remember("err-db", 
-        "Database connection pool exhausted — 50 active, 0 idle connections.",
-        MemoryType.EPISODIC, MemorySource.OBSERVED,
-        "error", "database").get();
-    
-    memory.remember("rule-retry",
-        "Always implement exponential backoff for database retries.",
-        MemoryType.PROCEDURAL, MemorySource.PROCEDURAL,
-        "database", "retry").get();
-    
-    // Semantic recall with synaptic tag filtering
-    List<CognitiveResult> results = memory.recall("database connection error",
-        RecallOptions.builder()
-            .topK(5)
-            .synapticFilter("database")        // Only memories tagged "database"
-            .minImportance(0.2f)               // Skip trivial memories
-            .build());
-}
-```
-
----
-
-## Core Operations
-
-### Remember (Ingestion)
-
-```java
-// Async — returns CompletableFuture
-CompletableFuture<Void> future = memory.remember(
-    "unique-id",                    // Unique memory identifier
-    "The text content to remember", // Raw text (will be auto-embedded)
-    MemoryType.EPISODIC,            // Cognitive tier
-    MemorySource.USER_STATED,       // Provenance
-    "tag1", "tag2", "tag3"          // Synaptic tags (Bloom filter encoded)
-);
-future.get(); // Block if needed
-```
-
-### Recall (Retrieval)
-
-```java
-List<CognitiveResult> results = memory.recall("query text",
-    RecallOptions.builder()
-        .topK(10)                              // Max results
-        .synapticFilter("java", "debugging")   // Bloom filter pre-screen
-        .minImportance(0.3f)                   // Importance threshold
-        .memoryTypes(MemoryType.EPISODIC,      // Tier filter
-                     MemoryType.SEMANTIC)
-        .minValence((byte) -50)                // Emotional range
-        .maxValence((byte) 50)
-        .alpha(0.6f)                           // Similarity weight
-        .beta(0.4f)                            // Importance × decay weight
-        .build());
-```
-
-### Forget & Suppress
-
-```java
-// Permanent: tombstone the memory (excluded from all future scans)
-memory.forget("memory-id");
-
-// Temporary: suppress from recall (can be un-suppressed later)
-memory.suppress("memory-id", "Not relevant to current task");
-```
-
-### Introspect
-
-```java
-// Memory health statistics
-int total = memory.totalMemories();
-var stats = memory.introspect();
-```
-
----
-
-## Claude Desktop / MCP Integration
-
-Add cognitive memory to your AI agent via the built-in MCP server. Enable memory in your `spector.yml`:
-
-```yaml
-spector:
-  engine:
-    dimensions: 4096
-  embedding:
-    model: qwen3-embedding
-    base-url: http://localhost:11434
-  memory:
-    enabled: true
-    persistence-path: .spector/memory
-```
-
-Then configure your agent:
-
-```json
-{
-  "mcpServers": {
-    "spector": {
-      "command": "java",
-      "args": [
-        "--add-modules", "jdk.incubator.vector",
-        "--enable-native-access=ALL-UNNAMED",
-        "--enable-preview",
-        "-jar", "/path/to/spector.jar",
-        "--config", "/path/to/spector.yml"
-      ]
-    }
-  }
-}
-```
-
-With `memory.enabled: true`, the MCP server registers all 13 tools (6 search + 7 cognitive memory).
-
----
-
-## Next Steps
-
-- :material-brain: [**System Architecture**](architecture.md) — understand the full package hierarchy
-- :material-lightning-bolt: [**6-Phase Scoring Pipeline**](scoring-pipeline.md) — how recall actually works under the hood
-- :material-head-cog: [**Biological Systems**](cortex.md) — explore each brain region
-- :material-speedometer: [**Performance**](performance.md) — benchmarks and optimization techniques
diff --git a/docs/docs/memory/habituation.md b/docs/docs/memory/habituation.md
deleted file mode 100644
index e729136..0000000
--- a/docs/docs/memory/habituation.md
+++ /dev/null
@@ -1,127 +0,0 @@
----
-title: "Habituation — Anti-Filter Bubble"
-description: "How HabituationPenalty prevents repetitive recall by attenuating scores for frequently-returned memories."
----
-
-# 😴 Habituation — Anti-Filter Bubble
-
-> **Package**: `com.spectrayan.spector.memory.habituation`
->
-> **Biological Analog**: **Habituation** is the simplest form of learning — a decrease in response to a stimulus after repeated presentations. You stop hearing the ticking clock after a few minutes. The brain allocates attention to *novel* stimuli, not repeated ones. This prevents sensory overload and enables adaptation.
-
----
-
-## The Problem
-
-Without habituation, an AI agent repeatedly recalls the same "most relevant" memories — creating a **filter bubble**. If memory A has the highest similarity score, it dominates every recall, crowding out potentially useful but slightly-less-similar memories.
-
-```
-Query 1: "database issues" → [A, B, C, D, E]     ← A dominates
-Query 2: "database issues" → [A, B, C, D, E]     ← Same results!
-Query 3: "database issues" → [A, B, C, D, E]     ← Filter bubble
-```
-
-### With Habituation
-
-```
-Query 1: "database issues" → [A, B, C, D, E]     ← Fresh results
-Query 2: "database issues" → [B, C, A, D, F]     ← A drops, F emerges
-Query 3: "database issues" → [C, F, B, G, D]     ← New memories surface
-```
-
----
-
-## HabituationPenalty
-
-The `HabituationPenalty` tracks recall frequency per memory ID and computes a decay penalty:
-
-```java
-public final class HabituationPenalty {
-    
-    private final ConcurrentHashMap<String, Integer> recallCounts 
-        = new ConcurrentHashMap<>();
-    private final float decayRate;  // default: 0.85
-    
-    /**
-     * Records a recall event and returns the habituation penalty.
-     * First recall: 1.0 (no penalty). Each subsequent recall multiplies
-     * the penalty by decayRate (default: 0.85).
-     *
-     * @param memoryId the memory being recalled
-     * @return penalty multiplier [0.0 – 1.0]
-     */
-    public float recordAndComputePenalty(String memoryId) {
-        int count = recallCounts.merge(memoryId, 1, Integer::sum);
-        if (count <= 1) return 1.0f;  // First recall — no penalty
-        return (float) Math.pow(decayRate, count - 1);
-    }
-    
-    /**
-     * Batch penalty computation for multiple IDs (P7 optimization).
-     */
-    public float[] batchPenalty(String[] ids) {
-        float[] penalties = new float[ids.length];
-        for (int i = 0; i < ids.length; i++) {
-            penalties[i] = recordAndComputePenalty(ids[i]);
-        }
-        return penalties;
-    }
-}
-```
-
-### Penalty Curve
-
-| Recall # | Penalty (rate=0.85) | Effect |
-|---|---|---|
-| 1st | 1.00 | Full score |
-| 2nd | 0.85 | 15% reduction |
-| 3rd | 0.72 | 28% reduction |
-| 5th | 0.52 | Half score |
-| 10th | 0.20 | 80% reduction |
-| 20th | 0.04 | Nearly eliminated |
-
-!!! info "Decay Rate Configuration"
-    The default decay rate of 0.85 provides a balance between novelty and relevance. A higher rate (0.95) creates a gentler penalty — useful when the agent genuinely needs to recall the same memory frequently. A lower rate (0.70) aggressively surfaces new content.
-
----
-
-## Integration with RecallPipeline
-
-Habituation is applied at **Step 5** of the recall pipeline — after scoring but before final ranking:
-
-```java
-// In RecallPipeline.recall()
-
-// Step 5: Apply habituation penalty (anti-filter-bubble)
-for (int i = 0; i < allResults.size(); i++) {
-    CognitiveResult r = allResults.get(i);
-    float habPenalty = habituationPenalty.recordAndComputePenalty(r.id());
-    if (habPenalty < 1.0f) {
-        allResults.set(i, new CognitiveResult(
-            r.id(), r.text(), r.score() * habPenalty, 
-            r.importance(), r.ageDays(),
-            r.recallCount(), r.valence(), r.memoryType(), r.source(),
-            r.synapticTags(), r.decayFactor(), r.ltpAdjustedDecay()));
-    }
-}
-```
-
-**Key**: The penalty multiplies the `score()` field — it doesn't modify the underlying memory. Habituation is a recall-time effect, not a storage-time effect.
-
----
-
-## Interaction with Other Systems
-
-| System | Interaction |
-|---|---|
-| **Reconsolidation** | Habituation reduces recall score, but reconsolidation *increases* the memory's durability. A frequently-recalled memory resists temporal decay (fewer buckets) but gets a lower score on repeated queries. |
-| **Surprise Detection** | New, surprising memories start with high importance and no habituation penalty — they naturally dominate initial queries. |
-| **Suppression** | If a memory is fully suppressed, habituation is irrelevant — it's excluded at Step 4 before habituation is applied. |
-
----
-
-## Next Steps
-
-- :material-cancel: [**Inhibition — Suppression**](inhibition.md) — explicit memory blocking
-- :material-link: [**Hebbian — Association Learning**](hebbian.md) — how co-activation creates associations
-- :material-lightning-bolt: [**6-Phase Scoring Pipeline**](scoring-pipeline.md) — the full recall pipeline
diff --git a/docs/docs/memory/hebbian.md b/docs/docs/memory/hebbian.md
deleted file mode 100644
index 39ee6cd..0000000
--- a/docs/docs/memory/hebbian.md
+++ /dev/null
@@ -1,315 +0,0 @@
----
-title: "3-Layer Cognitive Graph"
-description: "HebbianGraph, TemporalChain, and EntityGraph — three biologically-inspired off-heap graph structures that augment vector recall with associative, temporal, and relational signals."
----
-
-# 🧠 3-Layer Cognitive Graph
-
-> **Packages**: `com.spectrayan.spector.memory.hebbian`, `.temporal`, `.graph`
->
-> **Biological Analog**: The brain doesn't retrieve memories by content similarity alone. It uses **associative networks** (neurons that fire together wire together), **temporal sequences** (what happened next?), and **semantic knowledge** (who manages what project?). Spector Memory implements all three as off-heap graph structures that augment vector recall.
-
----
-
-## Architecture Overview
-
-```mermaid
-graph TB
-    subgraph "RecallPipeline"
-        RP["Vector Search → 6-Phase Scoring → Top-K Seed Set"]
-    end
-
-    RP --> S5c["Step 5c: Hebbian<br/>Spreading Activation"]
-    RP --> S5d["Step 5d: Temporal<br/>Chain Extension"]
-    RP --> S5e["Step 5e: Entity<br/>Graph Traversal"]
-
-    S5c --> M["Merge & Dedup → Re-sort → Final Top-K"]
-    S5d --> M
-    S5e --> M
-
-    subgraph "Layer 1 — Hebbian Association"
-        HG["HebbianGraph<br/>164B/node, off-heap"]
-        CAT["CoActivationTracker<br/>OffHeapPairTable + OffHeapEdgeTable"]
-    end
-
-    subgraph "Layer 2 — Entity-Relationship"
-        EG["EntityGraph<br/>64B/entity, 12B/edge"]
-        EX["EntityExtractor SPI<br/>LLM / NoOp / Custom"]
-    end
-
-    subgraph "Layer 3 — Temporal Causal"
-        TC["TemporalChain<br/>16B/node, linked list"]
-    end
-
-    S5c --> HG
-    S5c --> CAT
-    S5d --> TC
-    S5e --> EG
-
-    style RP fill:#4a90d9,color:white
-    style M fill:#00b894,color:white
-    style HG fill:#e74c3c,color:white
-    style EG fill:#9b59b6,color:white
-    style TC fill:#f39c12,color:white
-```
-
-!!! tip "Graceful Degradation"
-    Each graph step is **additive** — it can only ADD candidates to the result set, never remove. If a graph is null, empty, or throws an exception, the step is a no-op. Zero risk of regression.
-
----
-
-## Layer 1: Hebbian Association Graph
-
-> *"Neurons that fire together, wire together."* — Donald Hebb, 1949
-
-### HebbianGraph — Memory-Level Associations
-
-The `HebbianGraph` stores explicit **memory-to-memory edges** with association weights in an off-heap adjacency list.
-
-```mermaid
-graph LR
-    A["Memory #42<br/>'database error'"] ---|"weight: 0.83<br/>co-ingested 5×"| B["Memory #87<br/>'connection pool'"]
-    A ---|"weight: 0.47<br/>co-ingested 2×"| C["Memory #103<br/>'retry strategy'"]
-    B ---|"weight: 0.63<br/>co-ingested 3×"| C
-
-    style A fill:#e74c3c,color:white
-    style B fill:#3498db,color:white
-    style C fill:#2ecc71,color:white
-```
-
-**Off-heap layout** (164 bytes per node):
-
-```
-┌──────────┬──────────────────────────────────────────────┐
-│ degree   │ edges[0..19]: (neighborIdx:4B, weight:4B)    │
-│ (4B)     │ = 20 × 8B = 160B                            │
-└──────────┴──────────────────────────────────────────────┘
-```
-
-**Key properties:**
-
-| Property | Value |
-|---|---|
-| Storage | Off-heap `MemorySegment` via Panama |
-| Max degree | 20 neighbors per memory |
-| Edge weight | Float — strengthened on co-ingestion |
-| Eviction | Weakest edge evicted when degree exceeds MAX_DEGREE |
-| Decay | 0.9 multiplicative factor per consolidation cycle |
-| Spreading activation | BFS with depth=2, attenuated by edge weight |
-| Persistence | `HGPH` magic header, chunked 64KB FileChannel I/O |
-
-**Pipeline integration:**
-
-- **Ingestion (Step 9b):** When memories are co-ingested within the same session, `HebbianGraph.strengthen(currentIdx, previousIdx, 1.0f)` strengthens the bidirectional edge.
-- **Recall (Step 5c):** After the 6-phase scorer produces a seed set, `HebbianGraph.activateNeighbors(seedIdx, depth=2)` discovers associated memories. These are added to the result set with a 0.3× score attenuation.
-
-### CoActivationTracker — Tag-Level Associations
-
-The `CoActivationTracker` tracks **tag co-occurrence patterns** using two off-heap hash tables:
-
-#### OffHeapPairTable — Undirected Co-Activation Counts
-
-Tracks how often two tags appear together in ingested memories.
-
-```
-Slot layout (32 bytes):
-┌───────────┬───────────┬──────────┬───────┐
-│ keyHashA  │ keyHashB  │ count    │ flags │
-│ 8 bytes   │ 8 bytes   │ 4 bytes  │ ...   │
-└───────────┴───────────┴──────────┴───────┘
-```
-
-- Open-addressing hash table with linear probing
-- FNV-1a 64-bit hashing for tag strings
-- ~50% load factor for fast lookups
-
-#### OffHeapEdgeTable — Directed STDP Edges
-
-Tracks causal/predictive relationships between tags (Spike-Timing Dependent Plasticity):
-
-```
-Slot layout (40 bytes):
-┌────────────┬────────────┬────────┬──────────┬───────────┬───────┐
-│ sourceHash │ targetHash │ weight │ lastMs   │ actCount  │ flags │
-│ 8 bytes    │ 8 bytes    │ 4 bytes│ 8 bytes  │ 4 bytes   │ ...   │
-└────────────┴────────────┴────────┴──────────┴───────────┴───────┘
-```
-
-- Weight clamped to `[0.0, 1.0]`
-- Temporal metadata for STDP learning rules
-- Persistence via `COAX` magic header with hash→tag reverse map
-
-!!! info "STDP — Spike-Timing Dependent Plasticity"
-    If tag A is consistently recalled *before* tag B, the directed edge A→B is strengthened. This creates predictive associations: "when I think of A, I should also think of B." The `HebbianCoActivationListener` runs after each recall on a Virtual Thread, updating STDP weights with zero impact on recall latency.
-
----
-
-## Layer 2: Entity-Relationship Graph
-
-> *"What was the budget of the project managed by the person who met with me yesterday?"*
-
-The `EntityGraph` stores **typed entities** (PERSON, PROJECT, ORG, ...) and **typed relations** (MANAGES, AUTHORED, PART_OF, ...) extracted from ingested text. This enables **multi-hop knowledge traversal** that pure vector similarity cannot achieve.
-
-### Entity Extraction
-
-Entities are extracted at ingestion time via the `EntityExtractor` SPI:
-
-| Mode | Implementation | Description |
-|---|---|---|
-| `NONE` (default) | `NoOpEntityExtractor` | No extraction — graph features disabled |
-| `LLM` | `LlmEntityExtractor` | Uses `TextGenerationProvider` with a structured prompt |
-| `CUSTOM` | User-provided | Any custom `EntityExtractor` implementation |
-
-```java
-// Enable LLM entity extraction via Builder
-SpectorMemory.builder()
-    .entityExtractionMode(EntityExtractionMode.LLM)
-    .textGenerationProvider(provider)
-    .build();
-```
-
-### Type System
-
-**22 Entity Types:**
-`PERSON`, `ORGANIZATION`, `PROJECT`, `CONCEPT`, `EVENT`, `LOCATION`, `TOOL`, `SKILL`, `DOCUMENT`, `API`, `DATABASE`, `FRAMEWORK`, `PROTOCOL`, `METRIC`, `ROLE`, `TEAM`, `PRODUCT`, `SERVICE`, `WORKFLOW`, `DECISION`, `RISK`, `OTHER`
-
-**21 Relation Types:**
-`MANAGES`, `AUTHORED`, `ATTENDED`, `PART_OF`, `RELATED_TO`, `CAUSES`, `DEPENDS_ON`, `USES`, `CREATED`, `MENTIONS`, `MEMBER_OF`, `ASSIGNED_TO`, `REPORTED_BY`, `BLOCKED_BY`, `IMPLEMENTS`, `EXTENDS`, `TESTED_BY`, `DEPLOYED_TO`, `MONITORS`, `TRIGGERS`, `OTHER`
-
-### Off-Heap Layout
-
-**Entity Node (64 bytes, 8-byte aligned):**
-```
-[type:1B][pad:7B][nameHash:8B][memRef0:4B][memRef1:4B][memRef2:4B][memRef3:4B]
-[refCount:4B][degree:4B][edgeStart:4B][pad:20B]
-```
-
-**Entity Edge (12 bytes):**
-```
-[targetId:4B][relationType:4B][weight:4B]
-```
-
-**Traversal:** BFS with typed edge filtering, max 32 edges per entity, max 4 memory references per entity.
-
-**Pipeline integration:**
-
-- **Ingestion (Step 9d):** Extract entities from text → `entityGraph.addEntity(name, type)` → `entityGraph.linkEntityToMemory(eid, memoryIdx)` → `entityGraph.addRelation(fromEid, toEid, relationType)`
-- **Recall (Step 5e):** Extract entities from query → find in graph by name → 2-hop BFS → collect `memoriesForEntity(eid)` → add to result set with 0.25× attenuation per hop
-- **Persistence:** `ENTG` magic header with on-heap nameIndex reconstruction on load
-
----
-
-## Layer 3: Temporal Causal Chain
-
-> *"What happened after the deployment failed?"*
-
-The `TemporalChain` links memories ingested within the same session into a **doubly-linked list**, enabling temporal navigation.
-
-```mermaid
-graph LR
-    M1["Memory #12<br/>'deploy started'"] --> M2["Memory #13<br/>'tests passed'"]
-    M2 --> M3["Memory #14<br/>'deploy failed'"]
-    M3 --> M4["Memory #15<br/>'rollback initiated'"]
-
-    style M1 fill:#3498db,color:white
-    style M2 fill:#2ecc71,color:white
-    style M3 fill:#e74c3c,color:white
-    style M4 fill:#f39c12,color:white
-```
-
-### Off-Heap Layout (16 bytes per node)
-
-```
-┌──────────┬──────────┬───────────┬──────────┐
-│ prevIdx  │ nextIdx  │ sessionId │ pad      │
-│ 4 bytes  │ 4 bytes  │ 4 bytes   │ 4 bytes  │
-└──────────┴──────────┴───────────┴──────────┘
-```
-
-`-1` is used as sentinel for "no link" (beginning or end of chain).
-
-**API:**
-
-| Method | Description |
-|---|---|
-| `link(currentIdx, prevIdx, sessionId)` | Links two memories within a session |
-| `followForward(startIdx, maxHops)` | "What happened next?" → `List<Integer>` |
-| `followBackward(startIdx, maxHops)` | "What happened before?" → `List<Integer>` |
-| `save(Path)` / `load(Path)` | Persistence with `TPCH` magic header |
-
-**Pipeline integration:**
-
-- **Ingestion (Step 9c):** When a new memory is ingested within the same session, `temporalChain.link(currentIdx, lastIngestedIdx, sessionId)` creates the bidirectional link.
-- **Recall (Step 5d):** For each seed result, `followForward(idx, 3)` and `followBackward(idx, 3)` discover temporally adjacent memories. Forward links get 0.8× score, backward links get 0.7×.
-
----
-
-## Persistence
-
-All graph components persist alongside episodic partitions in DISK mode:
-
-| Component | File | Magic | Format |
-|---|---|---|---|
-| HebbianGraph | `hebbian.graph` | `HGPH` | 16B header + raw segment bytes |
-| CoActivationTracker | `coactivation.dat` | `COAX` | 16B header + pair table + edge table + hash→tag map |
-| EntityGraph | `entity.graph` | `ENTG` | 16B header + entity segment + edge segment + name index |
-| TemporalChain | `temporal.chain` | `TPCH` | 16B header + raw segment bytes |
-
-All use chunked 64KB FileChannel I/O to avoid `ByteBuffer` overflow on large segments.
-
----
-
-## Error Framework
-
-Graph operations use granular exceptions from the `SpectorGraphException` hierarchy:
-
-```
-SpectorMemoryException (SPE-310-xxx)
-  └── SpectorGraphException (base)
-      ├── SpectorHebbianException         (SPE-310-006)
-      ├── SpectorTemporalChainException   (SPE-310-007)
-      ├── SpectorEntityGraphException     (SPE-310-008)
-      ├── SpectorCoActivationException    (SPE-310-009)
-      ├── SpectorGraphPersistenceException(SPE-310-010)
-      └── SpectorGraphDecayException      (SPE-310-011)
-```
-
-All pipeline catch sites use `catch(RuntimeException)` → create granular exception → `log.warn(ex.getMessage())`. No generic catches, no swallowed exceptions.
-
----
-
-## Memory Budget
-
-| Layer | Per-Node | At 100K memories | At 1M memories |
-|---|---|---|---|
-| Hebbian (L1) | 164B | 16.4 MB | 164 MB |
-| CoActivation | ~1MB total | ~1 MB | ~1 MB |
-| Entity (L2) | ~64B + edges | ~8 MB | ~80 MB |
-| Temporal (L3) | 16B | 1.6 MB | 16 MB |
-| **Total** | | **~27 MB** | **~261 MB** |
-
-This is small compared to the vector store (100K × 768-dim × 1B quantized = 75 MB).
-
----
-
-## Why This Matters for AI Agents
-
-Traditional vector search treats each query independently. The 3-layer graph creates **emergent intelligence**:
-
-!!! example "Scenario: Multi-Signal Recall"
-    1. Agent queries "why is the app slow?"
-    2. **Vector search** → finds memory about "application latency"
-    3. **Hebbian (Layer 1)** → that memory was co-ingested with "connection pool settings" → adds it to results
-    4. **Temporal (Layer 3)** → follows the chain: connection pool → timeout config → retry backoff → adds all three
-    5. **Entity (Layer 2)** → "connection pool" mentions entity "DatabaseService" → traverses DEPENDS_ON edge → finds "Redis cache config" → adds it
-
-    The final result set contains memories that no single retrieval signal could have found alone.
-
----
-
-## Next Steps
-
-- :material-lightning-bolt: [**6-Phase Scoring Pipeline**](scoring-pipeline.md) — the SIMD hot-loop that produces the seed set
-- :material-sleep: [**Habituation — Anti-Filter Bubble**](habituation.md) — preventing repetitive recall
-- :material-head-cog: [**Dopamine — Surprise Detection**](dopamine.md) — auto-importance scoring
-- :material-brain: [**Architecture**](architecture.md) — how graphs fit in the full pipeline
diff --git a/docs/docs/memory/hippocampus.md b/docs/docs/memory/hippocampus.md
deleted file mode 100644
index 1bf87c1..0000000
--- a/docs/docs/memory/hippocampus.md
+++ /dev/null
@@ -1,160 +0,0 @@
----
-title: "Hippocampus — Sleep Consolidation"
-description: "How ReflectDaemon consolidates episodic memories into semantic knowledge during 'sleep' — K-Means clustering, tombstone compaction, and partition rebuild."
----
-
-# 🛏️ Hippocampus — Sleep Consolidation
-
-> **Package**: `com.spectrayan.spector.memory.hippocampus`
->
-> **Biological Analog**: During sleep, the **hippocampus replays** episodic memory traces to the neocortex, gradually transferring knowledge from episode-specific to generalized semantic form. This is called **systems consolidation**. Simultaneously, **synaptic pruning** weakens unused connections — the brain's garbage collector.
-
----
-
-## The Two Mechanisms
-
-### 1. ReflectDaemon — Sleep Consolidation
-
-The `ReflectDaemon` performs K-Means clustering on episodic memories to extract semantic knowledge:
-
-```mermaid
-sequenceDiagram
-    participant RD as ReflectDaemon
-    participant EP as EpisodicMemoryStore
-    participant CS as CognitiveScorer
-    participant SE as SemanticMemoryStore
-    participant MI as MemoryIndex
-
-    Note over RD: Circadian trigger (configurable interval)
-    RD->>EP: partitions().filter(SEALED)
-    
-    loop Each sealed partition
-        RD->>EP: Read all records from partition
-        Note over RD: K-Means clustering on header features
-        RD->>RD: Cluster by (synapticTags AND, importance AVG)
-        
-        loop Each cluster (size ≥ threshold)
-            Note over RD: Compute centroid header
-            RD->>RD: Merge synaptic tags (AND across cluster)
-            RD->>RD: Average importance, max valence
-            RD->>SE: Write consolidated semantic record
-            RD->>MI: Register new semantic memory
-        end
-        
-        RD->>EP: Mark partition as REFLECTABLE
-    end
-```
-
-**Key behaviors**:
-
-- **Tag merging**: Uses bitwise AND across the cluster — only common tags survive, representing the shared theme
-- **Importance averaging**: The consolidated memory inherits the mean importance of its source episodes
-- **Minimum cluster size**: Small clusters (noise) are not promoted — only patterns are
-
-!!! example "Example: Consolidation in Action"
-    An agent encounters 15 episodic memories tagged `[database, connection, error]` over a week. The ReflectDaemon clusters them and promotes a single semantic memory: *"Database connection issues are recurring — check connection pool sizing and timeout settings."*
-
----
-
-### 2. TombstoneCompactor — Synaptic Pruning
-
-When memories are `forget()`'d, they are tombstoned (bit 0 of flags byte set to 1). The scorer skips them in Phase 1 (~1 cycle). But tombstoned records still consume disk space.
-
-When the tombstone ratio in a partition exceeds a threshold (default: 30%), the `TombstoneCompactor` triggers a **partition rebuild**:
-
-```mermaid
-graph LR
-    A["Old Partition<br/>1000 records<br/>400 tombstoned<br/>(40% ratio)"] -->|TombstoneCompactor| B["New Partition<br/>600 records<br/>0 tombstoned<br/>(dense)"]
-    A -->|"atomicSwap()"| C["Closed & Deleted"]
-    
-    style A fill:#e74c3c,color:white
-    style B fill:#2ecc71,color:white
-    style C fill:#95a5a6,color:white
-```
-
-**The rebuild process**:
-
-1. Allocate a new partition file
-2. Sequentially copy only live (non-tombstoned) records
-3. Atomically swap the new partition into the `ConcurrentMap`
-4. Close and delete the old partition
-
-```java
-// Atomic swap — readers see either the old or new partition, never a torn state
-public boolean replacePartition(String key, 
-    EpisodicPartition oldPartition, EpisodicPartition newPartition) {
-    boolean replaced = partitions.replace(key, oldPartition, newPartition);
-    if (replaced) {
-        oldPartition.close();
-    }
-    return replaced;
-}
-```
-
-!!! warning "Concurrent Safety"
-    The swap uses `ConcurrentMap.replace(key, old, new)` — a CAS (compare-and-swap) operation. Readers that are mid-scan on the old partition will complete safely because the old `MemorySegment` remains valid until `close()`. New scans will use the compacted partition.
-
----
-
-## Circadian Trigger
-
-The ReflectDaemon runs on a configurable schedule. During ingestion, the `CognitiveIngestionTarget` checks if it's time for a consolidation cycle:
-
-```java
-// In CognitiveIngestionTarget — after each write
-private void checkCircadianTrigger() {
-    long now = System.currentTimeMillis();
-    if (now - lastReflectMs > reflectIntervalMs) {
-        lastReflectMs = now;
-        reflectDaemon.reflect();
-    }
-}
-```
-
-The default interval is 24 hours — matching the biological circadian cycle. For testing, it can be set to any duration.
-
----
-
-## Partition State Machine
-
-```mermaid
-stateDiagram-v2
-    [*] --> ACTIVE: New day → create partition
-    ACTIVE --> SEALED: Day rolls over
-    SEALED --> REFLECTABLE: ReflectDaemon processes
-    REFLECTABLE --> TOMBSTONED: tombstoneRatio > 30%
-    TOMBSTONED --> COMPACTED: TombstoneCompactor rebuilds
-    
-    ACTIVE --> TOMBSTONED: High forget rate during active day
-    
-    note right of ACTIVE: Accepting writes
-    note right of SEALED: Read-only, awaiting consolidation
-    note right of REFLECTABLE: Consolidation complete, eligible for pruning
-    note right of TOMBSTONED: Queued for compaction
-    note right of COMPACTED: Rebuilt as dense partition
-```
-
----
-
-## ReflectReport
-
-Each consolidation cycle produces a `ReflectReport` summarizing what happened:
-
-```java
-public record ReflectReport(
-    int partitionsProcessed,
-    int memoriesConsolidated,
-    int semanticMemoriesCreated,
-    long durationMs
-) {}
-```
-
-This can be logged, monitored, or exposed via the `MemoryIntrospector` for observability.
-
----
-
-## Next Steps
-
-- :material-brain: [**Cortex — Tier Stores**](cortex.md) — the 4-tier architecture
-- :material-flash: [**Synapse — Tags & Scoring**](synapse.md) — the 32-byte header
-- :material-head-cog: [**Dopamine — Surprise Detection**](dopamine.md) — auto-importance scoring
diff --git a/docs/docs/memory/importance-fusion.md b/docs/docs/memory/importance-fusion.md
deleted file mode 100644
index 6c832a6..0000000
--- a/docs/docs/memory/importance-fusion.md
+++ /dev/null
@@ -1,178 +0,0 @@
-# Importance Fusion (ICNU)
-
-The **ICNU Importance Fusion** system computes a memory's importance score at ingestion time by blending four signals: **Interest**, **Challenge**, **Novelty**, and **Urgency**.
-
----
-
-## The Problem
-
-Without ICNU, importance is determined solely by the [Surprise Detector](dopamine.md) — a statistical outlier test based on how "surprising" a memory's embedding is relative to recent memories. This works well for detecting unusual information, but has blind spots:
-
-- A memory about a user's **urgent deadline** might not be statistically surprising
-- A memory about a **challenging technical problem** might have a common embedding
-- A memory that the agent finds **interesting** has no way to signal that interest
-
-ICNU adds three LLM-provided signals alongside the existing novelty signal to produce a richer importance score.
-
----
-
-## The Formula
-
-$$
-\text{importance} = 0.05 + \left(\sum_{i \in \{I,C,N,U\}} w_i \cdot x_i\right) \times 9.95
-$$
-
-Where:
-
-| Signal | Symbol | Range | Source |
-|:---|:---:|:---:|:---|
-| Interest | $x_I$ | [0, 1] | LLM-provided hint |
-| Challenge | $x_C$ | [0, 1] | LLM-provided hint |
-| Novelty | $x_N$ | [0, 1] | Computed from working memory scan |
-| Urgency | $x_U$ | [0, 1] | LLM-provided hint |
-
-The weights $w_i$ are configurable and auto-normalize to sum=1.0:
-
-| Weight | Default | Rationale |
-|:---|:---:|:---|
-| $w_I$ (interest) | 0.30 | Agent engagement is a strong signal |
-| $w_C$ (challenge) | 0.10 | Complexity is less important than novelty |
-| $w_N$ (novelty) | 0.40 | Novelty is the strongest predictor of future usefulness |
-| $w_U$ (urgency) | 0.20 | Time-sensitive information needs priority |
-
-### Output Range
-
-The formula maps to importance ∈ **[0.05, 10.0]**:
-
-- **0.05** — All signals zero (routine, uninteresting, familiar, non-urgent)
-- **10.0** — All signals maximal (interesting, challenging, novel, urgent)
-
----
-
-## Novelty Computation
-
-### How It Works
-
-Novelty is computed using the **nearest-neighbor distance** in working memory — the minimum L2 distance between the incoming embedding and all existing working memory slots:
-
-```java
-float nearestDist = workingStore.nearestDistance(quantizedVector, mins, scales);
-```
-
-`nearestDistance()` performs a SIMD-accelerated scan of all working memory slots (~0.5ms for 100 slots × 768 dims) and returns the minimum L2 distance. A high distance means the memory is genuinely novel — it's far from everything the agent has seen recently.
-
-### Normalization
-
-The raw distance is normalized to [0, 1] via:
-
-$$
-\text{noveltyNorm} = \min\left(\frac{d_{\text{nearest}}}{2.0}, 1.0\right)
-$$
-
-Where 2.0 is a configurable threshold representing "maximally novel."
-
----
-
-## IngestionHints
-
-The LLM provides hints via the `IngestionHints` record:
-
-```java
-// At ingestion time
-var hints = new IngestionHints(
-    0.8f,   // interest: agent finds this very interesting
-    0.3f,   // challenge: moderate complexity
-    0.9f    // urgency: high time sensitivity
-);
-
-// Novelty is computed automatically from working memory
-cognitiveTarget.ingestCognitive(id, text, type, tags, source, hints);
-```
-
-### Safety Features
-
-- **Clamping**: All values are clamped to [0.0, 1.0] on construction
-- **Fallback**: `IngestionHints.NONE` triggers novelty-only mode (backward compatible)
-- **Gaming detection**: If all hints are maximal (I=1.0, C=1.0, U=1.0), a WARN is logged
-
-### NONE Fallback
-
-When no hints are provided (`IngestionHints.NONE`), the system falls back to `IcnuWeights.NOVELTY_ONLY` — importance is determined solely by nearest-neighbor distance, matching the pre-ICNU behavior.
-
----
-
-## Configuration
-
-### Fusion Weights
-
-```java
-var memory = SpectorMemory.builder()
-    .icnuWeights(new IcnuWeights(0.4f, 0.1f, 0.3f, 0.2f))  // custom weights
-    .build();
-```
-
-### Built-in Weight Presets
-
-| Preset | I | C | N | U | Use Case |
-|:---|:---:|:---:|:---:|:---:|:---|
-| `DEFAULT` | 0.30 | 0.10 | 0.40 | 0.20 | General-purpose |
-| `NOVELTY_ONLY` | 0.00 | 0.00 | 1.00 | 0.00 | Backward-compatible |
-
-### Weight Auto-Normalization
-
-Weights are automatically normalized on construction:
-
-```java
-var w = new IcnuWeights(1f, 1f, 1f, 1f);
-// → interest=0.25, challenge=0.25, novelty=0.25, urgency=0.25
-```
-
----
-
-## Worked Example
-
-Agent ingests: *"User has a production outage — database connections exhausted"*
-
-| Signal | Value | Source |
-|:---|:---:|:---|
-| Interest | 0.7 | LLM hint — agent finds this relevant |
-| Challenge | 0.5 | LLM hint — moderate complexity |
-| Novelty | 0.9 | Working memory scan — nothing like this recently |
-| Urgency | 1.0 | LLM hint — production outage |
-
-With default weights:
-
-$$
-\text{weighted} = 0.30 \times 0.7 + 0.10 \times 0.5 + 0.40 \times 0.9 + 0.20 \times 1.0 = 0.81
-$$
-
-$$
-\text{importance} = 0.05 + 0.81 \times 9.95 = \mathbf{8.11}
-$$
-
-This is a high-importance memory (8.11 / 10.0) — it will be prioritized in future recalls and resist time decay.
-
----
-
-## MCP Integration
-
-When using the MCP tools, importance fusion happens automatically if the ingestion tool provides hints:
-
-```json
-{
-  "name": "core_memory_append",
-  "arguments": {
-    "id": "outage-2024-01",
-    "text": "Production database connections exhausted at 2AM",
-    "tags": "production,database,outage",
-    "hints": {
-      "interest": 0.7,
-      "challenge": 0.5,
-      "urgency": 1.0
-    }
-  }
-}
-```
-
-!!! note "Backward Compatibility"
-    The `hints` field is optional. When omitted, importance is computed using novelty-only mode — identical to the pre-ICNU behavior.
diff --git a/docs/docs/memory/index.md b/docs/docs/memory/index.md
deleted file mode 100644
index 4da4ee4..0000000
--- a/docs/docs/memory/index.md
+++ /dev/null
@@ -1,193 +0,0 @@
----
-title: "🧠 Cognitive Memory"
-description: "The biologically-inspired memory engine that gives AI agents the ability to remember, forget, consolidate, and associate — at microsecond latency."
----
-
-# 🧠 Cognitive Memory
-
-!!! quote "The Vision"
-    Legacy AI frameworks bolt memory onto flat vector databases. Spector Memory is designed from the ground up as a **cognitive memory engine** — a biologically-inspired system where memories have importance, emotions, temporal decay, and contextual tags. It's the difference between a filing cabinet and a brain.
-
----
-
-## What Makes This Different
-
-Every AI memory solution today — Mem0, Letta (MemGPT), Zep — wraps a Python layer around Postgres/pgvector or ChromaDB. They suffer from:
-
-- **Network latency**: 50-200ms per query (HTTP → Postgres → HTTP)
-- **Python GIL**: Sequential embedding + scoring under a global lock
-- **Post-filtering trap**: Retrieve top-K by similarity, *then* filter by importance/time — losing critical memories that are old but vital
-
-Spector Memory collapses the entire cognitive stack onto a **zero-GC, off-heap Panama memory store** with SIMD-accelerated scoring. The result:
-
-| Metric | Python Memory Layer | **Spector Memory** |
-|---|---|---|
-| Query latency (1M memories) | 50-200ms | **0.13ms** † |
-| GC pauses | Unpredictable | **≤0.01%** (100% off-heap) † |
-| Scoring pipeline | Post-filter (lossy) | **Fused SIMD** (lossless) |
-| Concurrent queries | GIL-limited | **61,000 QPS** (Virtual Threads) † |
-| Memory per record | ~500B (Python objects) | **32B header + quantized vector** |
-
-† *Measured on Intel Core Ultra 9 285K, Java 25, AVX2. See [Benchmarks](performance.md).*
-
----
-
-## The Biological Metaphor
-
-Spector Memory maps every major cognitive subsystem from neuroscience to a dedicated Java package:
-
-```mermaid
-graph TB
-    subgraph "🧠 Spector Memory"
-        SM[SpectorMemory<br/>Façade] --> CT[CognitiveIngestionTarget<br/>Cognitive remember]
-        SM --> RP[RecallPipeline<br/>Parallel recall]
-        
-        subgraph "Cortex — Tier Stores"
-            TR[TierRouter] --> WM[Working<br/>Prefrontal Cortex]
-            TR --> EM[Episodic<br/>Hippocampus]
-            TR --> SE[Semantic<br/>Neocortex]
-            TR --> PR[Procedural<br/>Basal Ganglia]
-        end
-        
-        subgraph "Synapse — Scoring"
-            CS[CognitiveScorer<br/>6-phase SIMD] --> STE[SynapticTagEncoder<br/>Bloom Filter]
-            CS --> DS[DecayStrategy<br/>Temporal Decay]
-        end
-        
-        subgraph "Neuromodulators"
-            SD[SurpriseDetector<br/>Dopamine] --> FP[FlashbulbPolicy]
-            VT[ValenceTracker<br/>Amygdala]
-            HP[HabituationPenalty<br/>Anti-filter bubble]
-            SS[SuppressionSet<br/>Inhibition]
-        end
-        
-        subgraph "3-Layer Cognitive Graph"
-            HG[HebbianGraph<br/>Layer 1: Association]
-            EG[EntityGraph<br/>Layer 2: Knowledge]
-            TC[TemporalChain<br/>Layer 3: Causal]
-            CA[CoActivationTracker<br/>STDP Learning]
-        end
-        
-        subgraph "Consolidation"
-            RD[ReflectDaemon<br/>Sleep Consolidation]
-            TCC[TombstoneCompactor<br/>Synaptic Pruning]
-        end
-        
-        CT --> TR
-        RP --> CS
-        RP --> TR
-        RP --> HG
-        RP --> TC
-        RP --> EG
-    end
-```
-
----
-
-## The 4-Tier Memory Architecture
-
-Just as the human brain has distinct memory systems, Spector organizes memories into four cognitive tiers:
-
-=== "🧪 Working Memory"
-
-    **Biological analog: Prefrontal Cortex**
-    
-    Volatile, limited-capacity buffer for the current task context. Circular buffer — oldest entries are evicted when full.
-    
-    - **Capacity**: Configurable (default: 100 records)
-    - **Storage**: In-memory `Arena.ofShared()` segment
-    - **Use case**: "What was the user just talking about?"
-
-=== "📝 Episodic Memory"
-
-    **Biological analog: Hippocampus**
-    
-    Time-stamped event records. Partitioned by day, backed by mmap'd files for persistence across JVM restarts. Supports sleep consolidation into semantic memory.
-    
-    - **Capacity**: Unbounded (partitioned, mmap-backed)
-    - **Storage**: `FileChannel.map()` with 64-byte metadata header per partition
-    - **Use case**: "What error did we debug yesterday?"
-
-=== "🧬 Semantic Memory"
-
-    **Biological analog: Neocortex**
-    
-    Distilled, permanent knowledge. Created by sleep consolidation (ReflectDaemon) from episodic clusters, or directly by the user.
-    
-    - **Capacity**: Configurable (default: 5,000 records)
-    - **Storage**: Header-only slab (fast metadata scan)
-    - **Use case**: "The user prefers dark mode."
-
-=== "⚙️ Procedural Memory"
-
-    **Biological analog: Basal Ganglia**
-    
-    Learned procedures, rules, and patterns. Small, append-only store for procedural knowledge.
-    
-    - **Capacity**: Configurable (default: 500 records)
-    - **Storage**: In-memory `Arena.ofShared()` segment
-    - **Use case**: "Always use exponential backoff for retries."
-
----
-
-## Explore the Documentation
-
-<div class="grid cards" markdown>
-
--   :material-brain:{ .lg .middle } **System Architecture**
-
-    ---
-
-    Package hierarchy, data flow diagrams, and extensibility model
-
-    [:octicons-arrow-right-24: Architecture](architecture.md)
-
--   :material-lightning-bolt:{ .lg .middle } **6-Phase Scoring Pipeline**
-
-    ---
-
-    Deep dive into the SIMD hot-loop: tombstone → tags → valence → importance → L2 → fused score
-
-    [:octicons-arrow-right-24: Scoring Pipeline](scoring-pipeline.md)
-
--   :material-share-variant:{ .lg .middle } **3-Layer Cognitive Graph**
-
-    ---
-
-    Hebbian association, entity-relationship knowledge, and temporal causal chains — three off-heap graph structures that augment vector recall
-
-    [:octicons-arrow-right-24: Cognitive Graph](hebbian.md)
-
--   :material-head-cog:{ .lg .middle } **Biological Systems**
-
-    ---
-
-    Each brain region mapped to code: Cortex, Hippocampus, Synapse, Dopamine, Amygdala, Habituation, Inhibition
-
-    [:octicons-arrow-right-24: Start with Cortex](cortex.md)
-
--   :material-speedometer:{ .lg .middle } **Performance & SIMD**
-
-    ---
-
-    Benchmark results, SIMD kernel throughput, optimization techniques, virtual thread scaling
-
-    [:octicons-arrow-right-24: Performance](performance.md)
-
--   :material-memory:{ .lg .middle } **Off-Heap Panama Design**
-
-    ---
-
-    Zero-GC architecture, MemorySegment lifecycle, mmap partitions, 32-byte CognitiveRecord binary format
-
-    [:octicons-arrow-right-24: Panama Design](panama-design.md)
-
--   :material-api:{ .lg .middle } **API Reference**
-
-    ---
-
-    SpectorMemory.Builder, RecallOptions, CognitiveResult, MemoryType — full method signatures
-
-    [:octicons-arrow-right-24: API Reference](api-reference.md)
-
-</div>
diff --git a/docs/docs/memory/inhibition.md b/docs/docs/memory/inhibition.md
deleted file mode 100644
index 09b08c9..0000000
--- a/docs/docs/memory/inhibition.md
+++ /dev/null
@@ -1,150 +0,0 @@
----
-title: "Inhibition — Suppression"
-description: "SuppressionSet enables explicit memory blocking — the digital equivalent of motivated forgetting."
----
-
-# 🚫 Inhibition — Suppression
-
-> **Package**: `com.spectrayan.spector.memory.inhibition`
->
-> **Biological Analog**: **Retrieval-Induced Forgetting** (Anderson et al., 1994) — the brain actively suppresses competing memories during recall. When you try to remember where you parked today, your brain inhibits memories of yesterday's parking spot. This is an active process, not passive decay.
-
----
-
-## The Concept
-
-Suppression is different from forgetting:
-
-| Operation | Method | Effect | Reversible? |
-|---|---|---|---|
-| **Forget** | `memory.forget(id)` | Tombstones the record — permanently excluded from all scans | No |
-| **Suppress** | `memory.suppress(id, reason)` | Adds to suppression set — excluded from recall results | **Yes** |
-
-Tombstoning modifies the off-heap flags byte (bit 0 = 1). Suppression maintains a separate in-memory set — the underlying memory is untouched and can be un-suppressed later.
-
----
-
-## SuppressionSet
-
-```java
-public final class SuppressionSet {
-    
-    private final ConcurrentHashMap<String, String> suppressed = new ConcurrentHashMap<>();
-    
-    /**
-     * Suppresses a memory — it will be excluded from all future recall results.
-     *
-     * @param memoryId the memory to suppress
-     * @param reason   human-readable reason (for auditability)
-     */
-    public void suppress(String memoryId, String reason) {
-        suppressed.put(memoryId, reason != null ? reason : "");
-    }
-    
-    /**
-     * Removes suppression — the memory will appear in recall results again.
-     */
-    public void unsuppress(String memoryId) {
-        suppressed.remove(memoryId);
-    }
-    
-    /**
-     * Checks if a memory is currently suppressed.
-     * Called at Step 4 of the recall pipeline.
-     */
-    public boolean isSuppressed(String memoryId) {
-        return suppressed.containsKey(memoryId);
-    }
-    
-    /**
-     * Returns the number of currently suppressed memories.
-     */
-    public int size() {
-        return suppressed.size();
-    }
-}
-```
-
----
-
-## Integration with RecallPipeline
-
-Suppression is checked at **Step 4** of the recall pipeline — after scoring but before habituation:
-
-```java
-// Step 4: Filter suppressed memories (inhibition)
-allResults.removeIf(r -> suppressionSet.isSuppressed(r.id()));
-```
-
-**Timing matters**: Suppression is checked *after* the CognitiveScorer completes. This means suppressed memories still consume SIMD cycles during scoring. For high-frequency suppression scenarios, consider using `forget()` instead.
-
----
-
-## Use Cases
-
-### 1. User Redaction
-
-```java
-// User says: "Please forget what I said about project X"
-memory.suppress("project-x-conversation-1", "User requested redaction");
-memory.suppress("project-x-conversation-2", "User requested redaction");
-```
-
-### 2. Context Switching
-
-```java
-// Agent is switching tasks — suppress irrelevant context
-memory.suppress("frontend-task-context", "Switching to backend work");
-
-// Later, when switching back:
-memory.unsuppress("frontend-task-context");
-```
-
-### 3. Stale Data Quarantine
-
-```java
-// A data source is known to be stale — suppress while validating
-for (String id : staleSourceMemories) {
-    memory.suppress(id, "Source under validation — suppressed until confirmed");
-}
-```
-
-### 4. A/B Testing Memory Strategies
-
-```java
-// Suppress certain memories to test how the agent performs without them
-experimentGroup.forEach(id -> 
-    memory.suppress(id, "A/B test: control group"));
-```
-
----
-
-## Suppression vs. Tombstone
-
-```mermaid
-graph TB
-    subgraph "Suppress (Reversible)"
-        S1["memory.suppress(id)"] --> S2["SuppressionSet.add(id)"]
-        S2 --> S3["Recall Pipeline<br/>Step 4: removeIf(suppressed)"]
-        S3 --> S4["Can unsuppress(id)"]
-    end
-    
-    subgraph "Forget (Permanent)"
-        F1["memory.forget(id)"] --> F2["flags byte |= 0x01<br/>(tombstone bit)"]
-        F2 --> F3["CognitiveScorer<br/>Phase 1: skip immediately"]
-        F3 --> F4["Permanent — cannot undo"]
-    end
-    
-    style S4 fill:#2ecc71,color:white
-    style F4 fill:#e74c3c,color:white
-```
-
-**Performance difference**: Tombstoned memories are skipped in Phase 1 of the scorer (~1 cycle). Suppressed memories go through the full 6-phase scoring pipeline and are only filtered at Step 4 of the recall pipeline. For bulk suppression, `forget()` is more efficient.
-
----
-
-## Next Steps
-
-- :material-speedometer: [**Performance**](performance.md) — benchmark results and optimization techniques
-- :material-sleep: [**Habituation — Anti-Filter Bubble**](habituation.md) — automatic score attenuation
-- :material-brain: [**Architecture**](architecture.md) — where suppression fits in the pipeline
diff --git a/docs/docs/memory/interference.md b/docs/docs/memory/interference.md
deleted file mode 100644
index 24d11d3..0000000
--- a/docs/docs/memory/interference.md
+++ /dev/null
@@ -1,76 +0,0 @@
----
-title: "Interference — Deduplication"
-description: "SemanticDeduplicator detects near-duplicate memories and merges them to prevent proactive interference."
----
-
-# 🔀 Interference — Deduplication
-
-> **Package**: `com.spectrayan.spector.memory.interference`
->
-> **Biological Analog**: **Proactive interference** occurs when old memories interfere with new learning. If you move to a new city, your old address "interferes" when you try to recall the new one. The brain resolves this by strengthening the newer trace and weakening the old one.
-
----
-
-## The Problem
-
-Without deduplication, an agent remembering the same fact repeatedly creates redundant entries:
-
-```
-memory[0]: "User prefers dark mode"     importance=0.8
-memory[1]: "User prefers dark mode"     importance=0.7
-memory[2]: "The user likes dark mode"   importance=0.9  ← near-duplicate
-```
-
-These compete during recall, waste storage, and dilute the Hebbian co-activation signal.
-
----
-
-## SemanticDeduplicator
-
-The `SemanticDeduplicator` detects near-duplicates by computing L2 distance between the new memory's vector and existing memories. When a match is found within a configurable threshold, it **merges** rather than creating a new record:
-
-```java
-public final class SemanticDeduplicator {
-
-    /**
-     * Checks if a near-duplicate exists and merges if found.
-     * 
-     * Merge strategy:
-     * - importance = max(existing, new)
-     * - synapticTags = existing | new  (OR-merge: union of Bloom filters)
-     * - timestamp = most recent
-     * - recallCount preserved from existing
-     */
-    public Optional<Long> findAndMerge(MemorySegment segment, int recordCount,
-                                        CognitiveRecordLayout layout,
-                                        float[] newVector, CognitiveHeader newHeader,
-                                        float threshold) {
-        // Scan for near-duplicate within L2 threshold
-        // If found: merge headers via OR on tags, max on importance
-        // Return offset of merged record (or empty if no duplicate)
-    }
-}
-```
-
-**Merge rules**:
-
-| Field | Strategy | Rationale |
-|---|---|---|
-| `importance` | `max(existing, new)` | Keep the highest importance signal |
-| `synapticTags` | `existing \| new` | Union of Bloom filters — broader context |
-| `timestamp` | Most recent | Memory is "refreshed" |
-| `recallCount` | Preserved | Reconsolidation history maintained |
-| `valence` | From newer | Most recent emotional assessment |
-
----
-
-## Integration
-
-Deduplication runs during the ingestion pipeline **after embedding but before writing**. If a merge occurs, no new record is created — the existing record is updated in-place.
-
----
-
-## Next Steps
-
-- :material-clock: [**Prospective — Future Intents**](prospective.md) — time-triggered reminders
-- :material-brain: [**Architecture**](architecture.md) — where deduplication fits in the pipeline
diff --git a/docs/docs/memory/lateral-retrieval.md b/docs/docs/memory/lateral-retrieval.md
deleted file mode 100644
index 8df3117..0000000
--- a/docs/docs/memory/lateral-retrieval.md
+++ /dev/null
@@ -1,185 +0,0 @@
-# Explorer — Lateral Retrieval
-
-The **Explorer** profile enables **lateral retrieval** — surfacing memories that are semantically distant from the query but share contextual tags. This is the computational equivalent of divergent thinking: connecting ideas across domains.
-
----
-
-## The Problem
-
-Standard similarity-based retrieval has a blind spot: it only finds memories that are **close** to the query in vector space. This creates a filter bubble — the agent keeps retrieving the same cluster of closely related memories.
-
-But some of the most valuable insights come from **cross-domain connections**:
-
-- A debugging agent stuck on a race condition might benefit from recalling a design pattern used in a completely different subsystem
-- A research agent exploring "database indexing" might gain from a memory about "B-tree file system layouts" — related by tags, but distant in embedding space
-
----
-
-## How It Works
-
-### Dual-Heap Architecture
-
-When `lateralMode=true`, the [CognitiveScorer](scoring-pipeline.md) maintains **two priority queues** instead of one:
-
-```mermaid
-flowchart LR
-    Q["Query Vector"] --> S["CognitiveScorer"]
-    S --> |"L2 distance ≤ threshold"| H1["Standard Heap\n(top-K by score)"]
-    S --> |"L2 distance > threshold\n+ tag overlap ≥ minOverlap"| H2["Lateral Heap\n(top-N by lateral score)"]
-    H1 --> M["Merged Results"]
-    H2 --> M
-```
-
-A memory is classified as a **lateral candidate** when:
-
-1. **Semantically distant**: `l2dist > lateralDistanceThreshold` (default: 1.2)
-2. **Contextually related**: `tagOverlap >= lateralMinTagOverlap` (default: 0.5)
-
-### Lateral Scoring Formula
-
-Lateral candidates use an **inverted** scoring function — higher distance means higher lateral score:
-
-$$
-\text{lateralScore} = \frac{1}{1 + \frac{1}{d}} \cdot \text{tagOverlap} \cdot \text{importance} \cdot \text{decay}
-$$
-
-Where $d$ is the L2 distance. This produces a bounded score in $(0, 1)$:
-
-| L2 Distance | Lateral Similarity |
-|:---:|:---:|
-| 0.5 | 0.33 |
-| 1.0 | 0.50 |
-| 1.5 | 0.60 |
-| 2.0 | 0.67 |
-| 5.0 | 0.83 |
-| ∞ | 1.00 |
-
-### Result Blending
-
-After the scoring loop, lateral results are appended after standard results:
-
-```
-Final results = [standard top-K] + [lateral top-N]
-```
-
-The caller can distinguish them via `CognitiveResult.retrievalMode()`:
-
-```java
-for (CognitiveResult r : results) {
-    if (r.isLateral()) {
-        System.out.println("Cross-domain insight: " + r.text());
-    }
-}
-```
-
----
-
-## Configuration
-
-```java
-// Via profile preset (recommended)
-var results = memory.recall("performance optimization", CognitiveProfile.DIVERGENT);
-
-// Via explicit options
-var options = RecallOptions.builder()
-    .profile(CognitiveProfile.DIVERGENT)
-    .lateralDistanceThreshold(1.5f)   // how far is "far enough"
-    .lateralMaxResults(5)             // max lateral candidates
-    .lateralMinTagOverlap(0.3f)       // minimum tag overlap
-    .build();
-```
-
-### Parameter Tuning
-
-| Parameter | Default | Effect |
-|:---|:---:|:---|
-| `lateralDistanceThreshold` | 1.2 | Higher → only very distant memories qualify |
-| `lateralMaxResults` | topK/3 | Caps the number of lateral results |
-| `lateralMinTagOverlap` | 0.5 | Higher → requires stronger contextual connection |
-
----
-
-## Auto-Tuning via the Lateral Evaluator
-
-The system automatically monitors whether lateral results are useful through the **LateralEvaluator**:
-
-### Feedback Loop
-
-```mermaid
-sequenceDiagram
-    participant A as Agent
-    participant S as SpectorMemory
-    participant E as LateralEvaluator
-
-    A->>S: recall("topic", DIVERGENT)
-    S-->>A: [standard + lateral results]
-    Note right of A: Agent uses results...
-    A->>S: reinforce("lateral-mem-1", positive)
-    S->>E: recordLateralReinforcement()
-    Note right of E: LUR increases
-    A->>S: suppress("lateral-mem-2", "irrelevant")
-    S->>E: recordLateralSuppression()
-    Note right of E: LSR increases
-    Note right of E: Auto-tune threshold
-```
-
-### Metrics
-
-| Metric | Formula | Meaning |
-|:---|:---|:---|
-| **LUR** (Lateral Utility Rate) | reinforced / returned | "Are lateral results useful?" |
-| **LSR** (Lateral Suppression Rate) | suppressed / returned | "Are lateral results noise?" |
-| **LHI** (Lateral Hallucination Index) | suppressed / (reinforced + suppressed) | "Of all feedback, how much is negative?" |
-
-### Auto-Tuning Rules
-
-| Condition | Action |
-|:---|:---|
-| LUR < 0.05 (5%) | **Auto-disable** lateral mode |
-| LUR < 0.10 (10%) | **Tighten** distance threshold by 10% |
-| LUR > 0.30 (30%) | Lateral mode is healthy, no change |
-
-### MCP Monitoring
-
-The `memory_status` MCP tool shows lateral metrics:
-
-```
-Lateral Retrieval:
-  Enabled:    true
-  Threshold:  1.20
-  Samples:    47
-  LUR (util): 0.34
-  LSR (supp): 0.09
-  LHI (hall): 0.20
-```
-
-The `memory_reinforce` tool reports when feedback is recorded for a lateral result:
-
-```
-👍 Reinforced 'mem-123' with valence=50 (lateral result — feedback recorded)
-```
-
----
-
-## Performance
-
-| Metric | Cost |
-|:---|:---|
-| Lateral detection | ~3 cycles per record (threshold compare + tag overlap) |
-| Lateral heap | O(N log N) where N = lateralMaxResults (typically 3-5) |
-| Auto-tuning | O(1) atomic increments, evaluated every `evaluationWindow` returns |
-
-!!! note "Zero Overhead When Disabled"
-    The lateral code path is gated by `lateralMode == true`. When `lateralMode` is false (the default for all profiles except DIVERGENT), no lateral detection or heap management occurs.
-
----
-
-## When to Use Explorer
-
-| Scenario | Recommendation |
-|:---|:---|
-| Agent is stuck on a problem | ✅ Switch to DIVERGENT |
-| Brainstorming or creative tasks | ✅ Use DIVERGENT |
-| Precision recall (debugging, audit) | ❌ Use DEBUGGING or CRITICAL |
-| Building a knowledge base | ❌ Use SYSTEMATIZER |
-| General conversation | ⚠️ BALANCED is usually sufficient |
diff --git a/docs/docs/memory/metamemory.md b/docs/docs/memory/metamemory.md
deleted file mode 100644
index 0a4776b..0000000
--- a/docs/docs/memory/metamemory.md
+++ /dev/null
@@ -1,83 +0,0 @@
----
-title: "Metamemory — Self-Reflection"
-description: "MemoryIntrospector provides self-reflective analytics — the agent's ability to reason about its own memory health."
----
-
-# 🪞 Metamemory — Self-Reflection
-
-> **Package**: `com.spectrayan.spector.memory.metamemory`
->
-> **Biological Analog**: **Metamemory** is the awareness of one's own memory processes — "I know I'm forgetting things more often" or "I'm confident I remember this correctly." It's what enables humans to say "I need to write this down" or "Let me double-check that."
-
----
-
-## MemoryIntrospector
-
-The `MemoryIntrospector` provides analytics and health metrics for the memory system:
-
-```java
-public final class MemoryIntrospector {
-
-    /**
-     * Returns per-tier memory counts.
-     */
-    public Map<MemoryType, Integer> countsByTier() { ... }
-
-    /**
-     * Returns the most common synaptic tags across all memories.
-     * Useful for understanding what topics dominate the agent's memory.
-     */
-    public Map<String, Integer> tagDistribution() { ... }
-
-    /**
-     * Returns importance distribution statistics.
-     */
-    public DoubleSummaryStatistics importanceStats() { ... }
-
-    /**
-     * Returns memories with the highest recall counts
-     * (most frequently accessed — potential habituation candidates).
-     */
-    public List<CognitiveResult> mostRecalled(int topK) { ... }
-
-    /**
-     * Returns the oldest active memories (potential consolidation candidates).
-     */
-    public List<CognitiveResult> oldestActive(int topK) { ... }
-}
-```
-
----
-
-## Use Cases
-
-### Memory Health Dashboard
-
-```java
-var introspector = memory.introspect();
-
-// Tier distribution — is memory balanced?
-introspector.countsByTier().forEach((tier, count) ->
-    System.out.printf("  %s: %d memories%n", tier, count));
-
-// Tag distribution — what topics dominate?
-introspector.tagDistribution().entrySet().stream()
-    .sorted(Map.Entry.<String, Integer>comparingByValue().reversed())
-    .limit(10)
-    .forEach(e -> System.out.printf("  %s: %d occurrences%n", e.getKey(), e.getValue()));
-```
-
-### Adaptive Agent Behavior
-
-An agent can use metamemory to self-optimize:
-
-- **High episodic count, low semantic**: "I should consolidate — trigger a reflect cycle"
-- **High recall count on one memory**: "I'm over-relying on this — diversify"
-- **Low importance average**: "Most memories are routine — increase surprise sensitivity"
-
----
-
-## Next Steps
-
-- :material-sync: [**Sync — Persistence & Replication**](sync.md) — WAL and CRDT merge
-- :material-brain: [**Architecture**](architecture.md) — system overview
diff --git a/docs/docs/memory/panama-design.md b/docs/docs/memory/panama-design.md
deleted file mode 100644
index 14313b8..0000000
--- a/docs/docs/memory/panama-design.md
+++ /dev/null
@@ -1,304 +0,0 @@
----
-title: "Off-Heap Panama Design"
-description: "Zero-GC architecture using Project Panama MemorySegment, Arena management, mmap partitions, and versioned header layouts (V1/V2/V3)."
----
-
-# 💾 Off-Heap Panama Design
-
-Spector Memory achieves **zero garbage collection pressure** by storing all vector data and cognitive headers off-heap using Java Project Panama's Foreign Function & Memory API. No memory record ever touches the JVM heap.
-
----
-
-## Why Off-Heap?
-
-In a standard JVM application, objects live on the heap and are managed by the garbage collector. For AI memory workloads, this creates problems:
-
-| On-Heap (Traditional) | Off-Heap (Panama) |
-|---|---|
-| GC pauses (10-100ms for large heaps) | **Zero GC pauses** — data is invisible to GC |
-| Object overhead (16-24 bytes per object header) | **Zero overhead** — raw bytes, no object headers |
-| Memory fragmentation over time | **Compact** — contiguous byte arrays |
-| Heap size limits JVM config | **System memory** — limited only by OS |
-| Serialization required for persistence | **Direct mmap** — bytes are already on disk |
-
----
-
-## Panama Architecture
-
-### MemorySegment — The Core Abstraction
-
-Every memory record is stored in a `MemorySegment` — a contiguous off-heap byte buffer managed by an `Arena`:
-
-```java
-// Allocate 8 MB of off-heap memory, 32-byte aligned
-Arena arena = Arena.ofShared();
-MemorySegment segment = arena.allocate(8 * 1024 * 1024, 32);
-
-// Write a float directly at a byte offset — no Java objects involved
-segment.set(ValueLayout.JAVA_FLOAT, offset + 20, 0.85f);
-
-// Read it back — zero deserialization
-float importance = segment.get(ValueLayout.JAVA_FLOAT, offset + 20);
-```
-
-**Key properties**:
-
-- `Arena.ofShared()` — thread-safe for concurrent reads (Virtual Threads)
-- 32-byte alignment ensures SIMD-friendly access patterns
-- No Java objects are created — the GC never sees this memory
-
-### Arena Lifecycle
-
-```mermaid
-graph LR
-    A["Arena.ofShared()"] --> B["allocate(bytes, alignment)"]
-    B --> C["MemorySegment<br/>(off-heap)"]
-    C -->|read/write| D["SIMD Scorer<br/>Virtual Threads"]
-    C -->|"arena.close()"| E["Memory Released<br/>to OS"]
-    
-    style A fill:#3498db,color:white
-    style C fill:#2ecc71,color:white
-    style E fill:#e74c3c,color:white
-```
-
-!!! warning "Lifetime Management"
-    Unlike heap objects, off-heap memory is **not garbage collected**. You must explicitly close the `Arena` when done. `SpectorMemory` implements `AutoCloseable` and closes all arenas in its `close()` method. Always use try-with-resources.
-
----
-
-## Three Storage Modes
-
-### 1. Arena-Allocated (Working, Procedural)
-
-Volatile, in-memory segments for transient data:
-
-```java
-// WorkingMemoryStore — circular buffer
-Arena arena = Arena.ofShared();
-long totalBytes = (long) capacity * stride;
-MemorySegment segment = arena.allocate(totalBytes, HEADER_BYTES);
-```
-
-**Characteristics**:
-
-- Fast allocation (~1µs)
-- Lost on JVM shutdown
-- No file I/O overhead
-- Fixed capacity
-
-### 2. mmap-Backed (Episodic)
-
-Persistent, memory-mapped files for durable storage:
-
-```java
-// EpisodicPartition — mmap via FileChannel.map()
-FileChannel channel = FileChannel.open(path, READ, WRITE);
-MemorySegment segment = channel.map(MapMode.READ_WRITE, 0, totalBytes, arena);
-```
-
-**Characteristics**:
-
-- Persists across JVM restarts
-- OS handles paging to/from disk
-- Lazy loading — only mapped pages are in physical RAM
-- Atomic `force()` for durability
-
-### 3. Header-Only Slab (Semantic)
-
-Compact metadata-only storage (no vectors):
-
-```java
-// SemanticMemoryStore — header slab
-// Uses configured HeaderLayout (V1=32B, V2=48B, V3=64B)
-long slabBytes = (long) capacity * headerLayout.headerBytes();
-MemorySegment headerSlab = arena.allocate(slabBytes, headerLayout.headerBytes());
-```
-
-**Characteristics**:
-
-- Minimal memory footprint (32-64B per record vs. ~800B for full records)
-- Fast metadata scans (tag match, importance, valence, arousal)
-- No vector data — re-embed at query time if needed
-
----
-
-## Binary Record Format
-
-### Versioned Header Layouts
-
-The cognitive record format uses a **versioned header** via the `HeaderLayout` sealed interface. The header version determines the record stride and available fields. See [Synapse — Tags & Scoring](synapse.md) for the full byte-level specification.
-
-```mermaid
-graph LR
-    subgraph "V1 — 32B"
-        V1H["Header (32B)"] --> V1V["INT8 Vector (NB)"]
-    end
-    subgraph "V2 — 48B"
-        V2H["Header (48B)"] --> V2V["INT8 Vector (NB)"]
-    end
-    subgraph "V3 — 64B ⭐ Default"
-        V3H["Header (64B)"] --> V3V["INT8 Vector (NB)"]
-    end
-
-    style V3H fill:#27ae60,color:white
-    style V3V fill:#2ecc71,color:white
-```
-
-### V1 Layout (32 bytes) — Legacy
-
-```
- 0                   1                   2                   3
- 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-|                                                               |
-+                      timestamp (8B)                           +  ← Offset 0
-|                                                               |
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-|                                                               |
-+                    synapticTags (8B)                           +  ← Offset 8
-|                                                               |
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-|                    exactNorm (4B)                              |  ← Offset 16
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-|                    importance (4B)                             |  ← Offset 20
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-|                    recallCount (4B)                            |  ← Offset 24
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-|       centroidId (2B)         | valence (1B)  |   flags (1B)  |  ← Offset 28
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-|                                                               |
-+              Quantized Vector — INT8[N]                       +  ← Offset 32
-|              (dequantize: float = byte × scale + min)         |
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-                  stride = 32 + N bytes per record
-```
-
-### V2 Layout (48 bytes) — Extended
-
-Adds arousal and storage strength fields:
-
-```
-                    [32B V1 core as above]
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-| arousal (1B)  |          padding (3B)                         |  ← Offset 32
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-|                    storageStrength (4B)                        |  ← Offset 36
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-|                                                               |
-+                      reserved (8B)                            +  ← Offset 40
-|                                                               |
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-|                Quantized Vector — INT8[N]                      |  ← Offset 48
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-                  stride = 48 + N bytes per record
-```
-
-### V3 Layout (64 bytes) — Full Cache Line ⭐ Default
-
-Extends V2 with a 16-byte future buffer, aligned to a full CPU cache line:
-
-```
-                    [48B V2 core as above]
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-|                                                               |
-+                  reserved_2 (16B)                             +  ← Offset 48
-|                  (future expansion buffer)                    |
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-|                Quantized Vector — INT8[N]                      |  ← Offset 64
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-                  stride = 64 + N bytes per record
-```
-
-### Memory Cost Comparison
-
-| Version | Header | Stride (768-dim) | 1M Records | Alignment |
-|:---|:---:|:---:|:---:|:---|
-| V1 | 32B | 800B | ~763 MB | 1× AVX2 register |
-| V2 | 48B | 816B | ~778 MB | 1.5× AVX2 |
-| V3 ⭐ | 64B | 832B | ~793 MB | 1× cache line (64B) |
-
-### Field Access Patterns
-
-The header layout is designed for **sequential access** in the scoring hot-loop. Fields are ordered by access frequency:
-
-```
-Phase 1: flags        (offset 31, 1B)  — First check, highest skip rate
-Phase 2: synapticTags (offset 8,  8B)  — Second check, eliminates 99%
-Phase 3: valence      (offset 30, 1B)  — Third check (profile-dependent)
-Phase 4: importance   (offset 20, 4B)  — Fourth check
-Phase 4: timestamp    (offset 0,  8B)  — Read with importance
-Phase 4: recallCount  (offset 24, 4B)  — Reconsolidation adjustment
-Phase 4: arousal      (offset 32, 1B)  — V2+: arousal-modulated decay
-Phase 5: vector       (offset H,  NB)  — Only if all filters pass (H = header bytes)
-```
-
-!!! tip "Cache Line Optimization"
-    V3's 64-byte header occupies exactly **one CPU cache line**. During sequential scans, each header read hits exactly one cache line — no split-line loads, no false sharing. The CPU prefetcher can pre-fetch the next record's header while the current one is being scored. V1's 32-byte header fits in half a cache line, meaning the vector data starts mid-cache-line which can cause split reads.
-
----
-
-## Episodic Partition File Format
-
-Each episodic partition file has a 64-byte metadata header:
-
-```
-Offset   Size   Field            Description
-──────   ────   ─────            ───────────
-  0       4B    magic            0x45504943 ("EPIC" in ASCII)
-  4       4B    version          Format version (1)
-  8       4B    count            Number of live records
- 12       4B    tombstoneCount   Number of tombstoned records
- 16       4B    capacity         Maximum records in partition
- 20       4B    state            PartitionState ordinal
- 24       4B    stride           Record stride in bytes
- 28      36B    reserved         Future use (alignment padding)
-```
-
-**File naming**: `episodic-{yyyyMMdd}.mem` (e.g., `episodic-20260527.mem`)
-
-**Partition capacity**: Default 10,000 records per partition. At 800 bytes/record (768-dim INT8), each partition file is ~8 MB.
-
----
-
-## Thread Safety Model
-
-| Component | Thread Safety | Mechanism |
-|---|---|---|
-| `Arena.ofShared()` | ✅ Concurrent reads | Built-in Panama support |
-| `MemorySegment` reads | ✅ Lock-free | Direct memory access |
-| `MemorySegment` writes | ⚠️ Single writer | `synchronized` on partition append |
-| `ConcurrentHashMap` (index) | ✅ Lock-free reads | CAS-based updates |
-| Partition metadata | ⚠️ Single writer | Metadata header writes are synchronized |
-
-**Recall**: Multiple Virtual Threads read different partitions concurrently — zero contention because each partition's `MemorySegment` is disjoint.
-
-**Ingestion**: Writes are serialized per partition (one writer at a time) but different partitions can accept writes concurrently.
-
----
-
-## Zero-Copy Data Path
-
-```mermaid
-graph LR
-    A["💾 Disk"] -->|mmap| B["MemorySegment"]
-    B -->|"direct read"| C["SIMD Registers"]
-    C --> D["✅ Score"]
-
-    style A fill:#3498db,color:white
-    style B fill:#2ecc71,color:white
-    style D fill:#00b894,color:white
-```
-
-> **No Java objects created. No serialization. No deserialization. No GC pressure.**
-
-The entire data path from persistent storage to CPU computation operates on **raw bytes**. The JVM heap is used only for the top-K result set (`List<CognitiveResult>`) — typically 5-20 small Java records.
-
----
-
-## Next Steps
-
-- :material-speedometer: [**Performance**](performance.md) — benchmark results
-- :material-brain: [**Architecture**](architecture.md) — system design
-- :material-lightning-bolt: [**6-Phase Scoring Pipeline**](scoring-pipeline.md) — the SIMD hot-loop
-- :material-tag: [**Synapse — Tags & Scoring**](synapse.md) — versioned header byte maps, arousal decay, Bloom filter
-- :material-flask: [**Labs — Research Roadmap**](../labs/roadmap.md) — Dynamic Quantization (SQ4), Two-Factor Memory
diff --git a/docs/docs/memory/performance.md b/docs/docs/memory/performance.md
deleted file mode 100644
index 0f4e379..0000000
--- a/docs/docs/memory/performance.md
+++ /dev/null
@@ -1,159 +0,0 @@
----
-title: "Performance & SIMD"
-description: "Benchmark results, SIMD kernel throughput, and architecture decisions that enable microsecond-scale latency in Spector Memory."
----
-
-# ⚡ Performance & SIMD
-
-Spector Memory is engineered for microsecond-scale latency. This page documents the benchmark results and the key performance techniques that make it possible.
-
----
-
-## Benchmark Summary
-
-Measured on **Intel Core Ultra 9 285K**, Java 25, AVX2 256-bit (8 float lanes), ZGC:
-
-| Benchmark | Result | Notes |
-|---|---|---|
-| **SIMD L2 Distance (128-dim)** | 0.8 µs/vector | 1.2M vectors/sec |
-| **SIMD L2 Distance (384-dim)** | 1.5 µs/vector | 2.6M vectors/sec |
-| **SIMD L2 Distance (768-dim)** | 2.2 µs/vector | 1.4M vectors/sec |
-| **SIMD L2 Distance (1024-dim)** | 3.0 µs/vector | 1.0M vectors/sec |
-| **Reverse Index Lookup** | 180 ns/lookup | O(1) packed-key ConcurrentHashMap |
-| **CognitiveScorer (10K × 128-dim)** | 2.9 ms total | Full 6-phase pipeline |
-| **Batch Habituation (1K IDs)** | 101 µs total | 100 ns per penalty computation |
-| **TierRouter.totalCount()** | 17 ms / 100K calls | 170 ns per call |
-| **Full Pipeline (1K ingest + 100 recall)** | < 50 ms/query | End-to-end latency |
-| **Real Embedding (qwen3-embedding 4096-dim)** | 31 ms/embed | Via Ollama (network bound) |
-
----
-
-## Key Techniques
-
-### O(1) Reverse Index
-
-Memory IDs are resolved in constant time using a packed-key `ConcurrentHashMap<Long, String>`:
-
-```java
-// Pack (type, offset) into a single long — zero String concatenation
-private static long reverseKey(MemoryType type, long offset) {
-    return ((long) type.ordinal() << 48) | (offset & 0x0000_FFFF_FFFF_FFFFL);
-}
-```
-
-This yields **180 ns** lookups at 50K entries.
-
----
-
-### SIMD Euclidean Distance
-
-Quantized INT8 Euclidean distance uses the Java Vector API for hardware acceleration:
-
-```java
-// Vectorized dequantization + L2 in a single SIMD pass
-FloatVector vQuery = FloatVector.fromArray(SPECIES, queryVector, i);
-ByteVector vQuantized = ByteVector.fromMemorySegment(SPECIES_BYTE, segment, offset + i, NATIVE);
-FloatVector vFloat = vQuantized.castShape(SPECIES, 0);  // INT8 → float32
-FloatVector vDequant = vFloat.mul(vScale).add(vMin);    // Affine dequantization
-FloatVector vDiff = vQuery.sub(vDequant);
-vSum = vDiff.fma(vDiff, vSum);                          // Fused multiply-add
-```
-
-This achieves **2.2 µs/vector** at 768 dimensions (1.4M vectors/sec).
-
----
-
-### Batch Habituation
-
-The habituation penalty module computes all penalties in a single batch call with amortized map access, processing 1K penalties in **101 µs** total.
-
----
-
-### Inline Header Capture
-
-`ScoredRecord` captures the `CognitiveHeader` inline during scoring, eliminating N×8 off-heap re-reads per recall query.
-
----
-
-### Direct TierRouter Access
-
-`totalCount()` uses direct field access to typed store references rather than iteration, completing 100K calls in **17 ms** (170 ns/call).
-
----
-
-## Parallel Tier Scanning
-
-Each memory tier is scanned on a dedicated **Virtual Thread** via `ConcurrentTasks.forkJoinAll()`:
-
-```mermaid
-gantt
-    title Parallel Recall: 5 concurrent scans
-    dateFormat X
-    axisFormat %L ms
-    
-    section Working (100 records)
-    Scan     :a1, 0, 1
-    section Episodic P1 (5K records)
-    Scan     :a2, 0, 3
-    section Episodic P2 (3K records)
-    Scan     :a3, 0, 2
-    section Semantic (200 headers)
-    Scan     :a4, 0, 1
-    section Procedural (50 records)
-    Scan     :a5, 0, 1
-    section Merge + Rank
-    Top-K    :a6, 3, 4
-```
-
-**Key insight**: Episodic partitions use **disjoint memory segments** — each partition's mmap is a separate `MemorySegment`. This guarantees zero contention between virtual threads, enabling perfect parallel scaling.
-
-**Fallback**: If parallel scanning fails (e.g., thread pool exhaustion), the pipeline falls back to sequential scanning with identical results.
-
----
-
-## Memory Footprint
-
-| Component | Formula | 10K memories (768-dim) |
-|---|---|---|
-| Episodic partition | 64B header + N × (32B + vecBytes) | 64B + 10K × 800B = **7.8 MB** |
-| Working memory | capacity × (32B + vecBytes) | 100 × 800B = **78 KB** |
-| Semantic headers | capacity × 32B | 5K × 32B = **156 KB** |
-| Procedural store | capacity × (32B + vecBytes) | 500 × 800B = **390 KB** |
-| Forward index | ~120B per entry | 10K × 120B = **1.2 MB** |
-| Reverse index | ~60B per entry | 10K × 60B = **600 KB** |
-| **Total** | | **~10.2 MB** |
-
-!!! tip "vs. Python Memory Layers"
-    A Python memory system stores each memory as a Python object (~500-800 bytes overhead) plus the vector in NumPy (~3KB for 768-dim float32). Spector stores the same memory in **800 bytes** (32B header + 768B INT8 vector) — a 5-10× reduction.
-
----
-
-## Test Suite
-
-```
-spector-core:   276 tests ✅   (includes 15 SIMD kernel verification tests)
-spector-memory: 167 tests ✅   (includes performance benchmarks + index tests)
-                + 10 Ollama real embedding E2E tests (gated by OLLAMA_LIVE=true)
-Total: 443 tests, 0 failures
-```
-
-### Running Benchmarks
-
-```bash
-# Run all memory tests (includes benchmark assertions)
-mvn test -pl spector-memory
-
-# Run only performance benchmarks
-mvn test -pl spector-memory -Dtest=PerformanceBenchmarkTest
-
-# Run Ollama real embedding E2E tests
-OLLAMA_LIVE=true mvn test -pl spector-memory -Dtest=OllamaRealEmbeddingTest
-```
-
----
-
-## Next Steps
-
-- :material-memory: [**Off-Heap Panama Design**](panama-design.md) — zero-GC architecture
-- :material-lightning-bolt: [**6-Phase Scoring Pipeline**](scoring-pipeline.md) — the SIMD hot-loop
-- :material-brain: [**Architecture**](architecture.md) — system-level design
diff --git a/docs/docs/memory/prospective.md b/docs/docs/memory/prospective.md
deleted file mode 100644
index 6ddd8b0..0000000
--- a/docs/docs/memory/prospective.md
+++ /dev/null
@@ -1,98 +0,0 @@
----
-title: "Prospective — Future Intents"
-description: "ProspectiveScheduler enables time-triggered memory reminders — the agent's ability to remember to do something in the future."
----
-
-# 🔮 Prospective — Future Intents
-
-> **Package**: `com.spectrayan.spector.memory.prospective`
->
-> **Biological Analog**: **Prospective memory** is the ability to remember to perform an intended action in the future — "Remember to call the doctor at 3pm." Unlike retrospective memory (recalling the past), prospective memory is future-oriented and time-triggered.
-
----
-
-## The Concept
-
-An AI agent needs to remember not just *what happened*, but *what to do next*. Prospective memory enables:
-
-- "Remind me to check the build in 10 minutes"
-- "Flag this issue for follow-up tomorrow"
-- "Alert when deployment completes"
-
----
-
-## ProspectiveScheduler
-
-```java
-public final class ProspectiveScheduler {
-
-    /**
-     * Schedules a prospective reminder.
-     *
-     * @param text     reminder text
-     * @param triggerAt when to surface the reminder
-     * @param tags     synaptic tags for contextual association
-     * @return the scheduled Reminder
-     */
-    public Reminder schedule(String text, Instant triggerAt, String... tags) {
-        long synapticTags = SynapticTagEncoder.encode(tags);
-        String id = "prospective-" + UUID.randomUUID();
-        Reminder reminder = new Reminder(id, text, triggerAt, synapticTags, tags);
-        reminders.add(reminder);
-        return reminder;
-    }
-
-    /**
-     * Collects all reminders whose trigger time has passed.
-     * Called at Step 2 of the RecallPipeline.
-     */
-    public List<Reminder> collectDue() {
-        Instant now = Instant.now();
-        List<Reminder> due = new ArrayList<>();
-        reminders.removeIf(r -> {
-            if (r.triggerAt().isBefore(now)) {
-                due.add(r);
-                return true;
-            }
-            return false;
-        });
-        return due;
-    }
-}
-```
-
-## Reminder Record
-
-```java
-public record Reminder(
-    String id,
-    String text,
-    Instant triggerAt,
-    long synapticTags,
-    String[] tags
-) {}
-```
-
----
-
-## Integration with Recall
-
-Due reminders are injected at **Step 2** of the `RecallPipeline` with maximum score (10.0), ensuring they always appear at the top of results:
-
-```java
-// In RecallPipeline.recall()
-List<Reminder> dueReminders = prospectiveScheduler.collectDue();
-for (Reminder r : dueReminders) {
-    allResults.add(new CognitiveResult(
-        r.id(), r.text(), 10.0f, 10.0f, 0f,
-        (short) 0, (byte) 0, MemoryType.WORKING, MemorySource.PROCEDURAL,
-        new String[]{"prospective"}, 1.0f, 1.0f));
-}
-```
-
----
-
-## Next Steps
-
-- :material-mirror: [**Metamemory — Self-Reflection**](metamemory.md) — memory health analytics
-- :material-lightning-bolt: [**6-Phase Scoring Pipeline**](scoring-pipeline.md) — the full recall flow
diff --git a/docs/docs/memory/scoring-pipeline.md b/docs/docs/memory/scoring-pipeline.md
deleted file mode 100644
index b2c1512..0000000
--- a/docs/docs/memory/scoring-pipeline.md
+++ /dev/null
@@ -1,314 +0,0 @@
----
-title: The 6-Phase Scoring Pipeline
-description: "A deep dive into CognitiveScorer — the SIMD hot-loop that fuses six filtering and scoring phases into a single off-heap scan."
----
-
-# The 6-Phase Scoring Pipeline
-
-The `CognitiveScorer` is the performance-critical inner loop of Spector Memory. It scans off-heap `MemorySegment` data using **six sequential phases**, each eliminating candidates before the expensive SIMD vector math. This design is inspired by the brain's **sensory gating** — the auditory cortex filters out background noise before the prefrontal cortex evaluates it.
-
----
-
-## Why Fused Scoring?
-
-### The Truncation Trap
-
-In a standard vector database, you:
-
-1. Retrieve the top-K nearest vectors by L2 distance
-2. **Then** apply business logic (importance, time, tags) in Java
-
-This **fails catastrophically** for AI memory:
-
-!!! danger "The Problem"
-    If an AI agent asks *"What is the user's core preference?"*, the most important memory might be 6 months old and slightly less semantically similar than a useless conversation from 5 minutes ago. If you pull the top-100 nearest vectors and *then* sort by importance, the vital 6-month-old memory was already **dropped at step 1**.
-
-### The Fix: Fuse Everything
-
-Spector fuses temporal decay and importance directly into the scoring loop:
-
-$$\text{Similarity} = \frac{1}{1 + \text{L2\_Distance}(q, x)}$$
-
-$$\text{FinalScore} = \alpha \cdot \text{Similarity} + \beta \cdot \text{Importance} \cdot \text{Decay}(\text{AdjustedAge})$$
-
-Where $\alpha$ (default: 0.6) and $\beta$ (default: 0.4) are user-configurable scoring weights.
-
----
-
-## The Six Phases
-
-```java
-for (int i = 0; i < recordCount; i++) {
-    long offset = baseOffset + (long) i * stride;
-
-    // ── Phase 1: Tombstone Check (~1 cycle) ──
-    byte flags = segment.get(LAYOUT_FLAGS, offset + OFFSET_FLAGS);
-    if (isTombstoned(flags)) continue;
-
-    // ── Phase 2: Synaptic Tag Gating (~1 cycle) ──
-    if (queryTagMask != 0) {
-        long recordTags = segment.get(LAYOUT_SYNAPTIC_TAGS, offset + OFFSET_SYNAPTIC_TAGS);
-        if ((recordTags & queryTagMask) != queryTagMask) continue;
-    }
-
-    // ── Phase 3: Valence Filter (~2 cycles) ──
-    byte valence = segment.get(LAYOUT_VALENCE, offset + OFFSET_VALENCE);
-    if (valence < minValence || valence > maxValence) continue;
-
-    // ── Phase 4: Temporal/Importance Pre-screen (~5 cycles) ──
-    float importance = segment.get(LAYOUT_IMPORTANCE, offset + OFFSET_IMPORTANCE);
-    if (importance < minImportance) continue;
-    long timestamp = segment.get(LAYOUT_TIMESTAMP, offset + OFFSET_TIMESTAMP);
-    short recallCount = segment.get(LAYOUT_RECALL_COUNT, offset + OFFSET_RECALL_COUNT);
-    int adjustedBucket = DecayStrategy.adjustForReconsolidation(rawBucket, recallCount);
-    if (adjustedBucket >= MAX_BUCKET && importance < 1.0f && !isPinned(flags)) continue;
-
-    // ── Phase 5: SIMD L2 Distance (~200 cycles) ──
-    float l2dist = SimilarityFunction.EUCLIDEAN.computeQuantizedFromSegment(
-        queryVector, segment, layout.vectorOffset(offset),
-        effectiveMins, effectiveScales, quantizedVecBytes);
-    float similarity = 1.0f / (1.0f + l2dist);
-
-    // ── Phase 6: Fused Cognitive Score (~7 cycles) ──
-    float decay = DecayStrategy.decay(adjustedBucket);
-    float finalScore = alpha * similarity + beta * importance * decay;
-    
-    heap.insertWithOverflow(offset, finalScore);
-}
-```
-
----
-
-## Phase-by-Phase Deep Dive
-
-### Phase 1: Tombstone Check
-
-**Cost**: ~1 CPU cycle (single byte read + bit test)
-
-```java
-byte flags = segment.get(LAYOUT_FLAGS, offset + OFFSET_FLAGS);
-if ((flags & 0x01) != 0) continue; // Bit 0 = tombstone
-```
-
-Tombstoned memories are skipped without reading any other fields. When the tombstone ratio in an episodic partition exceeds 30%, the `TombstoneCompactor` triggers a partition rebuild.
-
----
-
-### Phase 2: Synaptic Tag Gating
-
-**Cost**: ~1 CPU cycle (single `long` read + bitwise AND)
-
-```java
-long recordTags = segment.get(LAYOUT_SYNAPTIC_TAGS, offset + OFFSET_SYNAPTIC_TAGS);
-if ((recordTags & queryTagMask) != queryTagMask) continue;
-```
-
-!!! info "Bloom Filter Containment"
-    The check `(record & query) != query` is a **containment check**, not an overlap check. It verifies that **all** query tag bits are present in the record's Bloom filter. This is the correct Bloom filter match — it can have false positives but never false negatives.
-
-**Selectivity**: If an agent has 1,000,000 memories and only 10,000 match the query tags, this phase eliminates **990,000 records** in ~990µs — saving 990,000 × 200 cycles of SIMD math.
-
-The synaptic tag Bloom filter uses MurmurHash3-inspired double hashing with k=3 hash functions in a 64-bit field. False positive rates:
-
-| Tags per Record | FPR | Assessment |
-|---|---|---|
-| 5 | 0.03% | Excellent |
-| 10 | 0.2% | Excellent |
-| 20 | 2.3% | Good |
-| 50 | 12% | Acceptable — vector distance rejects false matches |
-
----
-
-### Phase 3: Valence Filter
-
-**Cost**: ~2 CPU cycles (byte read + 2 comparisons)
-
-```java
-byte valence = segment.get(LAYOUT_VALENCE, offset + OFFSET_VALENCE);
-if (valence < minValence || valence > maxValence) continue;
-```
-
-Valence represents **emotional coloring** on a scale of -128 to +127:
-
-- **Negative**: Error memories, failures, warnings
-- **Zero**: Neutral factual memories
-- **Positive**: Successes, preferred outcomes
-
-!!! example "Use Case"
-    An agent debugging an error can filter to `maxValence = -10` to recall only negative-outcome memories — "What went wrong last time?"
-
----
-
-### Phase 4: Importance/Decay Pre-screen
-
-**Cost**: ~5 CPU cycles (float read + timestamp read + bucket computation)
-
-```java
-float importance = segment.get(LAYOUT_IMPORTANCE, offset + OFFSET_IMPORTANCE);
-if (importance < minImportance) continue;
-
-int rawBucket = DecayStrategy.ageToBucket(timestamp, nowMs);
-int adjustedBucket = DecayStrategy.adjustForReconsolidation(rawBucket, recallCount);
-
-if (adjustedBucket >= MAX_BUCKET && importance < 1.0f && !isPinned(flags)) continue;
-```
-
-**Reconsolidation**: Every 3 recalls shifts the decay bucket back by 1, simulating how frequently-recalled memories become more durable (Long-Term Potentiation). A memory recalled 12 times is 4 buckets "younger" than its actual age.
-
-**Decay Buckets** (precomputed — no `Math.exp()` required):
-
-| Bucket | Age Range | Decay Multiplier |
-|---|---|---|
-| 0 | 0–1 hours | 1.00 |
-| 1 | 1–6 hours | 0.95 |
-| 2 | 6–24 hours | 0.85 |
-| 3 | 1–3 days | 0.70 |
-| 4 | 3–7 days | 0.50 |
-| 5 | 1–2 weeks | 0.30 |
-| 6 | 2–4 weeks | 0.15 |
-| 7 | 1–3 months | 0.05 |
-| 8+ | 3+ months | 0.01 |
-
-!!! warning "The `exp()` Bottleneck"
-    Naive exponential decay `Math.exp(-λ·age)` costs 50-100ns per call and cannot be SIMD-vectorized. Spector uses precomputed decay buckets — a single array lookup per record (~1ns). At 1M memories, this saves **50-100ms** of scalar overhead.
-
----
-
-### Phase 5: SIMD L2 Distance
-
-**Cost**: ~200 CPU cycles (the dominant cost)
-
-```java
-float l2dist = SimilarityFunction.EUCLIDEAN.computeQuantizedFromSegment(
-    queryVector, segment, layout.vectorOffset(offset),
-    effectiveMins, effectiveScales, quantizedVecBytes);
-float similarity = 1.0f / (1.0f + l2dist);
-```
-
-This is the expensive operation that phases 1-4 are designed to gate. It:
-
-1. Reads INT8 quantized vector bytes directly from the off-heap `MemorySegment`
-2. Dequantizes via calibration: `float_val = byte_val * scale + min`
-3. Computes Euclidean distance using the Java Vector API (AVX2/AVX-512)
-4. Converts distance to similarity: `1 / (1 + L2)`
-
-**Throughput**: ~2.2µs per 768-dim vector (1.4M vectors/sec on AVX2).
-
----
-
-### Phase 6: Fused Cognitive Score
-
-**Cost**: ~7 CPU cycles (2 multiplies + 1 add + heap insert)
-
-```java
-float decay = DecayStrategy.decay(adjustedBucket);
-float finalScore = alpha * similarity + beta * importance * decay;
-heap.insertWithOverflow(offset, finalScore);
-```
-
-The final score fuses three signals:
-
-- **Semantic similarity** (α-weighted): How relevant is this memory to the query?
-- **Importance** (β-weighted): How important was this memory at ingestion?
-- **Temporal decay** (β-weighted): How recent is this memory?
-
-Results are tracked in a **min-heap** of size K — only the top-K scored records survive.
-
----
-
-## The Math: Gating Efficiency
-
-```mermaid
-graph TD
-    A["1,000,000 episodic memories"] --> B["Phase 1: Tombstone check<br/>−50,000 → 950,000 remain<br/><i>~1 cycle each</i>"]
-    B --> C["Phase 2: Synaptic tag gating<br/>−940,000 → 10,000 remain<br/><i>~1 cycle each</i>"]
-    C --> D["Phase 3: Valence filter<br/>−2,000 → 8,000 remain<br/><i>~2 cycles each</i>"]
-    D --> E["Phase 4: Importance pre-screen<br/>−3,000 → 5,000 remain<br/><i>~5 cycles each</i>"]
-    E --> F["Phase 5: SIMD L2 distance<br/>5,000 × 200 cycles<br/><i>expensive</i>"]
-    F --> G["Phase 6: Fused score<br/>5,000 × 7 cycles"]
-    G --> H["✅ ~0.13ms total"]
-
-    style A fill:#e74c3c,color:white
-    style C fill:#f39c12,color:white
-    style H fill:#00b894,color:white
-```
-
-> **Without gating**: 1,000,000 × 200 cycles = ~200ms → **100× improvement** from early elimination.
-
----
-
-## Parallel Tier Scanning
-
-The `RecallPipeline` scans all tiers in parallel using `ConcurrentTasks.forkJoinAll()`:
-
-```mermaid
-gantt
-    title Parallel Recall Scan (Virtual Threads)
-    dateFormat X
-    axisFormat %L ms
-    section Working
-    Scan 100 records     :a1, 0, 1
-    section Episodic P1
-    Scan 5000 records    :a2, 0, 3
-    section Episodic P2
-    Scan 3000 records    :a3, 0, 2
-    section Semantic
-    Header scan 200      :a4, 0, 1
-    section Procedural
-    Scan 50 records      :a5, 0, 1
-    section Merge
-    Sort + top-K         :a6, 3, 4
-```
-
-Each partition scan runs on a **dedicated Virtual Thread** — disjoint memory segments guarantee zero contention. The merge phase sorts all tier results and returns the global top-K.
-
----
-
-## Graph Augmentation (Post-Scorer)
-
-After the 6-phase scorer produces a **seed set** (top-K by fused cognitive score), three graph layers expand the result set by discovering memories that the scorer alone couldn't find:
-
-```mermaid
-graph LR
-    S["Seed Set<br/>(6-Phase Scorer Top-K)"] --> H["Step 5c: Hebbian<br/>Spreading Activation<br/>(depth=2, 0.3× attenuation)"]
-    H --> T["Step 5d: Temporal<br/>Chain Extension<br/>(maxHops=3, 0.8×/0.7×)"]
-    T --> E["Step 5e: Entity<br/>Graph Traversal<br/>(2-hop BFS, 0.25×/hop)"]
-    E --> M["Merge & Dedup<br/>→ Re-sort<br/>→ Final Top-K"]
-
-    style S fill:#4a90d9,color:white
-    style H fill:#e74c3c,color:white
-    style T fill:#f39c12,color:white
-    style E fill:#9b59b6,color:white
-    style M fill:#00b894,color:white
-```
-
-### Step 5c: Hebbian Spreading Activation
-
-For each seed result, `HebbianGraph.activateNeighbors(memoryIdx, depth=2)` traverses the off-heap adjacency list (164B/node, MAX_DEGREE=20). Activated neighbor memories are added to the result set with their score attenuated by **0.3×**.
-
-**Example:** Seed memory "database error" has a strong Hebbian edge (weight: 0.83) to "connection pool settings" → "connection pool settings" is added even though it wasn't in the vector similarity top-K.
-
-### Step 5d: Temporal Chain Extension
-
-For each seed result, `TemporalChain.followForward(idx, 3)` and `followBackward(idx, 3)` follow session-local linked list pointers. Forward-linked memories get **0.8×** score, backward-linked get **0.7×**.
-
-**Example:** Seed memory "deploy failed" → follow forward → "rollback initiated" → "post-mortem notes" — both added to results.
-
-### Step 5e: Entity Graph Traversal
-
-Entities are extracted from the query text, then looked up in the `EntityGraph`. For each matched entity, a 2-hop BFS with typed edge filtering discovers related entities. Their linked memories are added with **0.25× attenuation per hop**.
-
-**Example:** Query mentions "Alice" → Entity "Alice" → MANAGES → "Project Alpha" → memories mentioning "Project Alpha" are added.
-
-!!! tip "Graceful Degradation"
-    Each graph step is **additive and independently optional**. If a graph component is null (not configured), empty, or throws a `RuntimeException`, the step is a no-op. The system degrades gracefully to vector-only recall. Zero risk of regression.
-
----
-
-## Next Steps
-
-- :material-share-variant: [**3-Layer Cognitive Graph**](hebbian.md) — deep dive into Hebbian, Entity, and Temporal graphs
-- :material-brain: [**Cortex — Tier Stores**](cortex.md) — the 4-tier memory architecture
-- :material-flash: [**Synapse — Tags & Scoring**](synapse.md) — Bloom filter and binary layout
-- :material-speedometer: [**Performance**](performance.md) — benchmark results
-
diff --git a/docs/docs/memory/synapse.md b/docs/docs/memory/synapse.md
deleted file mode 100644
index d7c29d1..0000000
--- a/docs/docs/memory/synapse.md
+++ /dev/null
@@ -1,479 +0,0 @@
----
-title: "Synapse — Tags & Scoring"
-description: "The versioned synaptic header (V1/V2/V3), 64-bit inline Bloom filter, arousal-modulated decay, and CognitiveRecordLayout binary format."
----
-
-# 🔗 Synapse — Tags & Scoring
-
-> **Package**: `com.spectrayan.spector.memory.synapse`
->
-> **Biological Analog**: In neuroscience, the **Synaptic Tagging and Capture (STC)** hypothesis (Frey & Morris, 1997) describes how synapses are "tagged" during learning with lightweight chemical markers. These tags don't contain the memory itself — they identify *what* the memory is about and *when* it was formed, enabling the brain to route consolidation activity efficiently.
-
----
-
-## Versioned Header Layouts
-
-Every cognitive memory record begins with a synaptic header — the digital equivalent of a synaptic tag. The header format is **versioned** via the `HeaderLayout` sealed interface, supporting three layout sizes:
-
-```mermaid
-classDiagram
-    class HeaderLayout {
-        <<sealed interface>>
-        +headerBytes() int
-        +version() int
-        +readHeader(segment, offset) CognitiveHeader
-        +writeHeader(segment, offset, header)
-        +forVersion(int) HeaderLayout$
-        +defaultLayout() HeaderLayout$
-    }
-    
-    class HeaderLayoutV1 {
-        +headerBytes() = 32
-        +version() = 1
-    }
-    class HeaderLayoutV2 {
-        +headerBytes() = 48
-        +version() = 2
-    }
-    class HeaderLayoutV3 {
-        +headerBytes() = 64
-        +version() = 3
-    }
-    
-    HeaderLayout <|.. HeaderLayoutV1 : permits
-    HeaderLayout <|.. HeaderLayoutV2 : permits
-    HeaderLayout <|.. HeaderLayoutV3 : permits
-```
-
-### V1 — Core Layout (32 bytes)
-
-The original layout, still supported for backward compatibility. Contains all fields required for the [6-Phase Scoring Pipeline](scoring-pipeline.md).
-
-```
- Offset   Size   Field             Description
- ──────   ────   ─────             ───────────
-    0      8B    timestamp_ms      Unix epoch ms when memory was formed
-    8      8B    synaptic_tags     64-bit Bloom filter of contextual markers
-   16      4B    exact_norm        L2 norm of original float vector
-   20      4B    importance        Cognitive importance (0.05 – 10.0)
-   24      4B    recall_count      Times recalled (LTP reconsolidation counter)
-   28      2B    centroid_id       IVF centroid assignment (max 65,535)
-   30      1B    valence           Emotional coloring (signed: -128 to +127)
-   31      1B    flags             Bit flags (see below)
-                                   ═══════════════════════════════════
-                                   Total: 32 bytes (1× AVX2 register)
-```
-
-!!! info "Why 32 bytes?"
-    The V1 header is exactly one **AVX2 register width** (256 bits). The entire header can be loaded in a single SIMD instruction for bulk scanning operations.
-
-### V2 — Extended Layout (48 bytes)
-
-Adds **arousal** and **storage strength** for emotional modulation and the future [Two-Factor Memory Strength](../labs/roadmap.md#two-factor-memory-strength-bjork-bjork-1992) model.
-
-```
- Offset   Size   Field             Description
- ──────   ────   ─────             ───────────
-    0     32B    [V1 core]         All V1 fields (timestamp through flags)
-   ─────────────────────────────── V2 extension ───────────────────────
-   32      1B    arousal           Emotional intensity (unsigned: 0-255)
-   33      3B    [padding]         Alignment padding
-   36      4B    storage_strength  Durability factor S(t) for Two-Factor model
-   40      8B    [reserved]        Future use (zeroed)
-                                   ═══════════════════════════════════
-                                   Total: 48 bytes (1.5× AVX2 registers)
-```
-
-**New fields:**
-
-| Field | Type | Range | Purpose |
-|:---|:---|:---|:---|
-| `arousal` | unsigned byte | 0 (calm) – 255 (extreme) | Modulates decay curve — high-arousal memories resist forgetting |
-| `storage_strength` | float | 0.0 – 5.0 | Two-Factor model durability (default: 1.0). Reserved for [Labs](../labs/roadmap.md) |
-
-### V3 — Full Cache-Line Layout (64 bytes) ⭐ Default
-
-The default for all new stores. Extends V2 with a 16-byte future buffer, aligned to a full **CPU cache line** (64 bytes) for optimal sequential scan performance.
-
-```
- Offset   Size   Field             Description
- ──────   ────   ─────             ───────────
-    0     32B    [V1 core]         All V1 fields (timestamp through flags)
-   ─────────────────────────────── V2 extension ───────────────────────
-   32      1B    arousal           Emotional intensity (unsigned: 0-255)
-   33      3B    [padding]         Alignment padding
-   36      4B    storage_strength  Durability factor S(t)
-   40      8B    [reserved_1]     Future use (zeroed)
-   ─────────────────────────────── V3 extension ───────────────────────
-   48     16B    [reserved_2]     Future expansion buffer (zeroed)
-                                   ═══════════════════════════════════
-                                   Total: 64 bytes (1× cache line, 2× AVX2)
-```
-
-!!! tip "Why V3 is the default"
-    **Cache-line alignment** eliminates split-line reads during sequential scans. When the scorer iterates over 1M records, each header read hits exactly one cache line — no partial line loads, no false sharing. The 16 bytes of reserved space cost ~1.5% total memory overhead but prevent future migration costs when new fields are added.
-
-### Version Comparison
-
-| Property | V1 (32B) | V2 (48B) | V3 (64B) |
-|:---|:---:|:---:|:---:|
-| Core fields | ✅ | ✅ | ✅ |
-| Arousal | ❌ (default: 0) | ✅ | ✅ |
-| Storage strength | ❌ (default: 1.0) | ✅ | ✅ |
-| Future buffer | ❌ | ❌ | ✅ (16B) |
-| Cache-line aligned | ❌ | ❌ | ✅ |
-| Memory per 1M records | 32 MB | 48 MB | 64 MB |
-| SIMD reads per header | 1 | 2 | 2 |
-
-### Backward Compatibility
-
-When a V3 reader encounters a V1 file, the missing fields return safe defaults:
-
-```java
-// V1 → V3 transparent upgrade
-CognitiveHeader header = layout.readHeader(segment, offset);
-header.arousal();          // → 0   (neutral — no arousal effect)
-header.storageStrength();  // → 1.0 (default durability)
-```
-
-No data migration is required for reads. The `CognitiveScorer` checks `headerBytes > 32` to determine whether arousal is available and skips the arousal read on V1 segments.
-
----
-
-## HeaderMigrator — One-Time Version Upgrades
-
-The `HeaderMigrator` performs atomic, one-time migration of store files between header versions.
-
-### Supported Paths
-
-```
- Upgrade (lossless):
-   V1 (32B) ──→ V2 (48B)  ✅   New fields filled with defaults
-   V1 (32B) ──→ V3 (64B)  ✅   New fields filled with defaults
-   V2 (48B) ──→ V3 (64B)  ✅   Existing V2 fields preserved
-
- Downgrade (lossy):
-   V3 (64B) ──→ V2 (48B)  ⚠️   Reserved buffer lost
-   V3 (64B) ──→ V1 (32B)  ⚠️   Arousal + storage_strength lost
-   V2 (48B) ──→ V1 (32B)  ⚠️   Arousal + storage_strength lost
-```
-
-### Atomic Migration Process
-
-```mermaid
-flowchart LR
-    A["Original Store<br/>store.dat"] --> B["Write to temp<br/>store.dat.migrating"]
-    B --> C["Verify temp<br/>record count match"]
-    C --> D["Backup original<br/>store.dat.bak"]
-    D --> E["Atomic rename<br/>temp → store.dat"]
-    
-    C -->|"Verify failed"| F["Delete temp<br/>Abort migration"]
-
-    style A fill:#3498db,color:white
-    style E fill:#27ae60,color:white
-    style F fill:#e74c3c,color:white
-```
-
-1. **Write** — Records are read from source, headers expanded/shrunk, written to `store.dat.migrating`
-2. **Verify** — Record count in temp file must match source exactly
-3. **Backup** — Original file renamed to `store.dat.bak`
-4. **Rename** — Temp file atomically renamed to `store.dat`
-5. **Cleanup** — On startup, orphaned `.migrating` files are detected and deleted
-
-### Usage
-
-```java
-HeaderMigrator migrator = new HeaderMigrator();
-
-// Upgrade V1 store to V3
-migrator.migrate(
-    Path.of("/data/episodic.dat"),
-    HeaderLayout.forVersion(1),  // source layout
-    HeaderLayout.forVersion(3),  // target layout
-    quantizedVecBytes            // vector payload size
-);
-```
-
----
-
-## Flags Bitfield
-
-The `flags` byte at offset 31 encodes per-record state:
-
-```
- Bit   Name          Description
- ───   ────          ───────────
-  0    tombstone     Record is logically deleted (pruned by Deep Sleep)
-  1-2  memory_type   2-bit type: 0=WORKING, 1=EPISODIC, 2=SEMANTIC, 3=PROCEDURAL
-  3    consolidated  Has been reflected into Semantic tier
-  4    pinned        Exempt from decay and pruning (flashbulb memories)
-  5    resolved      Zeigarnik Effect — resolved tasks return to normal decay
-  6-7  reserved      Future use
-```
-
-### Zeigarnik Effect (Bit 5)
-
-Unresolved memories (bit 5 = 0) resist time-decay — their decay bucket is clamped to 0, keeping them perpetually "fresh." This models the psychological phenomenon where incomplete tasks remain more accessible than completed ones.
-
-```java
-// In CognitiveScorer Phase 4:
-if (!isResolved(flags) && !isPinned(flags)) {
-    adjustedBucket = 0;  // acts like the memory was just formed
-}
-
-// Agent marks task complete:
-memory.markResolved("task-123");  // bit 5 → 1, normal decay resumes
-```
-
----
-
-## SynapticTagEncoder — The Inline Bloom Filter
-
-The `synaptic_tags` field is a **64-bit inline Bloom filter** rather than a discrete bitmap. This enables encoding thousands of unique tag strings across the system while each individual record holds 5-50 tags with negligible false positive rates.
-
-### How It Works
-
-```java
-public static long encode(String... tags) {
-    long filter = 0L;
-    for (String tag : tags) {
-        filter |= encodeTag(tag);
-    }
-    return filter;
-}
-
-private static long encodeTag(String tag) {
-    long h = murmurHash64(tag);
-    long h1 = h;
-    long h2 = h >>> 32 | h << 32; // Swap halves for second hash
-    
-    long filter = 0L;
-    for (int i = 0; i < K; i++) {  // K = 3 hash functions
-        int bitIndex = Math.abs((int) ((h1 + (long) i * h2) % M)); // M = 64
-        filter |= (1L << bitIndex);
-    }
-    return filter;
-}
-```
-
-**Key properties**:
-
-| Property | Value |
-|:---|:---|
-| Filter size | 64 bits (fits in a single CPU register) |
-| Hash functions | k = 3 (MurmurHash3-inspired double hashing) |
-| Bits per tag | 3 |
-| Match operation | `(record & query) == query` (containment check) |
-| Cost | **1 CPU cycle** (single `long` read + bitwise AND) |
-
-### False Positive Rates
-
-| Tags per Record | FPR | Assessment |
-|:---|:---|:---|
-| 5 tags | 0.03% | Excellent — 1 false match per 3,000 records |
-| 10 tags | 0.2% | Excellent — 1 false match per 500 records |
-| 20 tags | 2.3% | Good — vector distance rejects false matches |
-| 50 tags | 12% | Acceptable — still useful for coarse gating |
-
-!!! tip "System vs. Record Tags"
-    The system can have **thousands** of unique tag strings. But any single record should have at most **10-50 tags** for the Bloom filter to remain effective. This is a natural fit — a single memory rarely has more than 5-15 contextual associations.
-
-### Tag Overlap Scoring
-
-Beyond binary gating, the `SynapticTagEncoder` also computes a **fractional overlap ratio** for weighted tag relevance in Phase 6:
-
-```java
-public static float overlapRatio(long recordTags, long queryMask) {
-    if (queryMask == 0) return 0f;
-    int overlapBits = Long.bitCount(recordTags & queryMask);
-    int queryBits = Long.bitCount(queryMask);
-    return (float) overlapBits / queryBits;
-}
-```
-
-This ratio is used as a multiplier in the scoring formula: `finalScore = baseScore × (1 + tagOverlap × tagRelevanceBoost)`. A record matching 3 of 5 query tags gets a 60% tag boost vs 100% for a full match.
-
----
-
-## CognitiveRecordLayout — Binary Format
-
-The `CognitiveRecordLayout` class manages reading/writing headers and quantized vectors to/from off-heap `MemorySegment`. It delegates header operations to the active `HeaderLayout`:
-
-```java
-public final class CognitiveRecordLayout {
-    private final HeaderLayout headerLayout;
-    private final int quantizedVecBytes;
-    
-    /**
-     * Record stride = header bytes + vector payload.
-     * V1: 32 + vecBytes, V2: 48 + vecBytes, V3: 64 + vecBytes.
-     */
-    public int stride() {
-        return headerLayout.headerBytes() + quantizedVecBytes;
-    }
-    
-    /**
-     * Offset where the quantized vector begins within a record.
-     */
-    public long vectorOffset(long recordOffset) {
-        return recordOffset + headerLayout.headerBytes();
-    }
-    
-    public void writeHeader(MemorySegment segment, long offset, CognitiveHeader header) {
-        headerLayout.writeHeader(segment, offset, header);
-    }
-    
-    public CognitiveHeader readHeader(MemorySegment segment, long offset) {
-        return headerLayout.readHeader(segment, offset);
-    }
-}
-```
-
-### CognitiveHeader Record
-
-The header data is represented as a Java `record` with all fields from all versions:
-
-```java
-public record CognitiveHeader(
-    long timestampMs,       // when the memory was formed
-    long synapticTags,      // 64-bit Bloom filter
-    float exactNorm,        // L2 norm of original vector
-    float importance,       // cognitive importance (0.05 – 10.0)
-    int recallCount,        // LTP reconsolidation counter
-    short centroidId,       // IVF partition routing ID
-    byte valence,           // emotional coloring (-128 to +127)
-    byte flags,             // bit field (tombstone, type, consolidated, pinned, resolved)
-    byte arousal,           // V2+: emotional intensity (unsigned 0-255)
-    float storageStrength   // V2+: Two-Factor durability S(t)
-) {
-    /**
-     * V1-compatible constructor — fills V2+ fields with safe defaults.
-     */
-    public CognitiveHeader(long timestampMs, long synapticTags, float exactNorm,
-                            float importance, int recallCount, short centroidId,
-                            byte valence, byte flags) {
-        this(timestampMs, synapticTags, exactNorm, importance,
-             recallCount, centroidId, valence, flags,
-             (byte) 0,   // arousal: neutral
-             1.0f);      // storageStrength: default durability
-    }
-}
-```
-
----
-
-## DecayStrategy — SIMD-Friendly Temporal Decay
-
-!!! warning "The `exp()` Problem"
-    The naive decay formula `Math.exp(-λ·age)` costs 50-100ns per call and is a **scalar operation** — it cannot be SIMD-vectorized. At 1M memories, this adds 50-100ms of pure overhead, destroying the SIMD advantage.
-
-### The Solution: Precomputed Decay Buckets
-
-`DecayStrategy` quantizes time into discrete buckets and uses a precomputed lookup table:
-
-```java
-// Precomputed — zero Math.exp() calls at query time
-private static final float[] DECAY_TABLE = {
-    1.00f,  // Bucket 0: 0-1 hours
-    0.95f,  // Bucket 1: 1-6 hours
-    0.85f,  // Bucket 2: 6-24 hours
-    0.70f,  // Bucket 3: 1-3 days
-    0.50f,  // Bucket 4: 3-7 days
-    0.30f,  // Bucket 5: 1-2 weeks
-    0.15f,  // Bucket 6: 2-4 weeks
-    0.05f,  // Bucket 7: 1-3 months
-    0.01f   // Bucket 8+: 3+ months
-};
-
-public static float decay(int bucket) {
-    return DECAY_TABLE[Math.min(bucket, DECAY_TABLE.length - 1)];
-}
-```
-
-### Reconsolidation Adjustment
-
-Every 3 recalls shifts the bucket back by 1, simulating Long-Term Potentiation:
-
-```java
-public static int adjustForReconsolidation(int rawBucket, int recallCount) {
-    return Math.max(0, rawBucket - (recallCount / 3));
-}
-```
-
-A memory recalled 12 times is 4 buckets "younger" than its actual age — it resists forgetting.
-
-### Arousal-Modulated Decay
-
-Emotionally intense memories resist forgetting. The `arousal` byte (V2+ headers) modulates the decay curve through a 4-bucket lookup table:
-
-```java
-private static final int[] AROUSAL_THRESHOLDS = {64, 128, 192};
-private static final float[] AROUSAL_MODIFIERS = {1.0f, 1.15f, 1.35f, 1.65f};
-```
-
-| Arousal Range | Bucket | Modifier | Biological Basis |
-|:---|:---:|:---:|:---|
-| 0-63 (neutral) | 0 | 1.00× | Normal forgetting — routine memories |
-| 64-127 (mild) | 1 | 1.15× | Slightly persistent — mildly emotional |
-| 128-191 (moderate) | 2 | 1.35× | Noticeably persistent — significant events |
-| 192-255 (extreme) | 3 | 1.65× | Very hard to forget — flashbulb memories |
-
-The modifier **multiplies the base decay factor**, slowing the decay rate. A production outage at arousal=200 decays 1.65× slower than a routine log entry at arousal=0.
-
-```java
-/**
- * Computes decay with arousal modulation.
- * Higher arousal → slower decay → memory persists longer.
- */
-public static float computeDecayWithArousal(int bucket, byte arousal) {
-    float baseFactor = decay(bucket);
-    float modifier = arousalModifier(arousal);
-    return Math.min(1.0f, baseFactor * modifier);
-}
-
-/**
- * Returns the arousal modifier for a given arousal byte (unsigned 0-255).
- */
-public static float arousalModifier(byte arousal) {
-    int unsigned = Byte.toUnsignedInt(arousal);
-    for (int i = AROUSAL_THRESHOLDS.length - 1; i >= 0; i--) {
-        if (unsigned >= AROUSAL_THRESHOLDS[i]) return AROUSAL_MODIFIERS[i + 1];
-    }
-    return AROUSAL_MODIFIERS[0];
-}
-```
-
-**Automatic arousal derivation:** When arousal is not explicitly set by the LLM, it is auto-derived from valence at ingestion time:
-
-$$
-\text{arousal} = \min(255, |\text{valence}| \times 2)
-$$
-
-This means both extremely positive (valence=+100) and extremely negative (valence=-100) memories are equally arousing — matching the psychological finding that emotional intensity, not polarity, drives memory persistence.
-
-### Wiring in CognitiveScorer
-
-The scorer reads arousal from the header and applies the modifier to both standard and lateral scoring paths:
-
-```java
-// In CognitiveScorer, after Phase 4 (temporal/importance pre-screen):
-
-// Read arousal — only available on V2+ layouts
-byte arousal = hasArousal
-    ? segment.get(LAYOUT_AROUSAL, offset + OFFSET_AROUSAL)
-    : (byte) 0;  // V1 fallback: no arousal effect
-
-// Phase 6: Standard scoring
-float decay = DecayStrategy.decay(adjustedBucket) * DecayStrategy.arousalModifier(arousal);
-decay = Math.min(1.0f, decay);
-float baseScore = alpha * similarity + beta * importance * decay;
-```
-
----
-
-## Next Steps
-
-- :material-head-cog: [**Dopamine — Surprise Detection**](dopamine.md) — auto-importance scoring
-- :material-brain: [**Cortex — Tier Stores**](cortex.md) — the 4-tier architecture
-- :material-lightning-bolt: [**6-Phase Scoring Pipeline**](scoring-pipeline.md) — how scoring uses the header
-- :material-flask: [**Labs — Research Roadmap**](../labs/roadmap.md) — Two-Factor Memory, Dynamic Quantization
diff --git a/docs/docs/memory/sync.md b/docs/docs/memory/sync.md
deleted file mode 100644
index 54faee9..0000000
--- a/docs/docs/memory/sync.md
+++ /dev/null
@@ -1,92 +0,0 @@
----
-title: "Sync — Persistence & Replication"
-description: "Write-Ahead Log for durability and CRDT merge strategy for distributed memory synchronization."
----
-
-# 🔄 Sync — Persistence & Replication
-
-> **Package**: `com.spectrayan.spector.memory.sync`
->
-> **Biological Analog**: Memory consolidation doesn't happen in isolation. During sleep, the brain replays memories and transfers them between regions (hippocampus → neocortex). The sync package provides the infrastructure for **durable persistence** and **distributed memory merge**.
-
----
-
-## MemoryWal — Write-Ahead Log
-
-The `MemoryWal` provides crash-safe durability for cognitive memory operations:
-
-```java
-public final class MemoryWal implements AutoCloseable {
-
-    /**
-     * Appends a REMEMBER event to the WAL.
-     */
-    public void appendRemember(String id, MemoryType type, byte[] quantizedVec,
-                                CognitiveHeader header, String text,
-                                MemorySource source, String[] tags) { ... }
-
-    /**
-     * Appends a FORGET event to the WAL.
-     */
-    public void appendForget(String id) { ... }
-
-    /**
-     * Replays all WAL events to rebuild memory state after restart.
-     */
-    public void replay(WalEventHandler handler) { ... }
-
-    /**
-     * Returns the number of events in the WAL.
-     */
-    public long eventCount() { ... }
-
-    /**
-     * Returns the high-water mark (latest event offset).
-     */
-    public long highWaterMark() { ... }
-}
-```
-
-**Two modes**:
-
-| Mode | Storage | Use Case |
-|---|---|---|
-| **File-backed** | Append-only log file | Production — survives JVM restarts |
-| **In-memory** | `ArrayList<WalEvent>` | Testing — fast, no disk I/O |
-
----
-
-## CrdtMergeStrategy — Distributed Merge
-
-For multi-agent or distributed deployments, the `CrdtMergeStrategy` resolves conflicts between divergent memory replicas using **Conflict-free Replicated Data Types (CRDTs)**:
-
-```java
-public final class CrdtMergeStrategy {
-
-    /**
-     * Merges two versions of the same memory record.
-     *
-     * CRDT merge rules:
-     * - timestamp:    max(local, remote)     — Last-Write-Wins
-     * - synapticTags: local | remote         — OR-merge (union)
-     * - importance:   max(local, remote)     — Highest signal wins
-     * - recallCount:  max(local, remote)     — Monotonic counter
-     * - flags:        local | remote         — OR-merge (tombstone propagates)
-     */
-    public CognitiveHeader merge(CognitiveHeader local, CognitiveHeader remote) { ... }
-
-    /**
-     * Determines if a remote update should be applied.
-     */
-    public boolean shouldApply(CognitiveHeader local, CognitiveHeader remote) { ... }
-}
-```
-
-**Key insight**: Synaptic tags use **bitwise OR** for merge — this is a natural CRDT (G-Set). Tags can only be added, never removed, which guarantees convergence without coordination.
-
----
-
-## Next Steps
-
-- :material-memory: [**Off-Heap Panama Design**](panama-design.md) — how persistence interacts with mmap
-- :material-brain: [**Architecture**](architecture.md) — system overview
diff --git a/docs/docs/memory/wal-design.md b/docs/docs/memory/wal-design.md
deleted file mode 100644
index 0d78c15..0000000
--- a/docs/docs/memory/wal-design.md
+++ /dev/null
@@ -1,561 +0,0 @@
----
-title: "WAL Design — Write-Ahead Log"
-description: "Append-only binary WAL with chunked files, CRC-32 integrity, DEFLATE compression, crash recovery, CRDT merge, and cloud replication for cognitive memory durability."
----
-
-# 📝 WAL Design — Write-Ahead Log
-
-> **Package**: `com.spectrayan.spector.memory.sync`
->
-> **Biological Analog**: The hippocampus doesn't write memories directly to the neocortex. It first records a transient "replay buffer" — a sequential log of experiences — and consolidates them during sleep. The WAL is the digital equivalent: an ordered, append-only log of every memory mutation that can be replayed to reconstruct state.
-
----
-
-## Why a WAL?
-
-Cognitive memory stores mutable state (importance, valence, recall count, tags) in off-heap `MemorySegment` buffers. Without durability, a JVM crash loses everything. The WAL provides:
-
-| Concern | WAL Guarantee |
-|---|---|
-| **Crash recovery** | Replay the log → full state reconstruction |
-| **Ordering** | Monotonic sequence numbers → total order |
-| **Distributed sync** | Ship events after a high-water mark → pull-based replication |
-| **Auditability** | Every mutation is recorded (who, what, when) |
-| **Compaction** | Truncate chunks below a snapshot HWM |
-
----
-
-## Architecture Overview
-
-```mermaid
-graph TD
-    subgraph "Write Path"
-        A["SpectorMemory.remember()"] --> B["MemoryWal.append()"]
-        B --> C["writeLock.lock()"]
-        C --> D["events.add(event)"]
-        C --> E["writeEventToChannel()"]
-        E --> F["CRC-32 header + payload"]
-        F --> G["FileChannel.write()"]
-        G --> H{"chunk ≥ 8MB?"}
-        H -->|yes| I["rollChunk()"]
-        H -->|no| J["fsync (optional)"]
-    end
-
-    subgraph "Read Path (Recovery)"
-        K["JVM restart"] --> L["recoverFromDisk()"]
-        L --> M["findChunkFiles()"]
-        M --> N["readChunkFile() × N"]
-        N --> O["Validate magic + CRC"]
-        O --> P["Rebuild in-memory cache"]
-        P --> Q["Restore sequenceCounter"]
-    end
-
-    subgraph "Replication"
-        R["CloudSync.exportEvents()"] --> S["replay(afterHwm)"]
-        S --> T["Ship to remote agent"]
-        T --> U["importEvents() + CRDT merge"]
-    end
-
-    style A fill:#6c5ce7,color:white
-    style B fill:#00b894,color:white
-    style K fill:#e17055,color:white
-    style R fill:#0984e3,color:white
-```
-
----
-
-## Dual Mode Operation
-
-`MemoryWal` operates in two modes, selected at construction time:
-
-| Mode | Constructor | Storage | Durability | Use Case |
-|---|---|---|---|---|
-| **File-backed** | `new MemoryWal(walDir)` | Append-only chunk files | ✅ Survives crashes | Production |
-| **In-memory** | `new MemoryWal()` | `ArrayList<WalEvent>` | ❌ Volatile | Testing, ephemeral agents |
-
-```java
-// Production: durable WAL with 8MB chunk rolling
-MemoryWal wal = new MemoryWal(Path.of(".spector/memory/wal"));
-
-// Production: custom chunk size + compression + per-write fsync
-MemoryWal wal = new MemoryWal(walDir, 16 * 1024 * 1024, true, 512, true);
-
-// Testing: in-memory, no disk I/O
-MemoryWal wal = new MemoryWal();
-```
-
----
-
-## Event Types
-
-Every memory mutation produces a `WalEvent` record:
-
-```java
-public record WalEvent(
-    long sequence,          // monotonically increasing
-    EventType type,         // REMEMBER, FORGET, REINFORCE, REFLECT, TAG_MERGE, RECALL_HIT
-    String memoryId,        // the affected memory ID
-    Instant timestamp,      // when the event occurred
-    byte[] payload          // serialized event data (format varies by type)
-) { }
-```
-
-| Event Type | Trigger | Payload |
-|---|---|---|
-| `REMEMBER` | `memory.remember(text)` | Full cognitive record (header + quantized vector + text) |
-| `FORGET` | `memory.forget(id)` | Empty (tombstone marker) |
-| `REINFORCE` | `memory.reinforce(id, valence)` | 1 byte: valence value |
-| `REFLECT` | Sleep consolidation cycle | Consolidation metadata |
-| `TAG_MERGE` | Synaptic tag update | Updated tag bitfield |
-| `RECALL_HIT` | `memory.recall(query)` | Recall count increment |
-
----
-
-## Binary Record Format (V2)
-
-### File Header
-
-Each WAL chunk file begins with an 8-byte header:
-
-```
-Offset   Size   Field      Value
-──────   ────   ─────      ─────
-  0       4B    magic      0x53504543 ("SPEC" in ASCII)
-  4       4B    version    2
-```
-
-### Record Layout
-
-Each event is serialized as a **40-byte fixed header** followed by variable-length segments, aligned to 8-byte boundaries:
-
-```
- 0                   1                   2                   3
- 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-|         recMagic (2B)         |  version (1B) |   flags (1B)  |  ← Offset 0
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-|  typeOrd (1B) |          idLen (2B)           | reserved (1B) |  ← Offset 4
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-|                                                               |
-+                      sequence (8B)                            +  ← Offset 8
-|                                                               |
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-|                                                               |
-+                timestamp — epoch millis (8B)                  +  ← Offset 16
-|                                                               |
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-|                    payloadLen (4B)                             |  ← Offset 24
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-|                    payloadCRC (4B)                             |  ← Offset 28
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-|                     reserved (4B)                             |  ← Offset 32
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-|                     headerCRC (4B)                            |  ← Offset 36
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-|                  memoryId (idLen bytes, UTF-8)                |  ← Offset 40
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-|          payload (payloadLen bytes, optionally compressed)    |
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-|                 padding (0–7 bytes to 8-byte align)           |
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-```
-
-### Field Reference
-
-| Offset | Size | Field | Description |
-|--------|------|-------|-------------|
-| 0 | 2B | `recMagic` | `0x5741` ("WA") — record start sentinel |
-| 2 | 1B | `version` | Record format version (matches file version) |
-| 3 | 1B | `flags` | Bit 0: compressed payload |
-| 4 | 1B | `typeOrd` | `WalEvent.EventType` ordinal |
-| 5 | 2B | `idLen` | Memory ID length in bytes (unsigned) |
-| 7 | 1B | reserved | Future use |
-| 8 | 8B | `sequence` | Monotonic sequence number |
-| 16 | 8B | `timestamp` | Epoch milliseconds |
-| 24 | 4B | `payloadLen` | Payload length in bytes |
-| 28 | 4B | `payloadCRC` | CRC-32 of (possibly compressed) payload |
-| 32 | 4B | reserved | Future use |
-| 36 | 4B | `hdrCRC` | CRC-32 of bytes [0..35] |
-| 40 | N | `memoryId` | UTF-8 encoded memory ID |
-| 40+N | M | `payload` | Event-specific data |
-| 40+N+M | P | padding | `(8 - ((N+M) % 8)) % 8` zero bytes |
-
-**Total record size**: `40 + idLen + payloadLen + padding`
-
-### Integrity: Dual CRC-32
-
-Every record has **two** independent CRC-32 checksums:
-
-```mermaid
-graph LR
-    H["Header bytes 0-35"] -->|CRC-32| HC["Header CRC (offset 36)"]
-    P["Payload bytes"] -->|CRC-32| PC["Payload CRC (offset 28)"]
-
-    HC -->|verified on read| V1["✅ Header intact"]
-    PC -->|verified on read| V2["✅ Payload intact"]
-
-    style HC fill:#00b894,color:white
-    style PC fill:#00b894,color:white
-```
-
-This split design detects:
-
-- **Torn headers**: header CRC fails → truncate at record start
-- **Corrupt payloads**: payload CRC fails → quarantine chunk file
-- **Partial writes**: record magic missing → truncate at boundary
-
----
-
-## Chunked File Layout
-
-WAL data is spread across multiple **chunk files** in a directory:
-
-```
-.spector/memory/wal/
-├── wal-000000.bin    ← oldest chunk (may be truncated after snapshot)
-├── wal-000001.bin
-├── wal-000002.bin
-├── wal-000003.bin    ← active chunk (currently being written)
-└── .quarantine/      ← corrupted chunks moved here
-    └── wal-000001.bin
-```
-
-### Chunk Rolling
-
-When the active chunk exceeds `maxChunkBytes` (default **8 MB**), the WAL:
-
-1. Calls `force(true)` on the active `FileChannel` (metadata + data flush)
-2. Closes the channel
-3. Increments `chunkIndex`
-4. Opens a new chunk file with a fresh file header
-
-```java
-// Configurable chunk size
-new MemoryWal(walDir, 16 * 1024 * 1024); // 16 MB chunks
-```
-
-### Compaction & Garbage Collection
-
-As memories decay or undergo sleep-consolidation, older WAL chunks become redundant. The WAL enforces **snapshot-driven truncation** — chunks are only deleted after a snapshot proves their events have been fully materialized to disk.
-
-```mermaid
-flowchart TD
-    A["Active Writing Chunk"] -->|"size ≥ maxChunkBytes (8MB)"| B["rollChunk()"]
-    B --> C["Immutable Closed Chunk"]
-    D["Background Consolidation Daemon"] -->|"runs memory consolidation"| E["Generate Disk Snapshot"]
-    E -->|"write metadata"| F["Persist Snapshot High-Water Mark"]
-    F -->|"trigger compaction"| G{"truncateBefore(snapshotHwm)"}
-    G -->|"chunk maxSeq ≤ snapshotHwm"| H["Safe to Delete"]
-    G -->|"chunk maxSeq > snapshotHwm"| I["Must Retain"]
-    G -->|"chunk == activeChunkPath"| J["Never Touched"]
-    H --> K["Files.delete(chunk)"]
-    H --> L["events.removeIf(seq ≤ hwm)"]
-
-    style A fill:#6c5ce7,color:white
-    style H fill:#00b894,color:white
-    style J fill:#e17055,color:white
-```
-
-**How it works:**
-
-1. **Snapshot trigger**: The consolidation daemon (hippocampus) periodically snapshots the full in-memory state to disk (mmap partition files)
-2. **HWM declaration**: The snapshot records the highest WAL sequence number that has been fully materialized
-3. **Chunk disposal**: `truncateBefore(snapshotHwm)` sweeps all closed chunks — any chunk where the maximum sequence ≤ HWM is safely deleted
-4. **Active chunk protection**: The currently active chunk is **never** deleted, even if all its events are below the HWM
-5. **In-memory cache pruning**: Events with sequence ≤ HWM are also removed from the `ArrayList<WalEvent>` cache to prevent memory bloating
-
-```java
-// After a successful snapshot at sequence 5042:
-wal.truncateBefore(5042);
-// → deletes wal-000000.bin (maxSeq=3200), wal-000001.bin (maxSeq=4980)
-// → retains wal-000002.bin (maxSeq=5100, has events after HWM)
-// → retains wal-000003.bin (active chunk, never touched)
-```
-
-!!! tip "Zero Page-Cache Poisoning"
-    Chunk deletion uses `Files.delete()` at the file level — the compaction scanner does **not** read old WAL data back into memory. This avoids evicting the host's page cache, which would degrade active mmap partition performance during concurrent queries.
-
----
-
-## Crash Recovery
-
-On startup, `MemoryWal` automatically recovers from disk:
-
-```mermaid
-sequenceDiagram
-    participant JVM as ☕ JVM Restart
-    participant WAL as 📝 MemoryWal
-    participant FS as 💾 Filesystem
-
-    JVM->>WAL: new MemoryWal(walDir)
-    WAL->>FS: findChunkFiles() — sorted by name
-    loop Each chunk file
-        WAL->>FS: Open FileChannel (READ+WRITE)
-        WAL->>WAL: Validate file header (magic + version)
-        loop Each record
-            WAL->>WAL: Read 40B header
-            WAL->>WAL: Verify record magic (0x5741)
-            WAL->>WAL: Verify header CRC-32
-            WAL->>WAL: Read variable segments
-            WAL->>WAL: Verify payload CRC-32
-            alt Torn write detected
-                WAL->>FS: truncate(startPos) — repair in place
-                WAL->>WAL: Stop reading this chunk
-            else Mid-log corruption
-                WAL->>FS: Move to .quarantine/
-                WAL->>WAL: Throw WalCorruptionException
-            end
-        end
-    end
-    WAL->>WAL: Restore sequenceCounter to max(seq)
-    WAL->>WAL: Open next chunk for writing
-```
-
-### Corruption Recovery Strategy
-
-Because distributed nodes can experience power cuts, OS crashes, or disk hardware decay, the recovery process must handle corruption gracefully and **never allow silent data loss**.
-
-#### Classification of Corruptions
-
-```mermaid
-graph TD
-    A["WAL Boot Scan"] --> B{"Verify Record CRC?"}
-    B -->|"All Valid"| C["✅ Replay Completed"]
-    B -->|"CRC Mismatch / Truncated"| D{"Corruption at file tail?"}
-    D -->|"Yes — Torn Write"| E["Auto-Repair: truncate(startPos)"]
-    D -->|"No — Mid-Log Bit Rot"| F["Fatal: Quarantine Protocol"]
-    E --> G["Resume writing after last valid record"]
-    F --> H["Halt boot + move file to .quarantine/"]
-    H --> I["Throw WalCorruptionException"]
-    I --> J["Cold Bootstrap from healthy peer"]
-
-    style C fill:#00b894,color:white
-    style E fill:#fdcb6e,color:black
-    style F fill:#d63031,color:white
-```
-
-#### A. Torn Writes (End-of-File Corruption)
-
-| Aspect | Detail |
-|---|---|
-| **Cause** | Crash occurred while writing a record, leaving an incomplete block at the active chunk's tail |
-| **Diagnosis** | Record's expected boundary exceeds actual file size, or header/payload CRC fails with no subsequent valid records in the file |
-| **Safety** | The write was never acknowledged to the caller — the event is uncommitted |
-| **Resolution** | `handleTornWrite()` truncates the file to `startPos` (the last fully-written record boundary) and forces to disk. Writing resumes from the repaired position |
-
-```java
-private void handleTornWrite(Path path, FileChannel fc, long startPos) throws IOException {
-    log.warn("Torn WAL record detected in {} at position {}. "
-           + "Truncating file to recovery boundary.", path, startPos);
-    fc.truncate(startPos);
-    fc.force(true);
-}
-```
-
-#### B. Mid-Log Corruption (Bit Rot)
-
-| Aspect | Detail |
-|---|---|
-| **Cause** | Magnetic/SSD decay in historical, closed chunks — a valid record is followed by corrupted bytes, then more valid records |
-| **Diagnosis** | CRC mismatch detected at a position that is NOT the file tail — valid records exist after the corruption point |
-| **Safety** | Truncating would discard **committed** operations, causing silent partition state divergence |
-| **Resolution** | **Never auto-repair.** The chunk is moved to `.quarantine/` to preserve forensic evidence, and a `WalCorruptionException` halts startup. In cluster mode, the node initiates a **Cold Bootstrap** from a healthy peer |
-
-```java
-private void handleMiddleLogCorruption(Path path, FileChannel fc,
-                                        long startPos, String reason) throws IOException {
-    log.error("Fatal mid-log corruption in {} at position {}: {}. "
-            + "Triggering quarantine.", path, startPos, reason);
-    fc.close();
-
-    Path quarantineDir = path.getParent().resolve(".quarantine");
-    Files.createDirectories(quarantineDir);
-    Path quarantinedPath = quarantineDir.resolve(path.getFileName());
-    Files.move(path, quarantinedPath, StandardCopyOption.REPLACE_EXISTING);
-
-    throw new WalCorruptionException(
-        "Fatal WAL corruption: " + reason + " at position " + startPos);
-}
-```
-
-#### Summary Matrix
-
-| Scenario | Detection | Action | Data Loss? |
-|---|---|---|---|
-| **Torn write** (EOF) | Record too short or CRC fails at tail | `truncate(startPos)` — auto-repair | ❌ No — write was uncommitted |
-| **Bit rot** (mid-log) | CRC fails with valid records after | Quarantine + `WalCorruptionException` | ❌ No — manual recovery required |
-| **Invalid file magic** | File header ≠ `0x53504543` | Skip file, log warning | ❌ No — file is not a WAL |
-| **Version mismatch** | File version ≠ `WAL_VERSION` | Skip file, log warning | ❌ No — incompatible format |
-
-!!! warning "Why Not Auto-Repair Bit Rot?"
-    Truncating in the middle of a historical chunk would discard committed operations that downstream consumers (replicas, snapshots) may depend on. The quarantine-and-halt approach ensures **zero silent data loss** — the operator or cluster protocol must explicitly resolve the corruption before the node can serve traffic.
-
----
-
-## Compression
-
-Payload compression is opt-in and uses **DEFLATE** (java.util.zip):
-
-```java
-// Enable compression for payloads > 512 bytes
-new MemoryWal(walDir, 8 * 1024 * 1024, true, 512, false);
-```
-
-| Setting | Default | Description |
-|---|---|---|
-| `compressionEnabled` | `false` | Master switch |
-| `compressionThreshold` | `1024` bytes | Minimum payload size before compression kicks in |
-
-When compression is enabled:
-
-1. Payloads larger than the threshold are DEFLATE-compressed before writing
-2. The `flags` byte (offset 3) has bit 0 set to `1`
-3. On read, the flag is checked and the payload is decompressed with `Inflater`
-4. CRC-32 is computed on the **compressed** bytes (what's on disk)
-
-!!! tip "When to Enable"
-    Compression is most useful for `REMEMBER` events, which carry full text + quantized vectors (hundreds to thousands of bytes). `FORGET` and `REINFORCE` events have tiny payloads and skip compression regardless of the threshold.
-
----
-
-## Distributed Sync — CloudSync
-
-`CloudSync` provides **pull-based replication** between agents using the WAL as the replication log:
-
-```mermaid
-graph LR
-    subgraph "Agent A"
-        WA["MemoryWal A"] --> CSA["CloudSync A"]
-    end
-
-    subgraph "Agent B"
-        WB["MemoryWal B"] --> CSB["CloudSync B"]
-    end
-
-    CSA -->|"exportEvents(remoteHwm)"| EVENTS["WAL Events"]
-    EVENTS -->|"importEvents()"| CSB
-
-    CSB -->|"CRDT merge"| WB
-
-    style CSA fill:#0984e3,color:white
-    style CSB fill:#0984e3,color:white
-    style EVENTS fill:#fdcb6e,color:black
-```
-
-### Replication Protocol
-
-1. **Agent B** sends its `highWaterMark` to Agent A
-2. **Agent A** calls `wal.replay(remoteHwm)` → returns only new events
-3. Events are shipped to Agent B (in-process V2, HTTP/gRPC V3)
-4. **Agent B** replays each event into its local memory store
-5. Conflicts are resolved via **CRDT merge** (see below)
-
-### Cold Bootstrap
-
-When a new agent joins (or corruption triggers a full resync):
-
-```java
-// Download snapshot from leader and restore local state
-long leaderHwm = CloudSync.bootstrapFromLeader(
-    "http://leader:7070",
-    localPersistenceDir
-);
-```
-
-The leader serves its entire off-heap state as a zip archive via `GET /api/v2/memory/snapshot`. The new agent unpacks it, restoring all mmap partition files and WAL chunks.
-
----
-
-## CRDT Merge Strategy
-
-When two agents modify the same memory concurrently, `CrdtMergeStrategy` resolves conflicts deterministically:
-
-| Field | CRDT Type | Merge Rule | Guarantee |
-|---|---|---|---|
-| `timestamp` | LWW Register | `max(local, remote)` | Most recent write wins |
-| `synapticTags` | G-Set (OR) | `local \| remote` | Tags only accumulate, never removed |
-| `importance` | Max Register | `max(local, remote)` | Highest signal preserved |
-| `recallCount` | G-Counter | `max(local, remote)` | Monotonic counter |
-| `valence` | LWW Register | Value from newer `timestamp` | Latest emotional signal wins |
-| `tombstone` (flag) | OR | `local \| remote` | Once deleted, always deleted |
-| `consolidated` (flag) | OR | `local \| remote` | Once consolidated, stays consolidated |
-| `pinned` (flag) | OR | `local \| remote` | Once pinned, stays pinned |
-
-**Convergence guarantee**: All merge operations are commutative, associative, and idempotent — any order of merges from any agents produces the **same final state**.
-
-```java
-CrdtMergeStrategy.MergedHeader result = CrdtMergeStrategy.merge(local, remote);
-
-// Check if merge would actually change local state
-if (CrdtMergeStrategy.wouldChange(local, remote)) {
-    applyMerge(result);
-}
-```
-
----
-
-## Thread Safety
-
-| Operation | Lock | Mechanism |
-|---|---|---|
-| `append()` | `writeLock` (ReentrantLock) | Serializes writes — safe with Virtual Threads |
-| `replay()` | None | Reads from in-memory `ArrayList` snapshot |
-| `truncateBefore()` | `writeLock` | Serializes with appends |
-| `close()` | `writeLock` | Final `force(true)` + channel close |
-
-!!! tip "No `synchronized`"
-    `MemoryWal` uses `ReentrantLock` exclusively — never `synchronized` — to avoid Virtual Thread pinning. This is consistent with the zero-`synchronized` policy across the entire Spector codebase.
-
----
-
-## Configuration
-
-WAL behavior is controlled via `spector.yml`:
-
-```yaml
-spector:
-  memory:
-    persistence-mode: DISK          # DISK | IN_MEMORY
-    persistence-path: .spector/memory
-```
-
-| Parameter | Default | Description |
-|---|---|---|
-| `persistence-mode` | `DISK` | `DISK` = file-backed WAL, `IN_MEMORY` = volatile |
-| `persistence-path` | `.spector/memory` | Root directory (WAL stored in `{path}/wal/`) |
-| Chunk size | 8 MB | Hardcoded default, configurable via constructor |
-| Compression | `false` | Configurable via constructor |
-| fsync-per-write | `false` | Configurable via constructor |
-
----
-
-## Storage Adapter SPI
-
-For cloud-based WAL replication, the `StorageAdapter` SPI provides a pluggable backend:
-
-```java
-public interface StorageAdapter extends AutoCloseable {
-    void upload(String namespace, String chunkName, ByteBuffer data);
-    ByteBuffer download(String namespace, String chunkName);
-    List<String> listChunks(String namespace);
-    List<String> listNamespaces();
-    boolean isAvailable();
-}
-```
-
-Planned implementations:
-
-| Adapter | Backend | Status |
-|---|---|---|
-| `S3StorageAdapter` | AWS S3 | Planned (V3) |
-| `GcsStorageAdapter` | Google Cloud Storage | Planned (V3) |
-| `LocalStorageAdapter` | Local filesystem | Planned (V3) |
-
----
-
-## Next Steps
-
-- :material-memory: [**Off-Heap Panama Design**](panama-design.md) — how mmap partitions store cognitive records
-- :material-sleep: [**Hippocampus — Sleep Consolidation**](hippocampus.md) — the consolidation daemon that triggers snapshot + truncation
-- :material-brain: [**Architecture**](architecture.md) — system overview
-- :material-lightning-bolt: [**Synapse — Tags & Scoring**](synapse.md) — the synaptic header that WAL events serialize
diff --git a/docs/docs/modules/index.md b/docs/docs/modules/index.md
deleted file mode 100644
index 165bcfd..0000000
--- a/docs/docs/modules/index.md
+++ /dev/null
@@ -1,213 +0,0 @@
-# Modules
-
-Spector is organized as a multi-module Maven project. Each module has a focused responsibility, clear API boundaries, and minimal cross-module coupling.
-
----
-
-## Architecture
-
-```mermaid
-graph LR
-    subgraph "🔬 Foundation"
-        core["spector-core<br/><i>SIMD kernels</i>"]
-        commons["spector-commons<br/><i>Chunkers, tokenizer</i>"]
-        config["spector-config<br/><i>SpectorConfig + YAML</i>"]
-        storage["spector-storage<br/><i>Panama MemorySegment</i>"]
-    end
-
-    subgraph "🧠 Intelligence"
-        embedApi["spector-embed-api<br/><i>Embedding SPI</i>"]
-        embedOllama["spector-embed-ollama<br/><i>Ollama provider</i>"]
-        index["spector-index<br/><i>HNSW + IVF-PQ + BM25</i>"]
-        query["spector-query<br/><i>Hybrid + RRF + rerank</i>"]
-        gpu["spector-gpu<br/><i>CUDA via Panama FFM</i>"]
-    end
-
-    subgraph "⚡ Engine"
-        rag["spector-rag<br/><i>RAG pipeline</i>"]
-        engine["spector-engine<br/><i>Search facade</i>"]
-        ingestion["spector-ingestion<br/><i>File ingest pipeline</i>"]
-        memory["spector-memory<br/><i>Cognitive memory 🧠</i>"]
-    end
-
-    subgraph "🌐 Runtime & Interfaces"
-        runtime["spector-runtime<br/><i>Composition root</i>"]
-        node["spector-node<br/><i>Armeria: REST + gRPC + SSE</i>"]
-        mcp["spector-mcp<br/><i>MCP Server (stdio)</i>"]
-        cli["spector-cli<br/><i>spectorctl</i>"]
-        client["spector-client<br/><i>Java SDK</i>"]
-        spring["spector-spring<br/><i>Spring AI</i>"]
-    end
-
-    subgraph "📦 Distribution"
-        metrics["spector-metrics<br/><i>Prometheus + JVM</i>"]
-        bench["spector-bench<br/><i>JMH benchmarks</i>"]
-        dist["spector-dist<br/><i>Fat JAR</i>"]
-    end
-```
-
----
-
-## Module Dependency Graph
-
-```mermaid
-graph TD
-    node["🌐 node"] --> runtime["⚡ runtime"]
-    node --> mcp["🤖 mcp"]
-    node --> metrics["📈 metrics"]
-    mcp --> runtime
-    mcp --> ingestion["📥 ingestion"]
-    cli["🖥️ cli"] --> runtime
-    cli --> client["📦 client"]
-
-    runtime --> engine["⚡ engine"]
-    runtime --> memory["🧠 memory"]
-    runtime --> ingestion
-
-    engine --> query["🔍 query"]
-    engine --> rag["🤖 rag"]
-    engine --> ingestion
-    engine --> index["📊 index"]
-    engine --> storage["💾 storage"]
-    engine --> embedapi["🧬 embed-api"]
-    engine -.-> gpu["🎮 gpu"]
-
-    memory --> index
-    memory --> storage
-    memory --> ingestion
-    memory --> embedapi
-    memory --> core["🔬 core"]
-
-    metrics --> engine
-    metrics --> memory
-
-    ingestion --> config["⚙️ config"]
-    ingestion --> embedapi
-
-    rag --> query
-    rag --> index
-    rag --> storage
-    rag --> embedapi
-
-    query --> index
-    index --> storage
-    index --> config
-    storage --> config
-    storage --> core
-    config --> core
-
-    embedapi --> commons["📄 commons"]
-    gpu --> core
-    gpu --> storage
-
-    dist["📦 dist"] --> mcp
-    dist --> cli
-    dist --> runtime
-
-    spring["🌱 spring"] --> engine
-    spring --> memory
-    spring --> metrics
-    bench["🧪 bench"] --> engine
-    bench --> memory
-```
-
-> **Legend:** Solid arrows = compile dependency. Dotted arrow (`gpu`) = optional dependency.
-
-!!! important "Architecture"
-    `spector-ingestion` defines the `IngestionPipeline` and `IngestionTarget` interface. Both `spector-engine` and `spector-memory` depend on it to implement their `IngestionTarget`. `spector-memory` is fully independent of `spector-engine` — they are peers, wired together only at the `SpectorRuntime` composition root.
-
----
-
-## Architecture: Entry Points → Runtime → Subsystems
-
-All entry points (MCP, CLI, Server) route through `SpectorRuntime`:
-
-```mermaid
-graph TD
-    cli["🖥️ spector-cli<br/><i>SpectorCtl</i>"]
-    mcp["🤖 spector-mcp<br/><i>SpectorMcpMain</i>"]
-    node["🌐 spector-node<br/><i>SpectorNode (Armeria)</i>"]
-
-    cli --> runtime
-    mcp --> runtime
-    node --> runtime
-
-    runtime["⚡ SpectorRuntime<br/><i>Composition Root</i>"]
-
-    runtime --> sh["SearchHandler<br/><i>mode-aware search</i>"]
-    runtime --> ih["IngestionHandler<br/><i>delegates to IngestionPipeline</i>"]
-
-    sh --> engine["SpectorEngine"]
-    sh --> memory["SpectorMemory"]
-    ih --> pipeline["IngestionPipeline<br/><i>chunk → embed → store</i>"]
-    pipeline --> engineTarget["EngineIngestionTarget<br/><i>SEARCH mode</i>"]
-    pipeline --> memTarget["CognitiveIngestionTarget<br/><i>MEMORY mode</i>"]
-```
-
-**SpectorRuntime** is a thin composition root — it creates and wires subsystems but contains no business logic. Each handler owns its domain:
-
-| Handler | Responsibility | Routes to |
-|---------|---------------|-----------|
-| `SearchHandler` | Mode-aware search | Engine (SEARCH mode) or Memory (MEMORY mode) |
-| `IngestionHandler` | Delegates to unified `IngestionPipeline` | Pipeline → `EngineIngestionTarget` or `CognitiveIngestionTarget` |
-
----
-
-## Module Overview
-
-### Foundation Layer
-
-| Module | Description |
-|:---|:---|
-| [spector-commons](spector-commons.md) | Shared utilities — concurrent primitives, I/O helpers |
-| [spector-core](spector-core.md) | Core abstractions — quantization, SIMD, similarity functions |
-| [spector-config](spector-config.md) | Configuration — `SpectorProperties`, `SpectorConfigFactory`, YAML loading |
-| [spector-storage](spector-storage.md) | Persistent storage — memory-mapped files, arena management |
-
-### Embedding Layer
-
-| Module | Description |
-|:---|:---|
-| [spector-embed-api](spector-embed-api.md) | Embedding provider SPI — model-agnostic interface |
-| [spector-embed-ollama](spector-embed-ollama.md) | Ollama embedding implementation |
-
-### Search Layer
-
-| Module | Description |
-|:---|:---|
-| [spector-index](spector-index.md) | Vector indexing — HNSW, IVF, brute-force |
-| [spector-query](spector-query.md) | Query processing — parsing, planning, execution |
-| [spector-gpu](spector-gpu.md) | GPU acceleration — Panama FFM bindings |
-
-### Intelligence Layer
-
-| Module | Description |
-|:---|:---|
-| [spector-rag](spector-rag.md) | RAG pipeline — retrieval-augmented generation |
-| [spector-engine](spector-engine.md) | Search engine — orchestrates index + RAG + storage |
-| [spector-ingestion](spector-ingestion.md) | Unified ingestion pipeline — `IngestionPipeline` (builder), `IngestionTarget` interface, `FileDiscoveryService` |
-| [spector-memory](spector-memory.md) | Cognitive memory — biologically-inspired agent memory |
-
-### Runtime Layer
-
-| Module | Description |
-|:---|:---|
-| [spector-runtime](spector-runtime.md) | Composition root — wires engine + memory + ingestion pipeline, exposes `SearchHandler` and `IngestionHandler` |
-| [spector-mcp](spector-mcp.md) | MCP server — Model Context Protocol integration via stdio |
-| [spector-node](spector-node.md) | Unified node — Armeria HTTP REST + gRPC + SSE events + cluster coordination |
-
-### Client Layer
-
-| Module | Description |
-|:---|:---|
-| [spector-cli](spector-cli.md) | CLI tool — `spectorctl` with remote (HTTP) and local batch (runtime) modes |
-| [spector-client](spector-client.md) | Java client — programmatic HTTP API access |
-| [spector-spring](spector-spring.md) | Spring AI integration — auto-configuration |
-
-### Infrastructure
-
-| Module | Description |
-|:---|:---|
-| [spector-metrics](spector-metrics.md) | Metrics — Prometheus + JVM instrumentation |
-| [spector-bench](spector-bench.md) | Benchmarks — JMH performance testing |
-| [spector-dist](spector-dist.md) | Distribution — single fat JAR packaging |
diff --git a/docs/docs/modules/spector-bench.md b/docs/docs/modules/spector-bench.md
deleted file mode 100644
index 570a55a..0000000
--- a/docs/docs/modules/spector-bench.md
+++ /dev/null
@@ -1 +0,0 @@
---8<-- "spector-bench/README.md"
diff --git a/docs/docs/modules/spector-cli.md b/docs/docs/modules/spector-cli.md
deleted file mode 100644
index adb4d1e..0000000
--- a/docs/docs/modules/spector-cli.md
+++ /dev/null
@@ -1 +0,0 @@
---8<-- "spector-cli/README.md"
diff --git a/docs/docs/modules/spector-client.md b/docs/docs/modules/spector-client.md
deleted file mode 100644
index fcea103..0000000
--- a/docs/docs/modules/spector-client.md
+++ /dev/null
@@ -1 +0,0 @@
---8<-- "spector-client/README.md"
diff --git a/docs/docs/modules/spector-commons.md b/docs/docs/modules/spector-commons.md
deleted file mode 100644
index baf8970..0000000
--- a/docs/docs/modules/spector-commons.md
+++ /dev/null
@@ -1 +0,0 @@
---8<-- "spector-commons/README.md"
diff --git a/docs/docs/modules/spector-config.md b/docs/docs/modules/spector-config.md
deleted file mode 100644
index 4a03d02..0000000
--- a/docs/docs/modules/spector-config.md
+++ /dev/null
@@ -1 +0,0 @@
---8<-- "spector-config/README.md"
diff --git a/docs/docs/modules/spector-core.md b/docs/docs/modules/spector-core.md
deleted file mode 100644
index 671e050..0000000
--- a/docs/docs/modules/spector-core.md
+++ /dev/null
@@ -1 +0,0 @@
---8<-- "spector-core/README.md"
diff --git a/docs/docs/modules/spector-cortex.md b/docs/docs/modules/spector-cortex.md
deleted file mode 100644
index 6281162..0000000
--- a/docs/docs/modules/spector-cortex.md
+++ /dev/null
@@ -1,71 +0,0 @@
----
-title: spector-cortex
-description: "Real-time neural dashboard for visualizing Spector's cognitive memory engine."
----
-
-# spector-cortex
-
-!!! info "Module Type"
-    **Frontend Application** — Angular 21 standalone UI (not a Maven module)
-
-## Purpose
-
-`spector-cortex` is the real-time neural visualization dashboard for Spector's cognitive memory engine. It provides interactive 3D and 2D visualizations of the entire cognitive pipeline — from SIMD vector processing to Hebbian graph spreading activation to Ebbinghaus decay curves.
-
-Unlike the backend Java modules, this is a standalone **Angular 21 application** that runs independently and connects to a Spector Node via SSE.
-
-## Key Features
-
-| Feature | Description |
-|:--------|:------------|
-| **Neural Graph** | 200-node Three.js 3D graph with 3 edge types and particle trails |
-| **Vector Space** | 300-point PCA-projected embedding cloud |
-| **Scoring Pipeline** | Animated 6-phase cognitive funnel |
-| **Live Metrics** | Real-time recall/remember/reinforce/forget time-series |
-| **Cognitive Profiles** | 6-axis radar chart with smooth profile transitions |
-| **SIMD Lanes** | 16-lane register heatmap |
-| **Memory Heatmap** | Off-heap segment utilization |
-| **Decay Curve** | Ebbinghaus + LTP reconsolidation overlay |
-| **Query History** | Scrollable timeline with latency and profile chips |
-| **Zeigarnik Effect** | Unresolved memory tension gauge |
-| **Habituation** | IoR, satiation, and penalty gauges |
-| **Mock Data** | Toggleable simulated events for demo/development |
-
-## Technology Stack
-
-| Layer | Technology |
-|:------|:-----------|
-| Framework | Angular 21 (standalone, zoneless) |
-| UI Components | Angular Material 3 |
-| 3D Rendering | Three.js |
-| 2D Charts | Canvas 2D API |
-| State | Angular Signals |
-| Data Stream | SSE (`ng-sse-client`) |
-| Styling | SCSS + M3 CSS tokens |
-
-## Quick Start
-
-```bash
-cd spector-cortex
-npm install
-npx ng serve --port 4300
-```
-
-## Dependencies
-
-`spector-cortex` has **no compile-time dependency** on any Java module. It communicates with the backend exclusively through SSE:
-
-```mermaid
-graph LR
-    cortex["🧬 spector-cortex<br/><i>Angular 21 UI</i>"] -->|SSE| node["🌐 spector-node<br/><i>Armeria Server</i>"]
-    node --> runtime["⚡ spector-runtime"]
-    node --> memory["🧠 spector-memory"]
-    node --> metrics["📈 spector-metrics"]
-```
-
-## Related
-
-- [Cortex Dashboard — Full Documentation](../cortex/index.md)
-- [Cognitive Memory Overview](../memory/index.md)
-- [spector-node](spector-node.md)
-- [spector-metrics](spector-metrics.md)
diff --git a/docs/docs/modules/spector-dist.md b/docs/docs/modules/spector-dist.md
deleted file mode 100644
index e3596b7..0000000
--- a/docs/docs/modules/spector-dist.md
+++ /dev/null
@@ -1 +0,0 @@
---8<-- "spector-dist/README.md"
diff --git a/docs/docs/modules/spector-embed-api.md b/docs/docs/modules/spector-embed-api.md
deleted file mode 100644
index defe85b..0000000
--- a/docs/docs/modules/spector-embed-api.md
+++ /dev/null
@@ -1 +0,0 @@
---8<-- "spector-embed-api/README.md"
diff --git a/docs/docs/modules/spector-embed-ollama.md b/docs/docs/modules/spector-embed-ollama.md
deleted file mode 100644
index 9f2e57f..0000000
--- a/docs/docs/modules/spector-embed-ollama.md
+++ /dev/null
@@ -1 +0,0 @@
---8<-- "spector-embed-ollama/README.md"
diff --git a/docs/docs/modules/spector-engine.md b/docs/docs/modules/spector-engine.md
deleted file mode 100644
index 9f602a4..0000000
--- a/docs/docs/modules/spector-engine.md
+++ /dev/null
@@ -1 +0,0 @@
---8<-- "spector-engine/README.md"
diff --git a/docs/docs/modules/spector-gpu.md b/docs/docs/modules/spector-gpu.md
deleted file mode 100644
index 90bbe4d..0000000
--- a/docs/docs/modules/spector-gpu.md
+++ /dev/null
@@ -1 +0,0 @@
---8<-- "spector-gpu/README.md"
diff --git a/docs/docs/modules/spector-index.md b/docs/docs/modules/spector-index.md
deleted file mode 100644
index f0a7ecb..0000000
--- a/docs/docs/modules/spector-index.md
+++ /dev/null
@@ -1 +0,0 @@
---8<-- "spector-index/README.md"
diff --git a/docs/docs/modules/spector-ingestion.md b/docs/docs/modules/spector-ingestion.md
deleted file mode 100644
index d1b7771..0000000
--- a/docs/docs/modules/spector-ingestion.md
+++ /dev/null
@@ -1 +0,0 @@
---8<-- "spector-ingestion/README.md"
diff --git a/docs/docs/modules/spector-mcp.md b/docs/docs/modules/spector-mcp.md
deleted file mode 100644
index 3197539..0000000
--- a/docs/docs/modules/spector-mcp.md
+++ /dev/null
@@ -1 +0,0 @@
---8<-- "spector-mcp/README.md"
diff --git a/docs/docs/modules/spector-memory.md b/docs/docs/modules/spector-memory.md
deleted file mode 100644
index 8cf3bad..0000000
--- a/docs/docs/modules/spector-memory.md
+++ /dev/null
@@ -1 +0,0 @@
---8<-- "spector-memory/README.md"
diff --git a/docs/docs/modules/spector-metrics.md b/docs/docs/modules/spector-metrics.md
deleted file mode 100644
index 393905f..0000000
--- a/docs/docs/modules/spector-metrics.md
+++ /dev/null
@@ -1 +0,0 @@
---8<-- "spector-metrics/README.md"
diff --git a/docs/docs/modules/spector-node.md b/docs/docs/modules/spector-node.md
deleted file mode 100644
index 799bef5..0000000
--- a/docs/docs/modules/spector-node.md
+++ /dev/null
@@ -1 +0,0 @@
---8<-- "spector-node/README.md"
diff --git a/docs/docs/modules/spector-query.md b/docs/docs/modules/spector-query.md
deleted file mode 100644
index 598ff97..0000000
--- a/docs/docs/modules/spector-query.md
+++ /dev/null
@@ -1 +0,0 @@
---8<-- "spector-query/README.md"
diff --git a/docs/docs/modules/spector-rag.md b/docs/docs/modules/spector-rag.md
deleted file mode 100644
index 7f79efb..0000000
--- a/docs/docs/modules/spector-rag.md
+++ /dev/null
@@ -1 +0,0 @@
---8<-- "spector-rag/README.md"
diff --git a/docs/docs/modules/spector-runtime.md b/docs/docs/modules/spector-runtime.md
deleted file mode 100644
index d11e054..0000000
--- a/docs/docs/modules/spector-runtime.md
+++ /dev/null
@@ -1 +0,0 @@
---8<-- "spector-runtime/README.md"
diff --git a/docs/docs/modules/spector-spring.md b/docs/docs/modules/spector-spring.md
deleted file mode 100644
index 7e619ea..0000000
--- a/docs/docs/modules/spector-spring.md
+++ /dev/null
@@ -1 +0,0 @@
---8<-- "spector-spring/README.md"
diff --git a/docs/docs/modules/spector-storage.md b/docs/docs/modules/spector-storage.md
deleted file mode 100644
index aa9a3df..0000000
--- a/docs/docs/modules/spector-storage.md
+++ /dev/null
@@ -1 +0,0 @@
---8<-- "spector-storage/README.md"
diff --git a/docs/docs/operations/contributing.md b/docs/docs/operations/contributing.md
deleted file mode 100644
index 7a07af6..0000000
--- a/docs/docs/operations/contributing.md
+++ /dev/null
@@ -1,268 +0,0 @@
-# 🤝 Contributing
-
-> **We'd love your help making Spector even better!** Whether you're fixing a bug, adding a feature, improving docs, or optimizing performance — every contribution matters. This page covers everything you need to get started.
-
----
-
-## 🚀 Development Setup
-
-### 📋 Prerequisites
-
-| Tool | Version | Notes |
-|------|---------|-------|
-| ☕ JDK | 25+ | OpenJDK with Vector API incubator |
-| 📦 Maven | 3.9+ | Multi-module reactor build |
-| 🔧 Git | 2.40+ | Version control |
-
-### 🏗️ First-Time Setup
-
-```bash
-# Fork and clone
-git clone https://github.com/<your-username>/spector.git
-cd spector
-
-# Verify JDK
-java -version   # Should show 25+
-
-# Build the project
-mvn clean compile
-
-# Run the full test suite (316+ tests)
-mvn test
-
-# Verify SIMD support
-java --add-modules jdk.incubator.vector -cp spector-core/target/classes \
-  com.spectrayan.spector.core.SimdCapability
-```
-
-> [!TIP]
-> The full build takes ~2 minutes. Use `mvn test -pl spector-core` to test a single module during development.
-
----
-
-## 📦 Module Structure
-
-```mermaid
-graph LR
-    subgraph "🔬 Foundation"
-        core["spector-core<br/>SIMD kernels"]
-        commons["spector-commons<br/>Chunkers, readers"]
-        storage["spector-storage<br/>Off-heap stores"]
-    end
-
-    subgraph "📊 Search"
-        index["spector-index<br/>HNSW, IVF-PQ, BM25"]
-        query["spector-query<br/>Hybrid + RRF"]
-    end
-
-    subgraph "🧠 Intelligence"
-        embedapi["spector-embed-api<br/>Embedding SPI"]
-        embedollama["spector-embed-ollama<br/>Ollama provider"]
-        gpu["spector-gpu<br/>CUDA via Panama"]
-    end
-
-    subgraph "⚡ Applications"
-        engine["spector-engine<br/>Unified facade"]
-        server["spector-node<br/>REST API"]
-        cluster["spector-node<br/>Distributed gRPC"]
-        cli["spector-cli<br/>CLI tool"]
-        client["spector-client<br/>Java SDK"]
-        spring["spector-spring<br/>Spring AI"]
-    end
-
-    subgraph "📈 Quality"
-        bench["spector-bench<br/>JMH benchmarks"]
-    end
-```
-
----
-
-## 🧪 Running Tests
-
-```bash
-# Full suite
-mvn test
-
-# Single module
-mvn test -pl spector-core
-
-# Single test class
-mvn test -pl spector-core -Dtest=DotProductTest
-
-# With JMH benchmarks
-mvn -pl spector-bench exec:java
-```
-
----
-
-## 📝 Code Style
-
-### Java Conventions
-
-| Rule | Details |
-|------|---------|
-| **Java 25 features** | Records, sealed classes, pattern matching, switch expressions |
-| **Vector API** | Always use `FloatVector.SPECIES_PREFERRED`, never hardcode lanes |
-| **Panama FFM** | `Arena.ofShared()` for concurrent, `Arena.ofConfined()` for single-thread |
-| **Virtual Threads** | `ReentrantLock` instead of `synchronized` (avoids pinning) |
-| **Testing** | JUnit 5 + AssertJ for all new features |
-| **Javadoc** | Required on all public classes and methods |
-
-### ⚡ Performance Rules
-
-- **No allocations in hot paths** — Reuse buffers, use slice-based APIs
-
-- **Branchless SIMD** — Use `VectorMask` for tail handling, no scalar fallback
-
-- **Benchmark before/after** — Performance PRs must include JMH results
-
-### 🏗️ Architecture Rules
-
-- **Respect module boundaries** — Follow the dependency graph, no circular dependencies
-
-- **Interface-first** — Add interfaces before implementations
-
-- **Zero-copy** — Prefer `MemorySegment` slices over array copies
-
----
-
-## 🌿 Branch Naming
-
-```
-feat/add-quantization-support
-fix/hnsw-concurrent-insert-race
-perf/simd-avx512-unroll-loop
-refactor/storage-arena-lifecycle
-docs/api-usage-examples
-```
-
----
-
-## 💬 Commit Messages
-
-Follow [Conventional Commits](https://www.conventionalcommits.org/):
-
-```
-feat(core): add AVX-512 double-pump dot product kernel
-fix(index): prevent HNSW neighbor list corruption under concurrent insert
-perf(storage): use bulk MemorySegment.copy for vector reads
-refactor(query): extract RRF into standalone utility class
-docs: add benchmark results to README
-test(index): add property tests for HNSW persistence round-trip
-```
-
-| Type | Purpose |
-|------|---------|
-| `feat` | New feature |
-| `fix` | Bug fix |
-| `perf` | Performance improvement |
-| `refactor` | Code restructuring (no behavior change) |
-| `docs` | Documentation only |
-| `test` | Adding or updating tests |
-| `chore` | Build, CI, tooling changes |
-
----
-
-## ✅ Testing Requirements
-
-All new features require tests. The project uses:
-
-| Framework | Purpose |
-|-----------|---------|
-| **JUnit 5** | Unit tests |
-| **AssertJ** | Fluent assertions |
-| **jqwik** | Property-based tests |
-| **JMH** | Performance benchmarks |
-
-### Test Categories
-
-| Type | When Required | Location |
-|------|---------------|----------|
-| Unit tests | All changes | `src/test/java/` in each module |
-| Property tests | Algorithm changes | `src/test/java/` with `@Property` |
-| Integration tests | Cross-module changes | `spector-engine/src/test/` |
-| Benchmarks | Performance PRs | `spector-bench/src/main/` |
-
-### Property-Based Tests Example
-
-```java
-@Property(tries = 100)
-void hnswPersistenceRoundTrip(@ForAll @Size(min=10, max=1000) List<float[]> vectors) {
-    // Build index, persist, reload, verify identical search results
-}
-```
-
----
-
-## 🔄 Pull Request Process
-
-1. **Create a branch** from `main` with appropriate naming
-2. **Make changes** with tests
-3. **Ensure all tests pass** — `mvn test`
-4. **Fill out the PR template**
-5. **Link related issues** — `Closes #123` or `Fixes #456`
-6. **One approval required** from a maintainer
-7. **Squash merge** to keep history clean
-
-### ✅ PR Checklist
-
-- [ ] Code follows the project's coding standards
-
-- [ ] Tests added/updated for the change
-
-- [ ] Javadoc updated for public API changes
-
-- [ ] No hardcoded secrets or credentials
-
-- [ ] Commit messages follow Conventional Commits
-
-- [ ] JMH benchmarks included (if performance-related)
-
-- [ ] No circular module dependencies introduced
-
----
-
-## 🐛 Reporting Issues
-
-### Bug Reports
-
-Use the [Bug Report template](https://github.com/spectrayan/spector/issues/new?template=bug_report.md):
-
-- Steps to reproduce
-
-- Expected vs actual behavior
-
-- JDK version and SIMD capability output
-
-- Relevant logs or stack traces
-
-### 💡 Feature Requests
-
-Use the [Feature Request template](https://github.com/spectrayan/spector/issues/new?template=feature_request.md):
-
-- Problem you're solving
-
-- Proposed solution
-
-- Alternatives considered
-
----
-
-## 💬 Getting Help
-
-| Channel | Use For |
-|---------|---------|
-| [GitHub Discussions](https://github.com/spectrayan/spector/discussions) | General questions |
-| [GitHub Issues](https://github.com/spectrayan/spector/issues) | Bug reports |
-| [SECURITY.md](https://github.com/spectrayan/spector/blob/main/SECURITY.md) | Security vulnerabilities |
-| developer@spectrayan.com | Direct contact |
-
----
-
-## 🔗 See Also
-
-- [Architecture Overview](../architecture/overview.md) — System design
-
-- [Core Concepts](../architecture/core-concepts.md) — Algorithms and data structures
-
-- [Performance Tuning](performance-tuning.md) — Benchmark methodology
\ No newline at end of file
diff --git a/docs/docs/operations/performance-tuning.md b/docs/docs/operations/performance-tuning.md
deleted file mode 100644
index 44d05f2..0000000
--- a/docs/docs/operations/performance-tuning.md
+++ /dev/null
@@ -1,308 +0,0 @@
-# 🏎️ Performance Tuning
-
-> **Spector delivers sub-millisecond latency out of the box — but there's always room to optimize for your specific workload.** This page covers benchmarks, tuning strategies, and the science of finding the right recall/latency/memory trade-off.
-
----
-
-## 📊 Benchmark Summary
-
-> All benchmarks measured on a 24-core x86 machine (Windows 11, Intel Core Ultra 9 285K), AVX2 256-bit, Java 25, ZGC, using clustered vectors (realistic distribution). Numbers represent actual measured results — run `mvn -pl spector-bench exec:java` to reproduce on your hardware.
-
-> [!NOTE]
-> **Methodology:** Benchmarks use 200 measurement iterations with 50 warmup iterations per scenario. Vectors are generated with realistic cluster structure (50 clusters with Gaussian noise). Documents contain 200–1500 words with paragraph structure. Recall is measured against brute-force ground truth. Your results may vary ±20% depending on CPU model, OS scheduling, background load, and thermal throttling.
-
-### ⚡ SIMD Kernel Latency
-
-| Dimension | Cosine P50 | Cosine P99 | Dot Product P50 | Dot Product P99 |
-|-----------|-----------|-----------|----------------|----------------|
-| 32 | 500 ns | 1,500 ns | 200 ns | 400 ns |
-| 128 | <100 ns | 100 ns | 100 ns | 1,300 ns |
-| 384 | ~100 ns | 100 ns | ~100 ns | 100 ns |
-| 768 | ~100 ns | 100 ns | ~100 ns | 100 ns |
-
-> [!NOTE]
-> Values at 384+ are at `System.nanoTime()` resolution floor. JMH confirms millions of ops/sec.
-
-### 🔍 Search Latency (128-dim, top-10, clustered vectors)
-
-| Scale | Keyword (BM25) | Vector (HNSW) | Hybrid (RRF) |
-|-------|---------------|---------------|--------------|
-| **10K docs** | 0.19 ms / 3.79 ms p99 | **0.05 ms** / 0.10 ms p99 | 0.17 ms / 0.37 ms p99 |
-| **50K docs** | 0.42 ms / 0.68 ms p99 | **0.09 ms** / 0.19 ms p99 | 0.50 ms / 0.81 ms p99 |
-| **100K docs** | 0.98 ms / 1.39 ms p99 | **0.13 ms** / 0.26 ms p99 | 1.01 ms / 1.22 ms p99 |
-
-### 🚀 Search Throughput (queries/sec)
-
-| Scale | Keyword | Vector | Hybrid |
-|-------|---------|--------|--------|
-| 10K | 5,194 | **18,824** | 5,828 |
-| 50K | 2,406 | **10,980** | 1,988 |
-| 100K | 1,019 | **7,556** | 994 |
-
-### 📥 Ingestion Throughput
-
-| Dataset Size | Time | Rate | Memory |
-|-------------|------|------|--------|
-| 10K | 2.5s | **3,931 docs/s** | +19 MB |
-| 50K | 15.1s | **3,308 docs/s** | +93 MB |
-| 100K | 38.2s | **2,618 docs/s** | +187 MB |
-
-### 🧵 Concurrency Scaling (50K docs, 384-dim, Hybrid Search)
-
-| Threads | Throughput | Avg Latency | Scaling Factor |
-|---------|-----------|-------------|----------------|
-| 1 | 3,739 ops/s | 0.26 ms | 1.0× |
-| 4 | 10,317 ops/s | 0.37 ms | **2.8×** |
-| 8 | 11,812 ops/s | 0.58 ms | **3.2×** |
-| 16 | 14,022 ops/s | 1.00 ms | **3.7×** |
-
-> [!NOTE]
-> Concurrency scaling is measured with 384-dim vectors (production-realistic). 128-dim shows higher absolute throughput but the scaling factor is similar. Individual HNSW queries are sequential — scaling comes from serving multiple queries concurrently.
-
----
-
-## 🧪 Running Benchmarks
-
-### Full Benchmark Suite
-
-```bash
-mvn -pl spector-bench exec:java
-```
-
-> [!TIP]
-> Generates an HTML report at `spector-bench/target/performance-report.html`
-
-### Specific Benchmarks
-
-```bash
-# SIMD kernels only
-mvn -pl spector-bench exec:java -Dexec.args="SimdKernelBenchmark"
-
-# HNSW index operations
-mvn -pl spector-bench exec:java -Dexec.args="HnswBenchmark"
-
-# Concurrency scaling
-mvn -pl spector-bench exec:java -Dexec.args="ConcurrencyBenchmark"
-```
-
-### JSON Output for CI
-
-```bash
-mvn -pl spector-bench exec:java -Dexec.args="-rf json -rff results.json"
-```
-
-### 📏 Baseline Regression Detection
-
-```bash
-# Generate baseline
-mvn -pl spector-bench exec:java -Dexec.args="--baseline"
-
-# Compare against baseline
-mvn -pl spector-bench exec:java -Dexec.args="--compare"
-```
-
----
-
-## 🎛️ Tuning Strategies
-
-### 🎯 Maximize Recall
-
-Goal: recall@10 ≥ 95%
-
-```java
-var config = SpectorConfig.DEFAULT
-    .withM(32)                  // More connections
-    .withEfConstruction(400)    // Better graph quality
-    .withEfSearch(200);         // Wider search beam
-```
-
-Trade-offs: 2× memory, ~3× build time, ~2× query latency.
-
----
-
-### ⚡ Minimize Latency
-
-Goal: p99 < 0.5ms
-
-```java
-var config = SpectorConfig.DEFAULT
-    .withM(12)
-    .withEfConstruction(100)
-    .withEfSearch(30);
-```
-
-Trade-offs: Lower recall (~80% recall@10), but sub-millisecond guaranteed.
-
----
-
-### 🚀 Maximize Throughput
-
-Goal: Maximum queries/sec under concurrent load
-
-```java
-var config = SpectorConfig.DEFAULT
-    .withM(16)               // Balanced
-    .withEfSearch(50)        // Not too high
-    .withGpu(true);          // Batch processing
-```
-
-Key factors:
-
-- Virtual threads handle concurrency automatically
-
-- Keep `efSearch` moderate to reduce per-query work
-
-- Enable GPU for batch workloads
-
-- Use IVF-PQ for large datasets (reduced memory = better cache behavior)
-
----
-
-### 💾 Minimize Memory
-
-Goal: Fit large datasets in limited RAM
-
-```java
-var config = SpectorConfig.DEFAULT
-    .withM(8)                // Fewer connections
-    .withEfConstruction(100);
-// Use IVF-PQ for 32× vector compression
-```
-
-**Memory per document (384-dim):**
-
-| Mode | Per Vector | 1M vectors |
-|------|-----------|------------|
-| Float32 | ~1.8 KB | ~1.8 GB |
-| INT8 | ~640 bytes | ~640 MB |
-| IVF-PQ | ~288 bytes | ~288 MB |
-
----
-
-## 📈 Parameter Tuning Guide
-
-### HNSW: efSearch vs Recall vs Latency
-
-> [!NOTE]
-> Recall values below are measured with uniform random vectors (best case). Real embedding distributions with cluster structure may show lower recall at the same efSearch — increase efSearch to 100–200 for production workloads with real embeddings.
-
-| efSearch | Recall@10 (random) | Recall@10 (clustered) | Avg Latency | Notes |
-|----------|-----------|-----------|-------------|-------|
-| 10 | ~70% | ~30-40% | 0.02 ms | Too low for most uses |
-| 30 | ~85% | ~50-60% | 0.03 ms | Fast, moderate recall |
-| **64** | **~90%** | **~50-65%** | **0.05 ms** | **Default** |
-| 100 | ~95% | ~70-80% | 0.10 ms | Good for production |
-| 200 | ~98% | ~85-90% | 0.20 ms | High recall |
-| 500 | ~99.5% | ~95%+ | 0.50 ms | Near-perfect |
-
-### IVF-PQ: nprobe vs Recall
-
-| nprobe | Recall@10 | Relative Latency |
-|--------|-----------|-----------------|
-| 1 | ~40% | 1× |
-| 4 | ~70% | 4× |
-| 8 | ~85% | 8× |
-| 16 | ~92% | 16× |
-| 32 | ~97% | 32× |
-
-### SpectorIndex (IVF-HNSW-SVASQ): nCentroids vs nProbe
-
-SpectorIndex uses IVF partitioning with adaptive HNSW shards. The two key parameters are:
-
-- **`nCentroids`** — number of K-Means partitions (set at training time)
-- **`nProbe`** — number of partitions searched at query time (adjustable)
-
-**Rule of thumb:** `nCentroids ≈ √N` (square root of dataset size).
-
-**Real embedding results (Qwen3-embedding, 4096-dim, 10K vectors):**
-
-| nCentroids | nProbe | % Data Searched | Avg Latency | QPS | Recall@10 |
-|------------|--------|-----------------|-------------|-----|-----------|
-| **128** | **4** | **3.1%** | **0.46ms** | **2,173** | **1.0000** |
-| 128 | 8 | 6.3% | 0.73ms | 1,368 | 1.0000 |
-| 128 | 16 | 12.5% | 1.26ms | 792 | 1.0000 |
-| 64 | 4 | 6.3% | 0.62ms | 1,601 | 1.0000 |
-| 64 | 8 | 12.5% | 1.17ms | 856 | 1.0000 |
-| 32 | 4 | 12.5% | 1.17ms | 857 | 1.0000 |
-
-> [!TIP]
-> With real embeddings (not random vectors), SpectorIndex achieves **perfect recall at nProbe=4** because real embeddings form natural semantic clusters that K-Means captures effectively. Start with `nProbe=4` and only increase if your recall target isn't met.
-
-> [!NOTE]
-> For the complete, empirical sweeps across multiple partition configurations ($C \in \{32, 64, 128, 256\}$) and detailed HNSW shard promotion benchmarks, see the dedicated [Large-Scale Benchmarks deep dive](../deep-dives/real-embedding-benchmarks.md).
-
-**Ingestion throughput** (SpectorIndex vs standalone HNSW):
-
-| Dataset Size | SpectorIndex | Standalone HNSW | Speedup |
-|-------------|-------------|-----------------|---------|
-| 10K | 130K docs/s | 4,677 docs/s | **28×** |
-| 50K | 140K docs/s | 2,483 docs/s | **56×** |
-| 100K | 150K docs/s | 1,535 docs/s | **98×** |
-| 500K | 246K docs/s | — | — |
-| 1M | 128K docs/s | — | — |
-
----
-
-## 📐 Scaling Strategies
-
-### ⬆️ Vertical Scaling
-
-- **Add CPU cores** → Concurrent throughput scaling (up to ~3.7× at 16 threads measured)
-
-- **Add RAM** → Support larger capacity without IVF-PQ compression
-
-- **Add GPU** → 4× brute-force search speedup at 100K+ vectors (data resident in VRAM)
-
-### ➡️ Horizontal Scaling (Distributed Mode)
-
-- **Add nodes** → Linear throughput scaling per shard
-
-- Rule of thumb: 100K–500K docs per shard
-
-- See [Distributed Mode](../architecture/distributed-mode.md) for cluster setup
-
----
-
-## ☕ JVM Tuning
-
-Recommended JVM arguments for production:
-
-```bash
-java \
-  --add-modules jdk.incubator.vector \
-  --enable-native-access=ALL-UNNAMED \
-  -XX:+UseZGC \
-  -XX:+ZGenerational \
-  -Xmx4g \
-  -Xms4g \
-  -jar spector-node.jar
-```
-
-| Argument | Purpose |
-|----------|---------|
-| `--add-modules jdk.incubator.vector` | Required for SIMD acceleration |
-| `--enable-native-access=ALL-UNNAMED` | Required for Panama FFM (GPU, mmap) |
-| `-XX:+UseZGC` | Low-pause GC (vectors are off-heap) |
-| `-XX:+ZGenerational` | Generational ZGC for better throughput |
-| `-Xmx4g -Xms4g` | Fixed heap avoids resize pauses |
-
-> [!TIP]
-> Since all vectors live off-heap, GC pressure is minimal. The heap primarily holds the HNSW graph structure and BM25 inverted index.
-
----
-
-## 🔗 See Also
-
-- [Configuration Guide](../configuration/parameters.md) — All parameters with ranges
-
-- [Core Concepts](../architecture/core-concepts.md) — How algorithms affect performance
-
-- [SpectorIndex Architecture](../deep-dives/spector-index-architecture.md) — IVF-HNSW-SVASQ design and tuning
-
-- [Large-Scale Benchmarks](../deep-dives/real-embedding-benchmarks.md) — Empirical sweeps for real embeddings and shard promotions
-
-- [SVASQ Quantization](../deep-dives/svasq-deep-dive.md) — How SVASQ compression works
-
-- [GPU Acceleration](../architecture/gpu-acceleration.md) — GPU-specific performance
-
-- [Distributed Mode](../architecture/distributed-mode.md) — Scaling across nodes
\ No newline at end of file
diff --git a/docs/docs/roadmap.md b/docs/docs/roadmap.md
deleted file mode 100644
index 656c7d1..0000000
--- a/docs/docs/roadmap.md
+++ /dev/null
@@ -1,472 +0,0 @@
-# 🗺️ Roadmap
-
-Spector is under active development. This page details planned improvements, their projected impact, and implementation status.
-
----
-
-## Compression & Quantization
-
-### ✅ SVASQ-4 — Half-Precision SVASQ (INT4 Codes) {#svasq-4}
-
-!!! success "Completed"
-    Implemented and merged. Available via `SpectorEngine.builder().svasq4()` or `QuantizedHnswIndex.svasq4(...)`.
-
-Replace INT8 `[-127, 127]` codes with INT4 `[-7, 7]` codes in the SVASQ pipeline. The FWHT rotation still equalizes variance, so INT4 quantization error remains uniformly distributed — just at a coarser granularity (15 levels vs 255).
-
-**Memory layout:**
-```
-[float32 normSq (4 bytes)] [INT4 × paddedDim nibble-packed (paddedDim/2 bytes)]
-```
-
-| Dims | Current SVASQ-8 | SVASQ-4 | Compression vs float32 |
-|------|---------------|--------|----------------------|
-| 384 → 512 | 516 B | 260 B | **5.9×** |
-| 768 → 1024 | 1028 B | 516 B | **6.0×** |
-| 4096 | 4100 B | 2052 B | **8.0×** |
-
-**Recall:**
-
-- Without rescore: ~95–97% recall@10
-- With 3× oversampling rescore: **~97–99% recall@10**
-
-**Key design decisions:**
-
-- Separate `Svasq4Encoder` / `Svasq4SimdKernel` classes (not parameterizing SVASQ-8) to avoid impacting existing code
-- Offset encoding `[0, 14]` keeps byte values non-negative for correct `castShape` sign extension
-- Deinterleaved hi/lo query arrays match nibble layout for natural SIMD ILP
-- Tighter clipping (2.5σ vs 3.0σ) optimizes for 15 quantization levels
-
----
-
-### 🔜 Padding-Aware Storage — Skip Zero Dimensions {#padding-aware}
-
-!!! info "Status: Planned (next)"
-    Low effort, zero recall loss for L2 distance. Highest ROI pending improvement.
-
-SVASQ pads vectors to the next power-of-two dimensionality (e.g., 768 → 1024), adding wasted bytes. The padded dimensions are zero-filled before FWHT, so their rotated codes are predictable. We can **store only the first `originalDim` codes** and reconstruct padded codes at query time.
-
-| Dims | paddedDim | Current SVASQ-8 | Padding-Aware | Savings |
-|------|-----------|---------------|---------------|---------|
-| 384 | 512 | 516 B | 388 B | **25%** |
-| 768 | 1024 | 1028 B | 772 B | **25%** |
-| 1536 | 2048 | 2052 B | 1540 B | **25%** |
-| 4096 | 4096 | 4100 B | 4100 B | 0% (already pow2) |
-
-**Recall impact:** **None** for L2 distance — padded dimensions contribute a constant offset that doesn't affect ranking.
-
-!!! warning "SIMD Tail Loop"
-    The current SIMD kernel exploits `paddedDim % VL == 0` to avoid tail loops. Storing only `originalDim` codes breaks this, requiring either a scalar tail loop or alignment padding to the next SIMD boundary (e.g., round up to multiple of 16 bytes).
-
-**Changes required:**
-
-- `SvasqEncoder` / `Svasq4Encoder`: Store only `originalDim` codes, update `bytesPerVector()`
-- `SvasqSimdKernel` / `Svasq4SimdKernel`: Handle non-power-of-2 loop bound (SIMD-aligned padding recommended)
-
----
-
-### 🔜 Norm Header Compression — float32 → float16 {#norm-f16}
-
-!!! info "Status: Planned (next)"
-    Very low effort. Negligible recall impact.
-
-The 4-byte `float32 exactNormSq` header can be compressed to 2 bytes using `float16` (half-precision). Java 21+ provides `Float.floatToFloat16()` and `Float.float16ToFloat()` for lossless conversion.
-
-**Savings:** 2 bytes per vector. Small absolute savings but trivial to implement.
-
-| Combined with | Before | After | Savings |
-|---------------|--------|-------|---------|
-| SVASQ-8 (768-dim) | 1028 B | 1026 B | 0.2% |
-| SVASQ-4 (768-dim) | 516 B | 514 B | 0.4% |
-| Padding-aware SVASQ-8 (768-dim) | 772 B | 770 B | 0.3% |
-
-**Recall impact:** < 0.01% — `float16` has ~3 decimal digits of precision. For L2 ranking, the norm header is a per-vector constant that shifts all distances equally.
-
-**Changes required:**
-
-- `SvasqEncoder` / `Svasq4Encoder`: Use `Float.floatToFloat16()` for 2-byte header write
-- `SvasqSimdKernel` / `Svasq4SimdKernel`: Read with `Float.float16ToFloat(segment.get(JAVA_SHORT, offset))`
-
----
-
-### 🔬 SVASQ-PQ Hybrid — Product Quantization of SVASQ Residuals {#svasq-pq}
-
-!!! note "Status: Future Research"
-    Very high implementation effort. Most aggressive compression option.
-
-After FWHT rotation, instead of scalar INT8/INT4 quantization, apply **Product Quantization** to the rotated coordinates. The FWHT rotation makes coordinates near-independent (isotropized), which is the ideal input distribution for PQ — similar to how Optimized PQ (OPQ) works with learned rotations, but using FWHT instead of an expensive SVD-based rotation matrix.
-
-**Memory layout:**
-```
-[float32 normSq (4 bytes)] [PQ codes: M bytes (one centroid ID per subspace)]
-```
-
-With M=16 subspaces, K=256 centroids:
-
-| Dims | Float32 | SVASQ-8 | SVASQ-PQ (M=16) | Compression vs float32 |
-|------|---------|--------|----------------|----------------------|
-| 768 | 3,072 B | 1,028 B | 20 B | **154×** |
-| 4096 | 16,384 B | 4,100 B | 68 B | **241×** |
-
-**Recall impact:**
-
-- PQ on FWHT-rotated residuals: ~85–93% recall@10
-- FWHT rotation gives ~3–5% recall advantage over naive PQ (pre-decorrelates dimensions)
-- Rescore with exact float32 residuals pushes recall to 95%+
-
-**Why it works:** The FWHT rotation is essentially a free, lossless "Optimized PQ" rotation — it decorrelates dimensions without requiring an expensive SVD or learned rotation matrix. This means PQ subspaces can be independent slices of the rotated vector, which is information-theoretically optimal.
-
-**Implementation scope:**
-
-- Train PQ codebooks per shard (or globally after FWHT rotation)
-- Asymmetric Distance Computation (ADC) lookup tables during search
-- New SIMD kernel for PQ distance computation
-- Integration with existing `ProductQuantizer` in `spector-index`
-
-!!! danger "Complexity Warning"
-    This is essentially building a new quantization mode. The existing `ProductQuantizer` could be adapted, but integrating it with the FWHT rotation pipeline is non-trivial. Estimated effort: 2–4 weeks.
-
----
-
-### 🔬 Flat-Mode SVASQ — Compress Flat-Shard Storage {#flat-svasq}
-
-!!! note "Status: Future Research"
-    Medium effort, good payoff for large flat shards.
-
-In `SpectorShard`'s flat mode, residuals are stored as raw `float32[]`. Since all residuals in a shard share the same centroid, they have similar statistical distributions. **SVASQ quantization of flat residuals** could compress flat-mode storage by ~3× without changing the shard architecture.
-
-**Savings:**
-
-| Scenario | Current (float32) | With SVASQ | Savings |
-|----------|-------------------|-----------|---------|
-| 10K vectors × 768 dims | 30 MB/shard | 10 MB/shard | **3×** |
-| 50K vectors × 4096 dims | 781 MB/shard | 195 MB/shard | **4×** |
-
-**Recall impact:**
-
-- If applied only to storage (decode for search): **None** — search uses decoded float32
-- If applied to search (scan quantized codes directly): Same as SVASQ-8 (~99.5%)
-
-**Implementation scope:**
-
-- Integrate SVASQ encoding into the flat-mode ingestion path
-- Modify `SpectorShard.flatScan()` to use the SVASQ SIMD kernel directly
-- Per-shard calibration using the shard's centroid residuals
-
----
-
-### 🔴 Adaptive Bit-Width SVASQ {#adaptive-bw}
-
-!!! warning "Status: Not Recommended"
-    Very high effort, marginal benefit due to FWHT already equalizing variance.
-
-Instead of uniform INT8 across all dimensions, assign more bits to high-variance dimensions and fewer to low-variance ones (after FWHT rotation):
-
-- Dimensions with σ > 2× median: 8 bits
-- Dimensions with σ < 0.5× median: 4 bits
-- Others: 6 bits
-
-**Projected savings:** ~10–15% additional compression.
-
-**Recall impact:** Minimal (< 0.5%) — allocating bits proportionally to variance is information-theoretically optimal.
-
-**Why it's not recommended:** FWHT already equalizes variance by design, so the marginal gain from adaptive bit-widths is small. The implementation requires variable-length encoding, non-aligned SIMD reads, and per-dimension bit-width bookkeeping — the worst effort-to-benefit ratio of all proposed improvements.
-
----
-
-## Agentic AI
-
-### ✅ Native MCP Server {#mcp-server}
-
-!!! success "Completed"
-    Implemented in `spector-mcp` module. 6 tools, stdio transport, agent-native search.
-
-Built-in [Model Context Protocol](https://modelcontextprotocol.io/) server that gives AI agents (Claude Desktop, Cursor, autonomous agents) direct, in-process access to Spector’s search engine. Zero network overhead — tool handlers call `SpectorEngine` directly via virtual threads.
-
-**Tools:** `semantic_search`, `hybrid_search`, `rag_query`, `ingest_document`, `delete_document`, `engine_status`
-
-**Architecture:**
-- `McpToolHandler` abstract base class (common timing, error handling, arg parsing)
-- `ToolSchemaBuilder` fluent JSON schema construction
-- `SpectorToolRegistry` for extensible tool registration
-- `SpectorResourceProvider` + `SpectorPromptProvider` for MCP resources/prompts
-- `ResultFormatter` shared formatting utilities
-
----
-
-### 🔜 Streamable HTTP Transport {#mcp-http}
-
-!!! info "Status: Planned (next)"
-    Stdio covers Claude Desktop, Cursor, and all local agents. HTTP needed for cloud/remote deployments.
-
-Add HTTP-based MCP transport for scenarios where the agent and Spector run on different machines. The official MCP SDK supports Streamable HTTP transport — Spector would expose the same 6 tools over an HTTP endpoint.
-
-**Use cases:** Cloud deployments, remote agent connections, multi-agent architectures.
-
----
-
-### 🔬 LoRA Adapter Routing {#lora-routing}
-
-!!! note "Status: Future Research"
-    Requires LoRA weight format specification and SIMD matrix multiply implementation.
-
-Multi-tenant query projection via SIMD matrix multiply. Instead of creating separate indexes per tenant, store one base index and apply per-tenant LoRA weight matrices at query time using Panama FMA loops.
-
-**How it works:**
-- Ingest base model embeddings once
-- Each tenant uploads a small LoRA matrix ($W_A$, typically 768×32 or similar)
-- At query time: $q_{tenant} = q_{base} \times W_A$ (microseconds via Panama SIMD)
-- Search the same index with the projected query
-
-**Expected impact:** Zero-downtime multi-tenant customization without index duplication.
-
----
-
-### 🔬 ColBERT Late Interaction Reranking {#colbert}
-
-!!! note "Status: Future Research"
-    Requires token-level vector storage and MaxSim SIMD kernel.
-
-Native ColBERT reranking using Panama FMA loops. ColBERT stores a vector for every token in a document, then computes relevance via MaxSim (maximum similarity per query token). Python struggles with this due to GIL contention when routing massive matrices between C++ and Python memory.
-
-**Spector advantage:** Off-heap `MemorySegment` arrays and Fused-Multiply-Add Panama loops can natively execute ColBERT MaxSim reranking faster than almost any competitor.
-
----
-
-## Cognitive Graph Memory
-
-### ✅ 3-Layer Cognitive Graph {#cognitive-graph}
-
-!!! success "Completed"
-    All four phases implemented and merged. 357 tests pass, 0 failures.
-
-Full graph augmentation layer for `spector-memory` — three biologically-inspired graph structures that augment vector recall with associative, temporal, and relational signals.
-
-**Architecture:**
-```
-RecallPipeline
-  Step 5a: Habituation + Inhibition of Return
-  Step 5b: STDP causal boost (CoActivationTracker)
-  Step 5c: Hebbian spreading activation (HebbianGraph, depth=2)
-  Step 5d: Temporal chain extension (TemporalChain, maxHops=3)
-  Step 5e: Entity graph traversal (EntityGraph, 2-hop BFS)
-```
-
-**Layer 1 — Hebbian Association Graph:**
-
-- Off-heap adjacency list (164B/node, MAX_DEGREE=20) via Panama `MemorySegment`
-- Edge strengthening, decay (0.9 factor per consolidation), spreading activation
-- Persistence via `HGPH` magic header, chunked 64KB FileChannel I/O
-- CoActivationTracker migrated to off-heap: `OffHeapPairTable` (32B/slot) + `OffHeapEdgeTable` (40B/slot)
-- Persistence via `COAX` magic header with hash→tag reverse map
-
-**Layer 2 — Entity-Relationship Graph:**
-
-- Off-heap entity store (48B/entity, 16B/edge), BFS traversal with typed edge filtering
-- 22 entity types × 21 relation types
-- `EntityExtractor` SPI with `LlmEntityExtractor` (externalized prompt template) and `NoOpEntityExtractor`
-- Persistence via `ENTG` magic header with nameIndex reconstruction
-
-**Layer 3 — Temporal Causal Chain:**
-
-- Off-heap linked list (16B/node: prevIdx + nextIdx + sessionId + pad)
-- Session-local memory linking at ingestion, forward/backward traversal at recall
-- Persistence via `TPCH` magic header
-
-**Error framework:** 6 error codes (`SPE-310-006..011`), 7 granular exception classes extending `SpectorGraphException`. All catch sites use `catch(RuntimeException)` → create exception → `log(ex.getMessage())`. No string concatenation.
-
-**Each graph step is additive and gracefully degrading** — if the graph is null/empty or the operation throws, the step is a no-op.
-
----
-
-### 🔜 Temporal Chain Pruning {#temporal-pruning}
-
-!!! info "Status: Planned (next)"
-    Low effort. Prevents unbounded temporal chain growth.
-
-Temporal chain links are permanent — unlike Hebbian edges which decay via `decayEdges(0.9f)`, temporal links have no homeostasis mechanism. Old session-local links waste slots indefinitely.
-
-**Design:**
-
-- Add `pruneOlderThan(long cutoffEpochMs)` to `TemporalChain`
-- Replace the `pad:4B` field in the 16B node layout with `epochSec:4B` (seconds since epoch, ~136 year range)
-- Integrate into `DefaultSpectorMemory.reflect()` after Hebbian decay
-- Configurable retention period via Builder: `temporalRetentionDays(int)` (default: 7)
-
-**Effort:** ~0.5 day
-
----
-
-### 🔜 Cross-Layer Promotion (Hebbian → Entity) {#cross-layer-promotion}
-
-!!! info "Status: Planned (next)"
-    Medium effort. Enables automatic knowledge graph construction from statistical patterns.
-
-Promote strong statistical Hebbian associations into explicit entity relations during sleep consolidation — analogous to hippocampal replay.
-
-**Design:**
-
-- During `reflect()`, scan HebbianGraph for edges with `weight ≥ 0.8` AND `activationCount ≥ 5`
-- For each strong edge, look up shared entities via `EntityGraph.memoriesForEntity()`
-- If shared entities exist, strengthen the entity relation edge; if none, create a `RELATED_TO` relation
-- Add `promotionThreshold(float)` and `promotionMinActivations(int)` to Builder config
-- Add `PromotionReport` record for observability: `promotedCount`, `strengthenedCount`, `skippedCount`
-
-**Effort:** ~1-2 days
-
----
-
-### 🔜 Entity Graph Decay + Node Merging {#entity-decay}
-
-!!! info "Status: Planned"
-    Medium effort. Prevents entity graph bloat.
-
-Entity graph edges accumulate without decay. Near-duplicate entities (e.g., "John Smith" and "J. Smith") should be merged during consolidation.
-
-**Design:**
-
-- Add `decayRelations(float factor)` to `EntityGraph` — multiplicative decay, prune below threshold
-- Add `mergeEntities(int sourceId, int targetId)` — redirect all edges and memory links
-- Fuzzy name matching via Levenshtein distance during consolidation
-- Integrate into `reflect()` cycle
-
-**Effort:** ~1-2 days
-
----
-
-### 🔜 Graph-Aware Scoring Weights {#graph-scoring}
-
-!!! info "Status: Planned"
-    Low effort. Highest ROI among remaining graph improvements.
-
-Extract hardcoded graph score attenuation factors into a configurable `GraphScoringPolicy`.
-
-**Current hardcoded values:**
-
-| Factor | Current Value | Used In |
-|---|---|---|
-| Hebbian boost | 0.3f | RecallPipeline Step 5c |
-| Temporal forward | 0.8f | RecallPipeline Step 5d |
-| Temporal backward | 0.7f | RecallPipeline Step 5d |
-| Entity hop attenuation | 0.25f | RecallPipeline Step 5e |
-
-**Design:**
-
-```java
-public record GraphScoringPolicy(
-    float hebbianBoostFactor,     // default 0.3
-    float temporalForwardFactor,  // default 0.8
-    float temporalBackwardFactor, // default 0.7
-    float entityHopAttenuation,   // default 0.25
-    int hebbianMaxDepth,          // default 2
-    int temporalMaxHops,          // default 3
-    int entityMaxHops             // default 2
-) {}
-```
-
-- Configurable via Builder: `graphScoringPolicy(GraphScoringPolicy)`
-- Future: online tuning based on user reinforcement/suppression feedback
-
-**Effort:** ~0.5 day
-
----
-
-## Compute & Hardware
-
-### 🔜 GPU Kernel Dispatch {#gpu-dispatch}
-
-!!! info "Status: Infrastructure Ready"
-    CUDA context management and Panama FFM bridge are implemented. The compute kernel dispatch is pending.
-
-Ship actual CUDA compute kernels for batch cosine similarity and HNSW neighbor selection. The existing `spector-gpu` module provides context management, memory allocation, and kernel loading via Panama FFM — the remaining work is the CUDA kernel code itself.
-
-**Prerequisites:** CUDA Toolkit 12+ on the host machine.
-
-**Expected impact:** 10–100× throughput improvement for batch similarity computation on large datasets (> 100K vectors).
-
----
-
-### 🔬 NPU Acceleration {#npu}
-
-!!! note "Status: Exploratory"
-    Depends on Intel/AMD NPU SDK maturity.
-
-Leverage Intel NPU (via OpenVINO) or AMD XDNA (via DirectML) for INT8 batch operations. NPUs are optimized for low-precision matrix operations, making them ideal for quantized SVASQ distance computation.
-
-**Target workloads:** INT8/INT4 batch similarity, SVASQ kernel offload.
-
----
-
-## Runtime & Deployment
-
-### 🔬 WASM Runtime for Edge Deployment {#wasm}
-
-!!! note "Status: Exploratory"
-    Depends on GraalWasm or Chicory maturity for JVM → WASM compilation.
-
-Compile the core SIMD kernels and HNSW index to WebAssembly for browser-based or edge deployment. This would enable client-side semantic search without a server round-trip.
-
----
-
-### 🔬 Project Valhalla Value Classes {#valhalla}
-
-!!! note "Status: Future Research"
-    Exploratory evaluation of JEP 401 (Value Classes and Objects). Requires Project Valhalla Early-Access builds.
-
-Migrate hot-path intermediate records (e.g., `CognitiveResult`, candidate pairs, search options) to `value class` (or `value record`). This will allow the JVM JIT compiler to perform aggressive scalar replacement and store value arrays contiguously in memory, eliminating garbage collection overhead and pointer-chasing latency during HNSW index traversals.
-
-**Benefits:**
-- **Zero-GC Hot Path**: Short-lived search results and option records are stack-allocated, avoiding the JVM heap.
-- **Cache Locality**: Contiguous storage of value structures inside arrays prevents pointer chasing.
-- **Header Elimination**: Removes standard 12-to-16-byte JVM object headers for inline arrays.
-
----
-
-### ✅ Structured Concurrency (JEP 505) {#structured-concurrency}
-
-!!! success "Completed"
-    Implemented via `ConcurrentTasks` in `spector-commons`. Dual-mode: structured concurrency (default) with classic `ExecutorService` fallback via `-Dspector.concurrency.structured=false`.
-
-Migrated all 6 concurrency sites from unstructured `ExecutorService` + `Future` to the JEP 505 `StructuredTaskScope` API, centralized in `ConcurrentTasks`:
-
-| Site | Module | Pattern | Benefit |
-|------|--------|---------|---------|
-| `HybridSearchOrchestrator` | spector-query | 2-way fan-out (keyword ∥ vector) | Auto-cancel sibling on failure |
-| `ClusterCoordinator` | spector-node | N-way shard fan-out | Auto-cancel all on shard failure |
-| `DistributedQueryCoordinator` | spector-node | N-way with timeout + partial results | Clean timeout via `awaitAll()` + `withTimeout()` |
-| `ParallelEmbeddingPipeline` | spector-embed-api | N-way batch embedding | Scope-per-call, no executor lifecycle |
-| `ParallelPqTrainer` | spector-index | M-way K-Means subspace training | All-or-nothing structured scope |
-| `BM25Index` | spector-index | Parallel term scoring | Auto-cancel with sequential fallback |
-
-**Key design decisions:**
-
-- Centralized in `ConcurrentTasks` (spector-commons) for single-point updates when JEP finalizes
-- Feature flag: `-Dspector.concurrency.structured=false` for fallback to classic virtual threads
-- `forkJoinAll()`: all-or-nothing with auto-cancel (uses `awaitAllSuccessfulOrThrow` Joiner)
-- `forkJoinPartial()`: deadline-based with `LabeledTask`/`PartialResult` records (uses `awaitAll` Joiner + `Configuration.withTimeout()`)
-
----
-
-## Summary Table
-
-| # | Improvement | Category | Effort | Status |
-|---|------------|----------|--------|--------|
-| 1 | **SVASQ-4** | Compression | Medium | ✅ Done |
-| 2 | **Native MCP Server** | Agentic AI | Medium | ✅ Done |
-| 3 | **3-Layer Cognitive Graph** | Graph Memory | High | ✅ Done |
-| 4 | **Structured Concurrency** | Runtime | Low | ✅ Done |
-| 5 | **Padding-aware storage** | Compression | Low | 🔜 Next |
-| 6 | **Norm header f16** | Compression | Very Low | 🔜 Next |
-| 7 | **Temporal chain pruning** | Graph Memory | Low | 🔜 Next |
-| 8 | **Cross-layer promotion** | Graph Memory | Medium | 🔜 Planned |
-| 9 | **Entity graph decay + merging** | Graph Memory | Medium | 🔜 Planned |
-| 10 | **Graph scoring weights** | Graph Memory | Low | 🔜 Planned |
-| 11 | **Streamable HTTP transport** | Agentic AI | Medium | 🔜 Planned |
-| 12 | **GPU kernel dispatch** | Compute | Medium | 🔜 Infra ready |
-| 13 | **SVASQ-PQ hybrid** | Compression | Very High | 🔬 Research |
-| 14 | **Flat-mode SVASQ** | Compression | Medium | 🔬 Research |
-| 15 | **LoRA adapter routing** | Agentic AI | High | 🔬 Research |
-| 16 | **ColBERT late interaction** | Agentic AI | High | 🔬 Research |
-| 17 | **NPU acceleration** | Compute | High | 🔬 Exploratory |
-| 18 | **WASM edge runtime** | Runtime | High | 🔬 Exploratory |
-| 19 | **Project Valhalla** | Runtime | Medium | 🔬 Research |
-| 20 | **Adaptive bit-width** | Compression | Very High | 🔴 Not planned |
diff --git a/docs/docs/sdk-usage/java-client.md b/docs/docs/sdk-usage/java-client.md
index c6e9298..44a84d8 100644
--- a/docs/docs/sdk-usage/java-client.md
+++ b/docs/docs/sdk-usage/java-client.md
@@ -1,12 +1,10 @@
-# ☕ Java SDK Guide
+# Java Client SDK
 
-> **Type-safe, thread-safe Java access to Spector — as a remote client or embedded engine.** Whether you're connecting to a server or embedding search directly in your application, this guide covers everything you need.
+The `spector-client` module provides a type-safe Java client for interacting with a Spector Search server.
 
----
+## Installation
 
-## 📦 Installation
-
-**Remote client** (connects to a running server):
+Add the dependency to your `pom.xml`:
 
 ```xml
 <dependency>
@@ -16,271 +14,109 @@
 </dependency>
 ```
 
-**Embedded engine** (in-process, zero network overhead):
-
-```xml
-<dependency>
-    <groupId>com.spectrayan</groupId>
-    <artifactId>spector-engine</artifactId>
-    <version>1.0-SNAPSHOT</version>
-</dependency>
-```
-
-> [!TIP]
-> Choose **embedded** for maximum performance (zero latency overhead). Choose **client** when you want a shared server across multiple services.
-
----
-
-## 🌐 Client SDK (Remote Server)
+## Creating a Client
 
-### 🔧 Creating a Client
+Use the builder pattern to configure the client:
 
 ```java
-import com.spectrayan.spector.client.SpectorClient;
-
 SpectorClient client = SpectorClient.builder()
     .host("localhost")
     .port(7070)
-    .apiKey("my-secret-key")       // optional
-    .connectTimeout(Duration.ofSeconds(10))
-    .requestTimeout(Duration.ofSeconds(30))
-    .maxConnections(10)
+    .apiKey("my-secret-key")  // optional
     .build();
 ```
 
-**Configuration Options:**
-
-| Option | Default | Description |
-|--------|---------|-------------|
-| `host` | localhost | Server hostname |
-| `port` | 7070 | Server port |
-| `apiKey` | — | API key for authentication |
-| `connectTimeout` | 10s | Connection timeout |
-| `requestTimeout` | 30s | Per-request timeout |
-| `maxConnections` | 10 | HTTP connection pool size |
-
-> [!NOTE]
-> `SpectorClient` is fully **thread-safe**. It uses Java's `HttpClient` with internal connection pooling. Share a single instance across all threads.
-
----
+## Runnable SDK Example
 
-### 📥 Ingesting Documents
+This complete example demonstrates the full lifecycle — ingest, search, and delete:
 
 ```java
-// Single document
-IngestResponse response = client.ingest(IngestRequest.builder()
-    .id("doc-1")
-    .title("Java Vector API")
-    .content("SIMD-accelerated search engine built on modern JVM")
-    .vector(new float[]{0.1f, 0.2f, 0.3f, 0.4f, 0.5f})
-    .build());
-
-System.out.println("Indexed: " + response.id());
-```
-
-```java
-// Bulk ingest
-List<IngestRequest> documents = List.of(
-    IngestRequest.builder().id("d1").content("first doc").vector(vec1).build(),
-    IngestRequest.builder().id("d2").content("second doc").vector(vec2).build(),
-    IngestRequest.builder().id("d3").content("third doc").vector(vec3).build()
-);
-
-IngestResponse bulkResponse = client.bulkIngest(documents);
-```
+import com.spectrayan.spector.client.SpectorClient;
+import com.spectrayan.spector.client.model.*;
 
----
+public class SpectorClientExample {
+    public static void main(String[] args) throws Exception {
+        // 1. Create client
+        try (SpectorClient client = SpectorClient.builder()
+                .host("localhost")
+                .port(7070)
+                .build()) {
 
-### 🔍 Searching
+            // 2. Ingest a document
+            IngestResponse ingestResp = client.ingest(IngestRequest.builder()
+                .id("sdk-doc-1")
+                .title("Vector Search")
+                .content("Spector uses HNSW for approximate nearest neighbor search")
+                .vector(new float[]{0.1f, 0.2f, 0.3f, 0.4f, 0.5f})
+                .build());
+            System.out.println("Ingested: " + ingestResp.id());
 
-```java
-// Keyword search
-SearchResponse results = client.search(SearchRequest.builder()
-    .text("vector search engine")
-    .topK(10)
-    .build());
+            // 3. Search
+            SearchResponse searchResp = client.search(SearchRequest.builder()
+                .text("nearest neighbor")
+                .topK(5)
+                .build());
+            for (SearchResponse.Result result : searchResp.results()) {
+                System.out.printf("  %s → %.4f%n", result.id(), result.score());
+            }
 
-// Vector search
-SearchResponse results = client.search(SearchRequest.builder()
-    .vector(queryEmbedding)
-    .topK(10)
-    .build());
+            // 4. Check status
+            StatusResponse status = client.status();
+            System.out.println("Engine status: " + status.status());
 
-// Hybrid search (both text and vector)
-SearchResponse results = client.search(SearchRequest.builder()
-    .text("search engine")
-    .vector(queryEmbedding)
-    .topK(10)
-    .build());
+            // 5. Get metrics
+            MetricsResponse metrics = client.metrics();
+            System.out.println("Total queries: " + metrics.totalQueries());
 
-// Process results
-for (SearchResponse.Result result : results.results()) {
-    System.out.printf("%s (%.4f): %s%n",
-        result.id(), result.score(), result.content());
+            // 6. Delete
+            client.delete("sdk-doc-1");
+            System.out.println("Deleted sdk-doc-1");
+        }
+    }
 }
 ```
 
----
-
-### 🗑️ Deleting Documents
+## Bulk Ingestion
 
 ```java
-client.delete("doc-1");
+List<IngestRequest> docs = List.of(
+    IngestRequest.builder().id("d1").content("first").vector(vec1).build(),
+    IngestRequest.builder().id("d2").content("second").vector(vec2).build()
+);
+IngestResponse resp = client.bulkIngest(docs);
 ```
 
-### 📊 Status and Metrics
+## Error Handling
 
-```java
-StatusResponse status = client.status();
-System.out.println("Documents: " + status.documentCount());
-System.out.println("SIMD: " + status.simd());
+The SDK throws typed exceptions:
 
-MetricsResponse metrics = client.metrics();
-System.out.println("QPS: " + metrics.queriesPerSecond());
-```
-
----
-
-### ⚠️ Error Handling
+| Exception | Cause |
+|-----------|-------|
+| `SpectorConnectionException` | Server unreachable |
+| `SpectorApiException` | HTTP 4xx/5xx response |
+| `SpectorTimeoutException` | Request timeout exceeded |
 
 ```java
 try {
     client.search(request);
 } catch (SpectorApiException e) {
-    // HTTP 4xx/5xx from server
     System.err.println("HTTP " + e.statusCode() + ": " + e.message());
 } catch (SpectorConnectionException e) {
-    // Server unreachable
     System.err.println("Cannot connect to " + e.endpoint());
-} catch (SpectorTimeoutException e) {
-    // Request timed out
-    System.err.println("Timeout after " + e.timeout());
-}
-```
-
-### ♻️ Resource Management
-
-The client implements `AutoCloseable`:
-
-```java
-try (SpectorClient client = SpectorClient.builder().build()) {
-    // Use client...
-} // Connections released automatically
-```
-
----
-
-## ⚡ SpectorEngine (Embedded Usage)
-
-For applications that want in-process search without network overhead:
-
-### 🔧 Creating an Engine
-
-```java
-import com.spectrayan.spector.engine.SpectorEngine;
-import com.spectrayan.spector.engine.SpectorConfig;
-
-var config = SpectorConfig.DEFAULT
-    .withDimensions(384)
-    .withCapacity(100_000)
-    .withSimilarityFunction(SimilarityFunction.COSINE)
-    .withGpu(true)                                           // optional GPU
-    .withReranker("http://localhost:11434", "llama3.2", 20); // optional LLM
-
-try (var engine = new SpectorEngine(config)) {
-    // Engine is ready — sub-millisecond search, zero network overhead
-}
-```
-
-### 📥 Ingesting
-
-```java
-// With pre-computed vector
-engine.ingest("doc-1", "Document content here", embedding);
-// The engine handles BM25 indexing, HNSW insertion, and storage automatically
-```
-
-### 🔍 Searching
-
-```java
-// Hybrid search (keyword + vector)
-SearchResponse response = engine.hybridSearch("search query", queryVector, 10);
-
-// Keyword-only
-SearchResponse response = engine.keywordSearch("exact phrase", 10);
-
-// Vector-only
-SearchResponse response = engine.vectorSearch(queryVector, 10);
-
-// Process results
-for (ScoredResult result : response.results()) {
-    System.out.printf("%s → %.4f%n", result.id(), result.score());
-}
-```
-
-### 🗑️ Deleting
-
-```java
-engine.delete("doc-1");
-```
-
----
-
-## 🎯 Complete Example
-
-```java
-import com.spectrayan.spector.client.SpectorClient;
-import com.spectrayan.spector.client.model.*;
-
-public class SpectorExample {
-    public static void main(String[] args) throws Exception {
-        try (SpectorClient client = SpectorClient.builder()
-                .host("localhost")
-                .port(7070)
-                .build()) {
-
-            // Ingest documents
-            client.ingest(IngestRequest.builder()
-                .id("java-1")
-                .title("Virtual Threads")
-                .content("Java virtual threads enable millions of concurrent tasks")
-                .vector(new float[]{0.9f, 0.1f, 0.3f, 0.7f, 0.5f})
-                .build());
-
-            client.ingest(IngestRequest.builder()
-                .id("java-2")
-                .title("Vector API")
-                .content("The Vector API provides SIMD acceleration for math operations")
-                .vector(new float[]{0.2f, 0.8f, 0.4f, 0.1f, 0.6f})
-                .build());
-
-            // Search
-            SearchResponse results = client.search(SearchRequest.builder()
-                .text("SIMD acceleration")
-                .topK(5)
-                .build());
-
-            System.out.println("Results:");
-            for (var r : results.results()) {
-                System.out.printf("  %s (%.4f): %s%n", r.id(), r.score(), r.title());
-            }
-
-            // Cleanup
-            client.delete("java-1");
-            client.delete("java-2");
-        }
-    }
 }
 ```
 
----
+## Thread Safety
 
-## 🔗 See Also
+`SpectorClient` is thread-safe. It uses Java's `HttpClient` with a connection pool (default 10 connections). You can safely share a single instance across multiple threads.
 
-- [REST API Reference](../api-reference/rest-endpoints.md) — Underlying API endpoints
+## Configuration
 
-- [Spring AI Integration](spring-ai.md) — Spring AI VectorStore adapter
-
-- [Configuration Guide](../configuration/parameters.md) — All engine parameters
-
-- [Getting Started](../getting-started/quickstart.md) — Quick start guide
\ No newline at end of file
+| Option | Default | Description |
+|--------|---------|-------------|
+| `host` | localhost | Server hostname |
+| `port` | 7070 | Server port |
+| `apiKey` | — | Authentication key |
+| `connectTimeout` | 10s | Connection timeout |
+| `requestTimeout` | 30s | Request timeout |
+| `maxConnections` | 10 | Connection pool size |
diff --git a/docs/docs/sdk-usage/mcp-server.md b/docs/docs/sdk-usage/mcp-server.md
deleted file mode 100644
index 5779bdd..0000000
--- a/docs/docs/sdk-usage/mcp-server.md
+++ /dev/null
@@ -1,301 +0,0 @@
-# 🤖 MCP Server Usage Guide
-
-> **Connect any AI agent to Spector's search engine in minutes.**
-
-This guide covers practical setup for Claude Desktop, Cursor IDE, and custom MCP clients.
-
----
-
-## Quick Start (3 Steps)
-
-### 1. Build the Distribution JAR
-
-```bash
-cd spector
-mvn package -pl spector-dist -am -DskipTests
-```
-
-The fat JAR is produced at `spector-dist/target/spector.jar`.
-
-### 2. Configure Your AI Agent
-
-Add the following to your agent's MCP configuration (see per-agent sections below):
-
-```json
-{
-  "mcpServers": {
-    "spector": {
-      "command": "java",
-      "args": [
-        "--add-modules", "jdk.incubator.vector",
-        "--enable-native-access=ALL-UNNAMED",
-        "--enable-preview",
-        "-jar", "/path/to/spector-dist/target/spector.jar",
-        "--config", "/path/to/spector.yml"
-      ]
-    }
-  }
-}
-```
-
-### 3. Start Using
-
-Your AI agent now has access to up to 13 tools. With cognitive memory enabled (`spector.memory.enabled: true`), all 13 tools are registered. Otherwise, the 6 search tools are available:
-
-- *"Search for documents about SIMD acceleration"* → `semantic_search`
-- *"Find articles mentioning 'Panama' and related to memory management"* → `hybrid_search`
-- *"What does the codebase say about quantization?"* → `rag_query`
-- *"Add this document to the index: ..."* → `ingest_document`
-- *"Remember that the user prefers dark mode"* → `core_memory_append`
-- *"What do you remember about the user's preferences?"* → `recall_context`
-
----
-
-## CLI Options
-
-| Flag | Default | Description |
-|:---|:---|:---|
-| `--config <FILE>` | *(none)* | Explicit config file (YAML or .properties) |
-| `--profile <NAME>` | *(none)* | Configuration profile (loads `spector-{profile}.yml`) |
-| `--dims <N>` | 384 | Vector dimensionality (must match your embedding model) |
-| `--capacity <N>` | 100,000 | Maximum document capacity |
-| `--data-dir <DIR>` | *(none)* | Persistence directory (auto-enables DISK mode) |
-| `--ollama-url <URL>` | *(none)* | Ollama embedding server URL (e.g., `http://localhost:11434`) |
-| `--ollama-model <NAME>` | *(none)* | Ollama embedding model name (e.g., `nomic-embed-text`) |
-| `--help`, `-h` | — | Show help message |
-
-> [!TIP]
-> **Recommended approach:** Use a `spector.yml` config file rather than CLI flags. CLI flags override values from the config file.
-
-### Configuration File
-
-All settings can be specified in a `spector.yml` file:
-
-```yaml
-spector:
-  engine:
-    dimensions: 768
-    capacity: 100000
-    persistence-mode: DISK
-    data-directory: .spector/index
-  embedding:
-    model: nomic-embed-text
-    base-url: http://localhost:11434
-  memory:
-    enabled: true              # Enable cognitive memory tools
-    persistence-path: .spector/memory
-```
-
-See the [Configuration Guide](../configuration/parameters.md) for the complete list of settings.
-
-### Choosing Dimensions
-
-The `--dims` flag must match your embedding model's output dimensionality:
-
-| Model | Dimensions | Flag |
-|:---|:---|:---|
-| `nomic-embed-text` | 768 | `--dims 768` |
-| `all-minilm` | 384 | `--dims 384` |
-| `mxbai-embed-large` | 1024 | `--dims 1024` |
-| `qwen3-embedding` | 4096 | `--dims 4096` |
-
----
-
-## Agent Configuration
-
-### Claude Desktop
-
-Edit your `claude_desktop_config.json`:
-
-=== "macOS"
-
-    ```
-    ~/Library/Application Support/Claude/claude_desktop_config.json
-    ```
-
-=== "Windows"
-
-    ```
-    %APPDATA%\Claude\claude_desktop_config.json
-    ```
-
-=== "Linux"
-
-    ```
-    ~/.config/Claude/claude_desktop_config.json
-    ```
-
-**Configuration:**
-
-```json
-{
-  "mcpServers": {
-    "spector": {
-      "command": "java",
-      "args": [
-        "--add-modules", "jdk.incubator.vector",
-        "--enable-native-access=ALL-UNNAMED",
-        "--enable-preview",
-        "-jar", "/absolute/path/to/spector.jar",
-        "--config", "/absolute/path/to/spector.yml"
-      ]
-    }
-  }
-}
-```
-
-> [!TIP]
-> Use absolute paths for the JAR file. Relative paths may not resolve correctly from Claude Desktop's working directory.
-
-### Cursor IDE
-
-Add to your Cursor MCP settings (`.cursor/mcp.json` in your project, or global settings):
-
-```json
-{
-  "mcpServers": {
-    "spector": {
-      "command": "java",
-      "args": [
-        "--add-modules", "jdk.incubator.vector",
-        "--enable-native-access=ALL-UNNAMED",
-        "--enable-preview",
-        "-jar", "/absolute/path/to/spector.jar",
-        "--config", "/absolute/path/to/spector.yml"
-      ]
-    }
-  }
-}
-```
-
-### Custom MCP Clients
-
-Any application implementing the [MCP client specification](https://modelcontextprotocol.io/docs/concepts/clients) can connect to Spector. The server communicates via **JSON-RPC 2.0 over stdio** (stdin/stdout).
-
-**Key requirements:**
-
-1. Spawn the Java process with the correct JVM flags
-2. Write JSON-RPC messages to the process's stdin
-3. Read JSON-RPC responses from the process's stdout
-4. All logging goes to stderr (stdout is reserved for protocol messages)
-
-**Example initialization sequence:**
-
-```json
-// Client → Server
-{"jsonrpc": "2.0", "id": 1, "method": "initialize", "params": {"protocolVersion": "2025-03-26", "capabilities": {}, "clientInfo": {"name": "my-app", "version": "1.0"}}}
-
-// Server → Client
-{"jsonrpc": "2.0", "id": 1, "result": {"protocolVersion": "2025-03-26", "capabilities": {"tools": {}}, "serverInfo": {"name": "spector-mcp", "version": "0.1.0"}}}
-
-// Client → Server
-{"jsonrpc": "2.0", "method": "notifications/initialized"}
-```
-
----
-
-## MCP Tools Overview
-
-Once connected, your agent has access to these tools:
-
-### Search Tools (always available)
-
-| Tool | Description | Requires Embedding |
-|:---|:---|:---|
-| `semantic_search` | Vector similarity search | ✅ |
-| `hybrid_search` | Keyword + vector with RRF fusion | Partial (keyword mode works without) |
-| `rag_query` | Retrieval-Augmented Generation context | ✅ |
-| `ingest_document` | Add documents to the index | ✅ (for auto-embedding) |
-| `delete_document` | Remove documents by ID | ❌ |
-| `engine_status` | Engine capabilities and stats | ❌ |
-
-### Cognitive Memory Tools (enabled via `spector.memory.enabled: true`)
-
-| Tool | Description |
-|:---|:---|
-| `core_memory_append` | Store a semantic memory with tags and source |
-| `recall_context` | Cognitive recall with fused scoring across tiers |
-| `memory_status` | Memory tier counts and persistence info |
-| `memory_reinforce` | Report positive/negative outcome for a memory |
-| `memory_forget` | Tombstone a memory by ID |
-| `memory_introspect` | Metamemory self-analysis on a topic |
-| `working_memory_scratchpad` | Quick-write to working memory |
-
-> [!NOTE]
-> For full tool schemas and parameter details, see the [MCP Integration Architecture](../architecture/mcp-integration.md#tool-reference) page.
-
----
-
-## Troubleshooting
-
-### Agent can't find or start the server
-
-- **Check the JAR path** — Use absolute paths, not relative
-- **Check Java version** — Spector requires JDK 25+. Run `java -version` to verify
-- **Check JVM flags** — `--add-modules jdk.incubator.vector` is required
-
-### "Embedding provider not configured" errors
-
-The `semantic_search` and `rag_query` tools require an embedding provider. Ensure:
-
-1. Ollama is running: `ollama serve`
-2. The model is pulled: `ollama pull nomic-embed-text`
-3. Both `--ollama-url` and `--ollama-model` are specified in the args
-
-### Stdout corruption / garbled output
-
-Spector redirects all logging to **stderr**. If you see garbled output:
-
-- Check that nothing else is writing to stdout
-- Verify the logback configuration routes to stderr
-- Check for print statements in any custom code
-
-### Performance issues
-
-- **High latency on first query** — The HNSW index is built lazily. First query triggers graph construction. Subsequent queries are fast.
-- **Memory usage** — Vectors are stored off-heap. Monitor with `-XX:NativeMemoryTracking=summary` and `jcmd <pid> VM.native_memory summary`
-
----
-
-## Adding a New Tool
-
-To extend the MCP server with a custom tool:
-
-1. **Create a new class** extending `McpToolHandler`:
-
-```java
-public final class MyCustomTool extends McpToolHandler {
-    @Override public String name() { return "my_custom_tool"; }
-    @Override public String description() { return "Does something useful."; }
-    @Override public Map<String, Object> inputSchema() {
-        return ToolSchemaBuilder.object()
-                .requiredString("input", "The input parameter.")
-                .build();
-    }
-    @Override public CallToolResult execute(SpectorEngine engine, Map<String, Object> args) {
-        String input = requireString(args, "input");
-        // Your logic here
-        return textResult("Result: " + input);
-    }
-}
-```
-
-2. **Register it** in `SpectorToolRegistry.handlers()`:
-
-```java
-List.of(
-    new SemanticSearchTool(),
-    // ... existing tools ...
-    new MyCustomTool()  // ← add here
-);
-```
-
-That's it — the tool is automatically available to all connected agents.
-
----
-
-## See Also
-
-- [MCP Integration Architecture](../architecture/mcp-integration.md) — Module structure, data flow, and performance analysis
-- [Architecture Overview](../architecture/overview.md) — Full system architecture
-- [REST API Reference](../api-reference/rest-endpoints.md) — Alternative HTTP interface
diff --git a/docs/docs/sdk-usage/spring-ai.md b/docs/docs/sdk-usage/spring-ai.md
deleted file mode 100644
index 32e2aea..0000000
--- a/docs/docs/sdk-usage/spring-ai.md
+++ /dev/null
@@ -1,336 +0,0 @@
-# 🌱 Spring AI Integration
-
-> **Seamlessly integrate Spector into your Spring AI applications.** The `spector-spring` module implements Spring AI's `VectorStore` interface, giving you access to filter expressions, RAG patterns, and the full Spring AI ecosystem backed by sub-millisecond search.
-
----
-
-## 📦 Maven Dependency
-
-```xml
-<dependency>
-    <groupId>com.spectrayan</groupId>
-    <artifactId>spector-spring</artifactId>
-    <version>1.0-SNAPSHOT</version>
-</dependency>
-```
-
-Spring AI dependencies (BOM recommended):
-
-```xml
-<dependencyManagement>
-    <dependencies>
-        <dependency>
-            <groupId>org.springframework.ai</groupId>
-            <artifactId>spring-ai-bom</artifactId>
-            <version>1.0.0</version>
-            <type>pom</type>
-            <scope>import</scope>
-        </dependency>
-    </dependencies>
-</dependencyManagement>
-```
-
----
-
-## ⚡ Configuration Modes
-
-```mermaid
-graph LR
-    subgraph "🏠 Embedded Mode"
-        A[Your App] --> B[SpectorVectorStore]
-        B --> C[SpectorEngine<br/>In-process, zero latency]
-    end
-
-    subgraph "🌐 Remote Mode"
-        D[Your App] --> E[SpectorVectorStore]
-        E --> F[SpectorClient<br/>REST to server]
-        F --> G[Spector Server]
-    end
-```
-
-### 🏠 Embedded Mode (In-Process)
-
-Use the SpectorEngine directly — no network, lowest latency:
-
-```java
-import org.springframework.ai.vectorstore.spector.SpectorVectorStore;
-import com.spectrayan.spector.engine.SpectorEngine;
-import com.spectrayan.spector.engine.SpectorConfig;
-
-@Configuration
-public class VectorStoreConfig {
-
-    @Bean
-    public SpectorEngine spectorEngine() {
-        var config = SpectorConfig.DEFAULT
-            .withDimensions(384)
-            .withCapacity(100_000);
-        return new SpectorEngine(config);
-    }
-
-    @Bean
-    public VectorStore vectorStore(SpectorEngine engine) {
-        return new SpectorVectorStore(engine);
-    }
-}
-```
-
-### 🌐 Remote Mode (Client SDK)
-
-Connect to a running Spector server:
-
-```java
-import com.spectrayan.spector.client.SpectorClient;
-
-@Configuration
-public class VectorStoreConfig {
-
-    @Bean
-    public SpectorClient spectorClient() {
-        return SpectorClient.builder()
-            .host("spector-node.internal")
-            .port(7070)
-            .apiKey("my-api-key")
-            .build();
-    }
-
-    @Bean
-    public VectorStore vectorStore(SpectorClient client) {
-        return new SpectorVectorStore(client);
-    }
-}
-```
-
----
-
-## 📄 Adding Documents
-
-```java
-import org.springframework.ai.document.Document;
-import org.springframework.ai.vectorstore.VectorStore;
-
-@Service
-public class DocumentService {
-
-    private final VectorStore vectorStore;
-
-    public DocumentService(VectorStore vectorStore) {
-        this.vectorStore = vectorStore;
-    }
-
-    public void addDocuments() {
-        List<Document> documents = List.of(
-            new Document("HNSW enables fast approximate nearest neighbor search",
-                Map.of("source", "architecture.md", "category", "indexing")),
-            new Document("BM25 provides keyword scoring with term frequency saturation",
-                Map.of("source", "algorithms.md", "category", "search")),
-            new Document("Virtual threads allow millions of concurrent operations",
-                Map.of("source", "concurrency.md", "category", "runtime"))
-        );
-
-        vectorStore.add(documents);
-    }
-}
-```
-
----
-
-## 🔍 Similarity Search
-
-### Basic Search
-
-```java
-List<Document> results = vectorStore.similaritySearch("nearest neighbor search");
-```
-
-### Search with Parameters
-
-```java
-import org.springframework.ai.vectorstore.SearchRequest;
-
-List<Document> results = vectorStore.similaritySearch(
-    SearchRequest.query("vector search algorithms")
-        .withTopK(10)
-        .withSimilarityThreshold(0.7)
-);
-```
-
-### 🎯 Filter Expressions
-
-SpectorVectorStore supports Spring AI's metadata filter expressions:
-
-```java
-// Filter by category
-List<Document> results = vectorStore.similaritySearch(
-    SearchRequest.query("search algorithms")
-        .withTopK(5)
-        .withFilterExpression("category == 'indexing'")
-);
-
-// Complex filters
-List<Document> results = vectorStore.similaritySearch(
-    SearchRequest.query("performance")
-        .withTopK(10)
-        .withFilterExpression("category == 'search' && source == 'algorithms.md'")
-);
-```
-
-**Supported filter operators:**
-
-| Operator | Example |
-|----------|---------|
-| `==` | `category == 'search'` |
-| `!=` | `category != 'draft'` |
-| `>`, `>=`, `<`, `<=` | `version > 2` |
-| `&&` | `a == 'x' && b == 'y'` |
-| `\|\|` | `a == 'x' \|\| a == 'y'` |
-| `in` | `category in ['search', 'index']` |
-| `not in` | `status not in ['archived']` |
-
----
-
-## 🗑️ Deleting Documents
-
-```java
-vectorStore.delete(List.of("doc-id-1", "doc-id-2"));
-```
-
----
-
-## 🤖 RAG Service
-
-The `SpectorRagService` provides end-to-end retrieval-augmented generation:
-
-```java
-import org.springframework.ai.vectorstore.spector.rag.SpectorRagService;
-
-@Service
-public class AiAssistant {
-
-    private final SpectorRagService ragService;
-
-    public AiAssistant(SpectorRagService ragService) {
-        this.ragService = ragService;
-    }
-
-    public String getContext(String userQuery) {
-        RagConfig config = new RagConfig(
-            10,      // topK
-            0.7f,    // similarity threshold
-            4096     // token limit
-        );
-
-        RetrievalResult result = ragService.retrieve(userQuery, config);
-        return result.contextText();
-    }
-}
-```
-
-### 💬 RAG with Spring AI ChatClient
-
-```java
-@Service
-public class RagChatService {
-
-    private final ChatClient chatClient;
-    private final VectorStore vectorStore;
-
-    public String ask(String question) {
-        return chatClient.prompt()
-            .system("Answer based on the provided context.")
-            .user(question)
-            .advisors(new QuestionAnswerAdvisor(vectorStore))
-            .call()
-            .content();
-    }
-}
-```
-
-> [!TIP]
-> Spring AI's `QuestionAnswerAdvisor` automatically retrieves relevant context from the VectorStore and includes it in the prompt — no manual context assembly needed.
-
----
-
-## ⚙️ Spring Boot Auto-Configuration
-
-Configure via `application.yml`:
-
-```yaml
-spector:
-  search:
-    mode: embedded          # or "remote"
-    dimensions: 384
-    capacity: 100000
-    # Remote mode settings
-    host: localhost
-    port: 7070
-    api-key: ${SPECTOR_API_KEY:}
-```
-
----
-
-## ⚠️ Error Handling
-
-| Exception | Cause |
-|-----------|-------|
-| `SpectorVectorStoreException` | Connection failure, server error |
-| `SpectorRagServiceException` | RAG pipeline errors |
-
-```java
-try {
-    vectorStore.add(documents);
-} catch (SpectorVectorStoreException e) {
-    log.error("Failed to add documents: {}", e.getMessage());
-}
-```
-
----
-
-## 🎯 Complete Example
-
-```java
-@SpringBootApplication
-public class SearchApp {
-
-    @Bean
-    public VectorStore vectorStore() {
-        var engine = new SpectorEngine(
-            SpectorConfig.DEFAULT.withDimensions(384));
-        return new SpectorVectorStore(engine);
-    }
-
-    @Bean
-    CommandLineRunner demo(VectorStore store) {
-        return args -> {
-            // Add documents
-            store.add(List.of(
-                new Document("HNSW uses multi-layer graphs for fast ANN search",
-                    Map.of("topic", "indexing")),
-                new Document("Product quantization compresses vectors 32x",
-                    Map.of("topic", "compression"))
-            ));
-
-            // Search with filter
-            var results = store.similaritySearch(
-                SearchRequest.query("compression techniques")
-                    .withTopK(5)
-                    .withFilterExpression("topic == 'compression'"));
-
-            results.forEach(doc ->
-                System.out.println(doc.getContent()));
-        };
-    }
-}
-```
-
----
-
-## 🔗 See Also
-
-- [Java SDK Guide](java-client.md) — Direct SDK usage
-
-- [RAG Pipeline](../architecture/rag-pipeline.md) — How the RAG pipeline works internally
-
-- [REST API Reference](../api-reference/rest-endpoints.md) — Underlying REST endpoints
-
-- [Configuration Guide](../configuration/parameters.md) — All configurable parameters
\ No newline at end of file
diff --git a/docs/docs/stylesheets/extra.css b/docs/docs/stylesheets/extra.css
deleted file mode 100644
index ec50d3c..0000000
--- a/docs/docs/stylesheets/extra.css
+++ /dev/null
@@ -1,79 +0,0 @@
-/* Center mermaid diagrams */
-.mermaid {
-  text-align: center;
-}
-
-.mermaid svg {
-  margin: 0 auto;
-  display: block;
-}
-
-/* Fix mermaid diagrams on dark theme */
-[data-md-color-scheme="slate"] .mermaid {
-  --md-mermaid-font-family: var(--md-text-font-family, _);
-}
-
-/* Ensure mermaid nodes are readable on dark backgrounds */
-[data-md-color-scheme="slate"] .mermaid .node rect,
-[data-md-color-scheme="slate"] .mermaid .node polygon,
-[data-md-color-scheme="slate"] .mermaid .node circle {
-  fill: #1e1e2e !important;
-  stroke: #6c6c8a !important;
-}
-
-[data-md-color-scheme="slate"] .mermaid .node .label,
-[data-md-color-scheme="slate"] .mermaid span {
-  color: #cdd6f4 !important;
-  fill: #cdd6f4 !important;
-}
-
-[data-md-color-scheme="slate"] .mermaid .edgePath .path {
-  stroke: #6c6c8a !important;
-}
-
-[data-md-color-scheme="slate"] .mermaid .edgeLabel {
-  background-color: #1e1e2e !important;
-  color: #cdd6f4 !important;
-}
-
-[data-md-color-scheme="slate"] .mermaid .cluster rect {
-  fill: #181825 !important;
-  stroke: #45475a !important;
-}
-
-[data-md-color-scheme="slate"] .mermaid .cluster span {
-  color: #a6adc8 !important;
-}
-
-/* Sequence diagram dark theme fixes */
-[data-md-color-scheme="slate"] .mermaid .actor {
-  fill: #1e1e2e !important;
-  stroke: #6c6c8a !important;
-}
-
-[data-md-color-scheme="slate"] .mermaid text.actor {
-  fill: #cdd6f4 !important;
-}
-
-[data-md-color-scheme="slate"] .mermaid .messageLine0,
-[data-md-color-scheme="slate"] .mermaid .messageLine1 {
-  stroke: #6c6c8a !important;
-}
-
-[data-md-color-scheme="slate"] .mermaid .messageText {
-  fill: #cdd6f4 !important;
-}
-
-[data-md-color-scheme="slate"] .mermaid .note {
-  fill: #313244 !important;
-  stroke: #45475a !important;
-}
-
-[data-md-color-scheme="slate"] .mermaid .noteText {
-  fill: #cdd6f4 !important;
-}
-
-/* Flowchart dark theme fixes */
-[data-md-color-scheme="slate"] .mermaid .flowchart-link {
-  stroke: #6c6c8a !important;
-}
diff --git a/docs/mkdocs.yml b/docs/mkdocs.yml
index 509697a..f879e6b 100644
--- a/docs/mkdocs.yml
+++ b/docs/mkdocs.yml
@@ -1,13 +1,11 @@
-site_name: Spector Documentation
-site_description: The Zero-Overhead, Agent-Ready AI Memory Backbone
-site_url: https://spectrayan.github.io/spector/
-repo_url: https://github.com/spectrayan/spector
-repo_name: spectrayan/spector
+site_name: Spector Search Documentation
+site_description: Ultra-fast, SIMD-accelerated semantic search engine built on Java Vector API
+site_url: https://spectrayan.github.io/spector-search/
+repo_url: https://github.com/spectrayan/spector-search
+repo_name: spectrayan/spector-search
 
 theme:
   name: material
-  icon:
-    logo: material/lightning-bolt
   palette:
     - scheme: default
       primary: indigo
@@ -22,182 +20,44 @@ theme:
         icon: material/brightness-4
         name: Switch to light mode
   features:
-    # Navigation
-    - navigation.tabs              # Top-level tabs
-    - navigation.tabs.sticky       # Tabs stay visible on scroll
-    - navigation.sections          # Bold section headers in sidebar
-    - navigation.expand            # Auto-expand sidebar sections
-    - navigation.top               # "Back to top" button on scroll
-    - navigation.instant           # Single-page app feel (no full reload)
-    - navigation.instant.progress  # Loading progress bar
-    - navigation.tracking          # URL updates as you scroll sections
-    - navigation.indexes           # Section index pages
-    - navigation.footer            # Previous/Next page links at bottom
-    - navigation.path              # Breadcrumbs above page title
-    # Search
-    - search.suggest               # Autocomplete suggestions
-    - search.highlight             # Highlight search terms on page
-    - search.share                 # Shareable search links
-    # Content
-    - content.code.copy            # Copy button on code blocks
-    - content.code.annotate        # Inline code annotations
-    - content.tabs.link            # Linked content tabs across page
-    - content.tooltips             # Rich tooltips on hover
-    # TOC
-    - toc.follow                   # TOC follows scroll position
+    - navigation.tabs
+    - navigation.sections
+    - navigation.expand
+    - navigation.top
+    - search.suggest
+    - search.highlight
+    - content.code.copy
+    - content.tabs.link
 
 plugins:
   - search
-  - callouts
 
 markdown_extensions:
-  - pymdownx.arithmatex:
-      generic: true
   - pymdownx.highlight:
       anchor_linenums: true
-      line_spans: __span
-  - pymdownx.inlinehilite
-  - pymdownx.snippets:
-      base_path:
-        - docs/docs
-        - ..                       # Repo root — enables --8<-- "spector-core/README.md"
-      check_paths: true
-  - pymdownx.superfences:
-      custom_fences:
-        - name: mermaid
-          class: mermaid
-          format: !!python/name:pymdownx.superfences.fence_code_format
+  - pymdownx.superfences
   - pymdownx.tabbed:
       alternate_style: true
-  - pymdownx.emoji:
-      emoji_index: !!python/name:material.extensions.emoji.twemoji
-      emoji_generator: !!python/name:material.extensions.emoji.to_svg
-  - pymdownx.tasklist:
-      custom_checkbox: true
-  - pymdownx.keys              # Render keyboard shortcuts like ++ctrl+c++
-  - pymdownx.mark              # ==highlighted text==
-  - pymdownx.critic            # Track changes markup
-  - pymdownx.caret             # ^^superscript^^
-  - pymdownx.tilde             # ~~strikethrough~~ and ~subscript~
-  - pymdownx.smartsymbols      # (c) → ©, (tm) → ™, etc.
   - admonition
   - pymdownx.details
   - attr_list
   - md_in_html
-  - def_list                   # Definition lists
-  - footnotes                  # Footnote references
-  - abbr                       # Abbreviation tooltips
-  - tables
   - toc:
       permalink: true
-      toc_depth: 3
-
-
 
 nav:
   - Home: index.md
-  - About: about.md
   - Getting Started:
       - Quick Start: getting-started/quickstart.md
       - Installation: getting-started/installation.md
-      - JDK API Status: getting-started/jdk-api-status.md
+  - API Reference:
+      - Overview: api-reference/overview.md
+      - REST Endpoints: api-reference/rest-endpoints.md
+  - Configuration:
+      - Parameters: configuration/parameters.md
   - Architecture:
       - System Overview: architecture/overview.md
-      - Core Concepts: architecture/core-concepts.md
-      - MCP Integration: architecture/mcp-integration.md
-      - Ingestion Pipeline: architecture/ingestion-pipeline.md
-      - RAG Pipeline: architecture/rag-pipeline.md
-      - Distributed Mode: architecture/distributed-mode.md
-      - GPU Acceleration: architecture/gpu-acceleration.md
-      - Modules:
-          - Overview: modules/index.md
-          - spector-core: modules/spector-core.md
-          - spector-commons: modules/spector-commons.md
-          - spector-config: modules/spector-config.md
-          - spector-storage: modules/spector-storage.md
-          - spector-embed-api: modules/spector-embed-api.md
-          - spector-embed-ollama: modules/spector-embed-ollama.md
-          - spector-index: modules/spector-index.md
-          - spector-query: modules/spector-query.md
-          - spector-gpu: modules/spector-gpu.md
-          - spector-rag: modules/spector-rag.md
-          - spector-engine: modules/spector-engine.md
-          - spector-ingestion: modules/spector-ingestion.md
-          - spector-memory: modules/spector-memory.md
-          - spector-runtime: modules/spector-runtime.md
-          - spector-node: modules/spector-node.md
-          - spector-mcp: modules/spector-mcp.md
-          - spector-cli: modules/spector-cli.md
-          - spector-client: modules/spector-client.md
-          - spector-spring: modules/spector-spring.md
-          - spector-metrics: modules/spector-metrics.md
-          - spector-bench: modules/spector-bench.md
-          - spector-dist: modules/spector-dist.md
-          - spector-cortex: modules/spector-cortex.md
-  - Deep Dives:
-      - ANN Search Primer: deep-dives/ann-search-primer.md
-      - HNSW Explained: deep-dives/hnsw-explained.md
-      - SpectorIndex Architecture: deep-dives/spector-index-architecture.md
-      - SVASQ Quantization: deep-dives/svasq-deep-dive.md
-      - Understanding Quantization: deep-dives/understanding-quantization.md
-      - Quantization Comparison: deep-dives/quantization-comparison.md
-      - TurboQuant: deep-dives/turbo-quant.md
-      - Real-Embedding Benchmarks: deep-dives/real-embedding-benchmarks.md
-      - "Whitepaper: SVASQ + SpectorIndex": deep-dives/svasq-spectorindex-whitepaper.md
-  - "🧠 Cognitive Memory":
-      - Overview: memory/index.md
-      - Getting Started: memory/getting-started.md
-      - Architecture:
-          - System Architecture: memory/architecture.md
-          - The 6-Phase Scoring Pipeline: memory/scoring-pipeline.md
-      - Biological Systems:
-          - Overview: memory/biological-systems.md
-          - "Cortex — Tier Stores": memory/cortex.md
-          - "Hippocampus — Sleep Consolidation": memory/hippocampus.md
-          - "Synapse — Tags & Scoring": memory/synapse.md
-          - "Dopamine — Surprise Detection": memory/dopamine.md
-          - "Amygdala — Emotional Valence": memory/amygdala.md
-          - "3-Layer Cognitive Graph": memory/hebbian.md
-          - "Habituation — Anti-Filter Bubble": memory/habituation.md
-          - "Inhibition — Suppression": memory/inhibition.md
-          - "Interference — Deduplication": memory/interference.md
-          - "Prospective — Future Intents": memory/prospective.md
-          - "Metamemory — Self-Reflection": memory/metamemory.md
-          - "Sync — Persistence & Replication": memory/sync.md
-      - Advanced Profiles:
-          - Cognitive Profiles Overview: memory/cognitive-profiles.md
-          - "Focus Mode": memory/focus-mode.md
-          - "Explorer — Lateral Retrieval": memory/lateral-retrieval.md
-          - "Importance Fusion (ICNU)": memory/importance-fusion.md
-      - Deep Dives:
-          - "Performance & SIMD": memory/performance.md
-          - "Off-Heap Panama Design": memory/panama-design.md
-          - "WAL Design": memory/wal-design.md
-      - API Reference: memory/api-reference.md
-
-  - "🧬 Cortex Dashboard":
-      - Overview: cortex/index.md
-
-  - Reference:
-      - REST API: api-reference/rest-endpoints.md
-      - MCP Server: sdk-usage/mcp-server.md
-      - Java SDK: sdk-usage/java-client.md
-      - Spring AI Integration: sdk-usage/spring-ai.md
-      - CLI (spectorctl): cli-reference/spectorctl.md
-      - Configuration: configuration/parameters.md
-  - Operations:
-      - Performance Tuning: operations/performance-tuning.md
-      - Contributing: operations/contributing.md
-  - FAQ: faq.md
-  - Roadmap: roadmap.md
-  - "🔬 Labs":
-      - labs/index.md
-      - Research Roadmap: labs/roadmap.md
-
-extra_css:
-  - stylesheets/extra.css
-
-extra_javascript:
-  - javascripts/mermaid-init.js
-  - javascripts/mathjax.js
-  - https://unpkg.com/mathjax@3/es5/tex-mml-chtml.js
+  - SDK Usage:
+      - Java Client SDK: sdk-usage/java-client.md
+  - CLI Reference:
+      - spectorctl: cli-reference/spectorctl.md
diff --git a/docs/screenshots/spector-cortex-dashboard.png b/docs/screenshots/spector-cortex-dashboard.png
deleted file mode 100644
index dc8dcfd..0000000
Binary files a/docs/screenshots/spector-cortex-dashboard.png and /dev/null differ
diff --git a/goal.md b/goal.md
new file mode 100644
index 0000000..97d9357
--- /dev/null
+++ b/goal.md
@@ -0,0 +1,68 @@
+# **Spector‑Search**  
+**Ultra‑fast, SIMD‑accelerated semantic search engine built on Java Vector API + modern JVM technologies.**
+
+Spector‑Search is a high‑performance search engine designed for the next generation of intelligent applications. It combines **Java's Vector API**, **virtual threads**, and **zero‑copy memory** to deliver blazing‑fast indexing and retrieval across large text corpora and vector embeddings.
+
+Built for developers who want **NumPy‑level performance** with the reliability, safety, and scalability of the JVM.
+
+---
+
+## 🚀 **Key Features**
+
+### **⚡ SIMD‑Accelerated Query Execution**  
+Powered by the Java Vector API (AVX2/AVX‑512/NEON/SVE), Spector‑Search performs vector math, scoring, and similarity computations at hardware speed.
+
+### **🧠 Semantic Search Ready**  
+Supports embedding‑based retrieval (cosine similarity, dot‑product ranking) and integrates cleanly with any embedding generator or LLM.
+
+### **🧵 Massive Concurrency with Virtual Threads**  
+Java Loom enables millions of lightweight concurrent search tasks without the overhead of traditional thread pools.
+
+### **🧩 Zero‑Copy Memory Architecture**  
+Uses Panama Memory Segments for high‑throughput indexing, caching, and vector storage.
+
+### **📦 Pluggable Indexing Pipeline**  
+Custom analyzers, tokenizers, and embedding pipelines allow you to tailor search behavior to your domain.
+
+### **🔍 Hybrid Search**  
+Combine keyword search + vector search for best‑of‑both‑worlds retrieval.
+
+### **🛠 JVM‑Native Performance**  
+No Python, no JNI overhead — pure Java, optimized by the JIT and Graal.
+
+---
+
+## 🧪 **Use Cases**
+
+- High‑performance document search  
+- Embedding/vector similarity search  
+- LLM‑augmented retrieval (RAG)  
+- Real‑time log or event search  
+- On‑device or edge semantic search  
+- Custom search engines for enterprise data  
+
+---
+
+## 🏗 **Tech Stack**
+
+- **Java 25**  
+- **Java Vector API (SIMD)**  
+- **Virtual Threads (Project Loom)**  
+- **Foreign Function & Memory API (Panama)**  
+- **Custom SIMD‑optimized math kernels**  
+- **CUDA GPU acceleration (optional)**  
+- **gRPC distributed search**  
+
+---
+
+## 📈 **Roadmap**
+
+- [x] GPU acceleration via CUDA bindings  
+- [x] HNSW / IVF / PQ vector index  
+- [x] Distributed search nodes  
+- [x] LLM‑powered ranking  
+- [x] REST API with CORS, auth, metrics  
+- [x] Embedding provider SPI (Ollama)  
+- [x] Document deletion + bulk ingest  
+- [x] gRPC TLS support  
+- [ ] WASM runtime for edge deployment  
diff --git a/pom.xml b/pom.xml
index 4f0f760..0b4237d 100644
--- a/pom.xml
+++ b/pom.xml
@@ -5,13 +5,13 @@
     <modelVersion>4.0.0</modelVersion>
 
     <groupId>com.spectrayan</groupId>
-    <artifactId>spector</artifactId>
+    <artifactId>spector-search</artifactId>
     <version>0.1.0-SNAPSHOT</version>
     <packaging>pom</packaging>
 
-    <name>Spector</name>
+    <name>Spector Search</name>
     <description>Ultra-fast, SIMD-accelerated semantic search engine built on Java Vector API + modern JVM technologies.</description>
-    <url>https://github.com/spectrayan/spector</url>
+    <url>https://github.com/spectrayan/spector-search</url>
 
     <licenses>
         <license>
@@ -24,26 +24,19 @@
     <modules>
         <module>spector-commons</module>
         <module>spector-core</module>
-        <module>spector-config</module>
         <module>spector-storage</module>
         <module>spector-index</module>
         <module>spector-query</module>
         <module>spector-embed-api</module>
         <module>spector-embed-ollama</module>
         <module>spector-gpu</module>
-        <module>spector-rag</module>
         <module>spector-engine</module>
-        <module>spector-ingestion</module>
-        <module>spector-memory</module>
-        <module>spector-metrics</module>
-        <module>spector-runtime</module>
-        <module>spector-node</module>
+        <module>spector-server</module>
+        <module>spector-cluster</module>
         <module>spector-bench</module>
         <module>spector-cli</module>
         <module>spector-client</module>
         <module>spector-spring</module>
-        <module>spector-mcp</module>
-        <module>spector-dist</module>
     </modules>
 
     <!-- ───────────────────────── Properties ───────────────────────── -->
@@ -60,17 +53,10 @@
 
         <!-- Dependency versions -->
         <javalin.version>6.6.0</javalin.version>
-        <jackson.version>3.1.3</jackson.version>
-        <jackson2.version>2.21.3</jackson2.version>
+        <jackson.version>2.18.3</jackson.version>
         <slf4j.version>2.0.17</slf4j.version>
         <logback.version>1.5.18</logback.version>
         <jmh.version>1.37</jmh.version>
-        <mcp-sdk.version>2.0.0-M3</mcp-sdk.version>
-        <commons-configuration2.version>2.11.0</commons-configuration2.version>
-        <commons-beanutils.version>1.9.4</commons-beanutils.version>
-        <snakeyaml.version>2.3</snakeyaml.version>
-        <micrometer.version>1.14.5</micrometer.version>
-        <armeria.version>1.31.3</armeria.version>
 
         <!-- Test dependency versions -->
         <junit.version>5.11.4</junit.version>
@@ -82,7 +68,6 @@
         <maven-jar-plugin.version>3.4.2</maven-jar-plugin.version>
         <maven-shade-plugin.version>3.6.0</maven-shade-plugin.version>
         <jacoco-plugin.version>0.8.12</jacoco-plugin.version>
-        <license-maven-plugin.version>5.0.0</license-maven-plugin.version>
 
         <!-- Reproducible builds: fixed timestamp for deterministic JARs -->
         <project.build.outputTimestamp>2024-01-01T00:00:00Z</project.build.outputTimestamp>
@@ -92,11 +77,6 @@
     <dependencyManagement>
         <dependencies>
             <!-- ── Internal modules ── -->
-            <dependency>
-                <groupId>com.spectrayan</groupId>
-                <artifactId>spector-config</artifactId>
-                <version>${project.version}</version>
-            </dependency>
             <dependency>
                 <groupId>com.spectrayan</groupId>
                 <artifactId>spector-core</artifactId>
@@ -122,16 +102,6 @@
                 <artifactId>spector-engine</artifactId>
                 <version>${project.version}</version>
             </dependency>
-            <dependency>
-                <groupId>com.spectrayan</groupId>
-                <artifactId>spector-ingestion</artifactId>
-                <version>${project.version}</version>
-            </dependency>
-            <dependency>
-                <groupId>com.spectrayan</groupId>
-                <artifactId>spector-rag</artifactId>
-                <version>${project.version}</version>
-            </dependency>
             <dependency>
                 <groupId>com.spectrayan</groupId>
                 <artifactId>spector-commons</artifactId>
@@ -164,83 +134,15 @@
             </dependency>
             <dependency>
                 <groupId>com.spectrayan</groupId>
-                <artifactId>spring-ai-starter-vector-store-spector</artifactId>
-                <version>${project.version}</version>
-            </dependency>
-            <dependency>
-                <groupId>com.spectrayan</groupId>
-                <artifactId>spector-mcp</artifactId>
-                <version>${project.version}</version>
-            </dependency>
-            <dependency>
-                <groupId>com.spectrayan</groupId>
-                <artifactId>spector-memory</artifactId>
-                <version>${project.version}</version>
-            </dependency>
-            <dependency>
-                <groupId>com.spectrayan</groupId>
-                <artifactId>spector-metrics</artifactId>
-                <version>${project.version}</version>
-            </dependency>
-            <dependency>
-                <groupId>com.spectrayan</groupId>
-                <artifactId>spector-node</artifactId>
-                <version>${project.version}</version>
-            </dependency>
-            <dependency>
-                <groupId>com.spectrayan</groupId>
-                <artifactId>spector-runtime</artifactId>
+                <artifactId>spring-ai-starter-vector-store-spector-search</artifactId>
                 <version>${project.version}</version>
             </dependency>
 
-            <!-- ── Micrometer (Observability) ── -->
-            <dependency>
-                <groupId>io.micrometer</groupId>
-                <artifactId>micrometer-core</artifactId>
-                <version>${micrometer.version}</version>
-            </dependency>
-            <dependency>
-                <groupId>io.micrometer</groupId>
-                <artifactId>micrometer-registry-prometheus</artifactId>
-                <version>${micrometer.version}</version>
-            </dependency>
-
-            <!-- ── MCP SDK (official Anthropic Java SDK) ── -->
-            <dependency>
-                <groupId>io.modelcontextprotocol.sdk</groupId>
-                <artifactId>mcp</artifactId>
-                <version>${mcp-sdk.version}</version>
-            </dependency>
-
-            <!-- ── Jackson (JSON) — Jackson 3.x (tools.jackson) ── -->
-            <dependency>
-                <groupId>tools.jackson.core</groupId>
-                <artifactId>jackson-databind</artifactId>
-                <version>${jackson.version}</version>
-            </dependency>
-
-            <!-- ── Jackson 2.x (required by Javalin 6.x which uses com.fasterxml.jackson) ── -->
+            <!-- ── Jackson (JSON) ── -->
             <dependency>
                 <groupId>com.fasterxml.jackson.core</groupId>
                 <artifactId>jackson-databind</artifactId>
-                <version>${jackson2.version}</version>
-            </dependency>
-
-            <!-- ── Apache Commons Configuration (hierarchical config) ── -->
-            <dependency>
-                <groupId>org.apache.commons</groupId>
-                <artifactId>commons-configuration2</artifactId>
-                <version>${commons-configuration2.version}</version>
-            </dependency>
-            <dependency>
-                <groupId>commons-beanutils</groupId>
-                <artifactId>commons-beanutils</artifactId>
-                <version>${commons-beanutils.version}</version>
-            </dependency>
-            <dependency>
-                <groupId>org.yaml</groupId>
-                <artifactId>snakeyaml</artifactId>
-                <version>${snakeyaml.version}</version>
+                <version>${jackson.version}</version>
             </dependency>
 
             <!-- ── Logging ── -->
@@ -255,31 +157,12 @@
                 <version>${logback.version}</version>
             </dependency>
 
-            <!-- ── Javalin (REST) — retained for spector-server backward compat ── -->
+            <!-- ── Javalin (REST) ── -->
             <dependency>
                 <groupId>io.javalin</groupId>
                 <artifactId>javalin</artifactId>
                 <version>${javalin.version}</version>
             </dependency>
-
-            <!-- ── Armeria (HTTP + gRPC on one port, built on Netty) ── -->
-            <dependency>
-                <groupId>com.linecorp.armeria</groupId>
-                <artifactId>armeria-bom</artifactId>
-                <version>${armeria.version}</version>
-                <type>pom</type>
-                <scope>import</scope>
-            </dependency>
-            <dependency>
-                <groupId>com.linecorp.armeria</groupId>
-                <artifactId>armeria</artifactId>
-                <version>${armeria.version}</version>
-            </dependency>
-            <dependency>
-                <groupId>com.linecorp.armeria</groupId>
-                <artifactId>armeria-grpc</artifactId>
-                <version>${armeria.version}</version>
-            </dependency>
             <dependency>
                 <groupId>io.javalin</groupId>
                 <artifactId>javalin-testtools</artifactId>
@@ -401,28 +284,6 @@
                         </execution>
                     </executions>
                 </plugin>
-
-                <!-- License header management (mycila) -->
-                <plugin>
-                    <groupId>com.mycila</groupId>
-                    <artifactId>license-maven-plugin</artifactId>
-                    <version>${license-maven-plugin.version}</version>
-                    <configuration>
-                        <properties>
-                            <year>2026</year>
-                        </properties>
-                        <licenseSets>
-                            <licenseSet>
-                                <header>src/license/apache2-header.txt</header>
-                                <includes>
-                                    <include>src/main/java/**/*.java</include>
-                                    <include>src/test/java/**/*.java</include>
-                                </includes>
-                            </licenseSet>
-                        </licenseSets>
-                        <skipExistingHeaders>false</skipExistingHeaders>
-                    </configuration>
-                </plugin>
             </plugins>
         </pluginManagement>
 
@@ -439,10 +300,6 @@
                 <groupId>org.jacoco</groupId>
                 <artifactId>jacoco-maven-plugin</artifactId>
             </plugin>
-            <plugin>
-                <groupId>com.mycila</groupId>
-                <artifactId>license-maven-plugin</artifactId>
-            </plugin>
         </plugins>
     </build>
 
diff --git a/scripts/collect-labs.sh b/scripts/collect-labs.sh
deleted file mode 100755
index 1671d18..0000000
--- a/scripts/collect-labs.sh
+++ /dev/null
@@ -1,187 +0,0 @@
-#!/usr/bin/env bash
-# ═══════════════════════════════════════════════════════════════════════
-# collect-labs.sh — Auto-discover labs/* branches and generate docs
-# ═══════════════════════════════════════════════════════════════════════
-#
-# This script is run by CI before `mkdocs build`. It:
-#   1. Discovers all remote branches matching `origin/labs/*`
-#   2. Extracts LABS.md from each branch via `git show`
-#   3. Copies each LABS.md into docs/docs/labs/<branch-name>.md
-#   4. Auto-generates docs/docs/labs/index.md with overview cards
-#
-# Convention: Each labs/* branch must have a LABS.md at the repo root.
-#   - Line 1: `# <Title>` (becomes the nav entry and card title)
-#   - Lines 3-5: First paragraph (becomes the overview blurb)
-#
-# Usage:
-#   ./scripts/collect-labs.sh          # Run from repo root
-#   ./scripts/collect-labs.sh --dry-run  # Preview without writing files
-#
-set -eu
-
-DOCS_LABS_DIR="docs/docs/labs"
-DRY_RUN=false
-
-if [[ "${1:-}" == "--dry-run" ]]; then
-    DRY_RUN=true
-    echo "🔍 Dry run mode — no files will be written"
-fi
-
-# ─── Ensure we have remote branch info ───────────────────────────────
-git fetch --prune origin 'refs/heads/labs/*:refs/remotes/origin/labs/*' 2>/dev/null || true
-
-# ─── Discover all labs branches ──────────────────────────────────────
-LABS_BRANCHES=$(git branch -r --list 'origin/labs/*' 2>/dev/null | sed 's/^ *//' | sort)
-
-if [[ -z "$LABS_BRANCHES" ]]; then
-    echo "ℹ️  No labs/* branches found. Skipping labs docs generation."
-    # Create minimal index if the nav references it
-    mkdir -p "$DOCS_LABS_DIR"
-    cat > "$DOCS_LABS_DIR/index.md" << 'EOF'
-# 🔬 Labs
-
-> **Experimental branches exploring cutting-edge JVM features and research ideas.**
-
-No active lab branches found. When a `labs/*` branch is pushed with a `LABS.md` file,
-it will automatically appear here.
-
-Check the [Roadmap](../roadmap.md) for planned experiments.
-EOF
-    exit 0
-fi
-
-echo "🔬 Discovered lab branches:"
-echo "$LABS_BRANCHES" | sed 's/^/   /'
-
-# ─── Create output directory ────────────────────────────────────────
-if [[ "$DRY_RUN" == "false" ]]; then
-    mkdir -p "$DOCS_LABS_DIR"
-fi
-
-# ─── Collect LABS.md from each branch ────────────────────────────────
-declare -a LAB_ENTRIES=()
-
-for BRANCH in $LABS_BRANCHES; do
-    # Extract branch short name: origin/labs/valhalla → valhalla
-    SHORT_NAME="${BRANCH#origin/labs/}"
-    SAFE_NAME=$(echo "$SHORT_NAME" | tr '/' '-')
-
-    echo "   📄 Processing: $BRANCH → labs/$SAFE_NAME.md"
-
-    # Try to extract LABS.md from this branch
-    CONTENT=$(git show "$BRANCH:LABS.md" 2>/dev/null) || {
-        echo "   ⚠️  No LABS.md found in $BRANCH — skipping"
-        continue
-    }
-
-    # Extract title (first H1 line)
-    TITLE=$(echo "$CONTENT" | grep -m1 '^# ' | sed 's/^# //')
-    if [[ -z "$TITLE" ]]; then
-        TITLE="Labs: $SHORT_NAME"
-    fi
-
-    # Extract overview: first non-empty, non-heading paragraph after the title
-    # Skip lines starting with #, >, ---, or empty lines, then grab until next blank line
-    OVERVIEW=$(echo "$CONTENT" | awk '
-        BEGIN { found_title=0; in_para=0 }
-        /^# / { found_title=1; next }
-        found_title && /^$/ && !in_para { next }
-        found_title && /^[>#\-\[]/ && !in_para { next }
-        found_title && /^.+$/ && !in_para { in_para=1; print; next }
-        in_para && /^.+$/ { print; next }
-        in_para && /^$/ { exit }
-    ')
-
-    if [[ -z "$OVERVIEW" ]]; then
-        OVERVIEW="Experimental branch: \`labs/$SHORT_NAME\`"
-    else
-        # Collapse multi-line to single line (read <<< splits on newlines)
-        OVERVIEW=$(echo "$OVERVIEW" | tr '\n' ' ' | sed 's/  */ /g')
-    fi
-
-    # Extract metadata (disable pipefail for grep pipelines)
-    STATUS=$(set +o pipefail; echo "$CONTENT" | grep -m1 'Status:' | sed 's/.*Status:[[:space:]]*//' | sed 's/[*]//g' | sed 's/^[[:space:]]*//')
-    [[ -z "$STATUS" ]] && STATUS="Experimental"
-
-    LAST_UPDATED=$(set +o pipefail; git log -1 --format='%cd' --date=short "$BRANCH" 2>/dev/null)
-    [[ -z "$LAST_UPDATED" ]] && LAST_UPDATED="unknown"
-
-    COMMIT_COUNT=$(set +o pipefail; git rev-list --count "origin/main..$BRANCH" 2>/dev/null)
-    [[ -z "$COMMIT_COUNT" ]] && COMMIT_COUNT="?"
-
-    if [[ "$DRY_RUN" == "false" ]]; then
-        # Write the full LABS.md as a doc page, with metadata header
-        {
-            echo "---"
-            echo "title: \"$TITLE\""
-            echo "---"
-            echo ""
-            echo "!!! warning \"Experimental Branch\""
-            echo "    This page is auto-generated from the \`labs/$SHORT_NAME\` branch."
-            echo "    It requires a specialized JDK or environment. See build instructions below."
-            echo ""
-            echo "**Branch:** [\`labs/$SHORT_NAME\`](https://github.com/spectrayan/spector/tree/labs/$SHORT_NAME)"
-            echo "| **Last updated:** $LAST_UPDATED"
-            echo "| **Commits ahead of main:** $COMMIT_COUNT"
-            echo ""
-            echo "---"
-            echo ""
-            echo "$CONTENT"
-        } > "$DOCS_LABS_DIR/$SAFE_NAME.md"
-    fi
-
-    # Collect entry for index page (use SOH as delimiter — pipe conflicts with markdown tables)
-    SEP=$'\x01'
-    LAB_ENTRIES+=("${SAFE_NAME}${SEP}${TITLE}${SEP}${OVERVIEW}${SEP}${STATUS}${SEP}${LAST_UPDATED}${SEP}${COMMIT_COUNT}")
-
-    echo "   ✅ Done: $TITLE"
-done
-
-# ─── Generate index page ────────────────────────────────────────────
-if [[ "$DRY_RUN" == "false" ]]; then
-    INDEX_FILE="$DOCS_LABS_DIR/index.md"
-
-    cat > "$INDEX_FILE" << 'HEADER'
-# 🔬 Labs
-
-> **Experimental branches exploring cutting-edge JVM features and research ideas.**
->
-> Each lab branch contains a self-contained experiment that may require specialized
-> JDK builds or dependencies. Labs are automatically discovered from `labs/*` branches
-> and documented here.
-
-!!! info "How Labs Work"
-    Any branch named `labs/<feature>` with a `LABS.md` file at the root is automatically
-    picked up by CI and rendered here. No manual editing of `main` required.
-
----
-
-HEADER
-
-    for ENTRY in "${LAB_ENTRIES[@]}"; do
-        IFS=$'\x01' read -r SAFE_NAME TITLE OVERVIEW STATUS LAST_UPDATED COMMIT_COUNT <<< "$ENTRY"
-
-        cat >> "$INDEX_FILE" << EOF
-## [$TITLE]($SAFE_NAME.md)
-
-| | |
-|---|---|
-| **Branch** | [\`labs/$SAFE_NAME\`](https://github.com/spectrayan/spector/tree/labs/$SAFE_NAME) |
-| **Status** | $STATUS |
-| **Updated** | $LAST_UPDATED |
-| **Commits** | $COMMIT_COUNT ahead of main |
-
-$OVERVIEW
-
-[:octicons-arrow-right-24: Full details]($SAFE_NAME.md){ .md-button }
-
----
-
-EOF
-    done
-
-    echo ""
-    echo "✅ Generated $INDEX_FILE with ${#LAB_ENTRIES[@]} lab(s)"
-fi
-
-echo "🔬 Labs collection complete: ${#LAB_ENTRIES[@]} lab(s) processed"
diff --git a/scripts/ingest-docs.bat b/scripts/ingest-docs.bat
deleted file mode 100644
index 25c4445..0000000
--- a/scripts/ingest-docs.bat
+++ /dev/null
@@ -1,28 +0,0 @@
-@echo off
-REM ═══════════════════════════════════════════════════════════════
-REM  Spector File Ingestion Script
-REM  Uses spectorctl to discover and ingest files via SpectorRuntime.
-REM  All configuration is read from spector.yml (or CLI overrides).
-REM
-REM  Usage: scripts\ingest-docs.bat [--pattern "**\*.java"] [--root path]
-REM ═══════════════════════════════════════════════════════════════
-
-set SPECTOR_HOME=%~dp0..
-set JAR=%SPECTOR_HOME%\spector-dist\target\spector.jar
-set CONFIG=%SPECTOR_HOME%\spector-local.yml
-
-if not exist "%JAR%" (
-    echo [ERROR] Fat JAR not found: %JAR%
-    echo [INFO]  Run: mvn package -pl spector-dist -am -DskipTests
-    exit /b 1
-)
-
-java ^
-    -Xmx4g ^
-    --add-modules jdk.incubator.vector ^
-    --enable-native-access=ALL-UNNAMED ^
-    --enable-preview ^
-    -cp "%JAR%" ^
-    com.spectrayan.spector.cli.SpectorCtl ^
-    ingest --config "%CONFIG%" ^
-    %*
diff --git a/scripts/mcp-config.json b/scripts/mcp-config.json
deleted file mode 100644
index 92798d0..0000000
--- a/scripts/mcp-config.json
+++ /dev/null
@@ -1,20 +0,0 @@
-{
-  "mcpServers": {
-    "spector": {
-      "command": "java",
-      "args": [
-        "--add-modules",
-        "jdk.incubator.vector",
-        "--enable-native-access=ALL-UNNAMED",
-        "-XX:+UseCompactObjectHeaders",
-        "-XX:+UnlockDiagnosticVMOptions",
-        "-XX:+UseVectorizedMismatch",
-        "--enable-preview",
-        "-jar",
-        "/path/to/spector-dist/target/spector.jar",
-        "--config",
-        "/path/to/spector-local.yml"
-      ]
-    }
-  }
-}
\ No newline at end of file
diff --git a/scripts/start-mcp.bat b/scripts/start-mcp.bat
deleted file mode 100644
index 52ba034..0000000
--- a/scripts/start-mcp.bat
+++ /dev/null
@@ -1,28 +0,0 @@
-@echo off
-REM ═══════════════════════════════════════════════════════════════
-REM  Spector MCP Server — Start Script
-REM  Starts the MCP server. Configuration is read from spector.yml.
-REM  CLI args can override any setting.
-REM ═══════════════════════════════════════════════════════════════
-
-set SPECTOR_HOME=%~dp0..
-set JAR=%SPECTOR_HOME%\spector-dist\target\spector.jar
-set CONFIG=%SPECTOR_HOME%\spector-local.yml
-
-if not exist "%JAR%" (
-    echo [ERROR] Fat JAR not found: %JAR%
-    echo [INFO]  Run: mvn package -pl spector-dist -am -DskipTests
-    exit /b 1
-)
-
-echo [Spector MCP] Starting... 1>&2
-echo [Spector MCP] JAR: %JAR% 1>&2
-echo [Spector MCP] Config: %CONFIG% 1>&2
-
-java ^
-    --add-modules jdk.incubator.vector ^
-    --enable-native-access=ALL-UNNAMED ^
-    --enable-preview ^
-    -jar "%JAR%" ^
-    --config "%CONFIG%" ^
-    %*
diff --git a/spector-bench/README.md b/spector-bench/README.md
deleted file mode 100644
index a99ece5..0000000
--- a/spector-bench/README.md
+++ /dev/null
@@ -1,36 +0,0 @@
-# spector-bench 📊
-
-> **JMH microbenchmarks, performance sweeps, and large-scale real-embedding performance runners.**
-
-`spector-bench` handles empirical performance testing, SIMD kernel validation, and large-scale index sweeps for Spector. It is designed to run locally, generating interactive HTML reports with latency charts.
-
----
-
-## 🏗️ Core Architecture & Runners
-
-1. **JMH Microbenchmarks (`SpectorMicrobench`):** Microsecond-level isolation checks for the Panama Vector similarity kernels (AVX2 vs. AVX-512 vs. ARM NEON).
-2. **Real-Embedding Sweeps (`RealEmbeddingScaleBench`):** Implements multi-centroid sweeps ($C \in \{32, 64, 128, 256\}$) using real Qwen3 text embeddings from local Ollama providers.
-3. **Promotion Benchmarks (`SpectorIndexPromotionBench`):** Head-to-head comparisons of Flat Shard SIMD scans vs. Promoted HNSW Shards at 100K scale.
-
----
-
-## 🚀 Running Benchmarks
-
-### Generate Dependencies Classpath
-Ensure the classpath is compiled before running:
-```bash
-mvn clean compile -pl spector-bench
-```
-
-### Running the Real-Embedding Scale Sweep
-Run Ollama qwen3-embedding benchmarking at a scale of 10,000 vectors:
-```powershell
-$cp = "spector-bench/target/classes;" + (Get-Content spector-bench/target/cp.txt)
-java --add-modules jdk.incubator.vector -Xmx12g -cp $cp com.spectrayan.spector.bench.RealEmbeddingScaleBench 10000
-```
-
-### Running the Shard Promotion Comparison
-Run Flat vs Promoted HNSW comparison at 100K scale:
-```powershell
-java --add-modules jdk.incubator.vector -Xmx12g -cp $cp com.spectrayan.spector.bench.SpectorIndexPromotionBench
-```
diff --git a/spector-bench/pom.xml b/spector-bench/pom.xml
index 7cef599..095d07c 100644
--- a/spector-bench/pom.xml
+++ b/spector-bench/pom.xml
@@ -6,24 +6,15 @@
 
     <parent>
         <groupId>com.spectrayan</groupId>
-        <artifactId>spector</artifactId>
+        <artifactId>spector-search</artifactId>
         <version>0.1.0-SNAPSHOT</version>
     </parent>
 
     <artifactId>spector-bench</artifactId>
     <name>Spector Benchmarks</name>
-    <description>JMH benchmarks for Spector performance testing.</description>
-
-    <properties>
-        <exec.mainClass>com.spectrayan.spector.bench.IndustryBenchmark</exec.mainClass>
-    </properties>
+    <description>JMH benchmarks for Spector Search performance testing.</description>
 
     <dependencies>
-
-        <dependency>
-            <groupId>com.spectrayan</groupId>
-            <artifactId>spector-config</artifactId>
-        </dependency>
         <dependency>
             <groupId>com.spectrayan</groupId>
             <artifactId>spector-engine</artifactId>
@@ -36,14 +27,6 @@
             <groupId>com.spectrayan</groupId>
             <artifactId>spector-gpu</artifactId>
         </dependency>
-        <dependency>
-            <groupId>com.spectrayan</groupId>
-            <artifactId>spector-memory</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>com.spectrayan</groupId>
-            <artifactId>spector-embed-ollama</artifactId>
-        </dependency>
 
         <!-- JMH -->
         <dependency>
@@ -58,7 +41,7 @@
 
         <!-- Jackson for JSON baseline regression -->
         <dependency>
-            <groupId>tools.jackson.core</groupId>
+            <groupId>com.fasterxml.jackson.core</groupId>
             <artifactId>jackson-databind</artifactId>
         </dependency>
 
@@ -85,18 +68,14 @@
                 <artifactId>exec-maven-plugin</artifactId>
                 <version>3.5.0</version>
                 <configuration>
-                    <!-- exec:exec launches a child JVM with enable-preview flag -->
-                    <executable>java</executable>
-                    <arguments>
-                        <argument>--enable-preview</argument>
-                        <argument>--add-modules</argument>
-                        <argument>jdk.incubator.vector</argument>
-                        <argument>-Xmx28g</argument>
-                        <argument>-Dlogback.configurationFile=logback-bench.xml</argument>
-                        <argument>-classpath</argument>
-                        <classpath/>
-                        <argument>${exec.mainClass}</argument>
-                    </arguments>
+                    <mainClass>com.spectrayan.spector.bench.PerformanceTestRunner</mainClass>
+                    <arguments/>
+                    <systemProperties>
+                        <systemProperty>
+                            <key>logback.configurationFile</key>
+                            <value>logback-bench.xml</value>
+                        </systemProperty>
+                    </systemProperties>
                 </configuration>
             </plugin>
         </plugins>
diff --git a/spector-bench/src/main/java/com/spectrayan/spector/bench/BM25Benchmark.java b/spector-bench/src/main/java/com/spectrayan/spector/bench/BM25Benchmark.java
index 6ce870b..0569952 100644
--- a/spector-bench/src/main/java/com/spectrayan/spector/bench/BM25Benchmark.java
+++ b/spector-bench/src/main/java/com/spectrayan/spector/bench/BM25Benchmark.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.bench;
 
 import com.spectrayan.spector.index.BM25Index;
diff --git a/spector-bench/src/main/java/com/spectrayan/spector/bench/BaselineRegressionDetector.java b/spector-bench/src/main/java/com/spectrayan/spector/bench/BaselineRegressionDetector.java
index ce8c49a..d489f82 100644
--- a/spector-bench/src/main/java/com/spectrayan/spector/bench/BaselineRegressionDetector.java
+++ b/spector-bench/src/main/java/com/spectrayan/spector/bench/BaselineRegressionDetector.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.bench;
 
 import java.io.IOException;
@@ -23,8 +8,8 @@
 import java.util.List;
 import java.util.Map;
 
-import tools.jackson.databind.JsonNode;
-import tools.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
 
 /**
  * Detects performance regressions by comparing JMH JSON results against a baseline.
@@ -110,7 +95,9 @@ private Map<String, BenchmarkEntry> parseBenchmarks(Path path) throws IOExceptio
             JsonNode paramsNode = node.get("params");
             if (paramsNode != null && paramsNode.isObject()) {
                 StringBuilder sb = new StringBuilder();
-                for (var field : paramsNode.properties()) {
+                var fields = paramsNode.fields();
+                while (fields.hasNext()) {
+                    var field = fields.next();
                     if (!sb.isEmpty()) sb.append(",");
                     sb.append(field.getKey()).append("=").append(field.getValue().asText());
                 }
diff --git a/spector-bench/src/main/java/com/spectrayan/spector/bench/BenchmarkSuiteRunner.java b/spector-bench/src/main/java/com/spectrayan/spector/bench/BenchmarkSuiteRunner.java
index e193fd8..b77571d 100644
--- a/spector-bench/src/main/java/com/spectrayan/spector/bench/BenchmarkSuiteRunner.java
+++ b/spector-bench/src/main/java/com/spectrayan/spector/bench/BenchmarkSuiteRunner.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.bench;
 
 import java.io.IOException;
diff --git a/spector-bench/src/main/java/com/spectrayan/spector/bench/CognitiveMemoryBenchmark.java b/spector-bench/src/main/java/com/spectrayan/spector/bench/CognitiveMemoryBenchmark.java
deleted file mode 100644
index 268601b..0000000
--- a/spector-bench/src/main/java/com/spectrayan/spector/bench/CognitiveMemoryBenchmark.java
+++ /dev/null
@@ -1,324 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.bench;
-
-import com.spectrayan.spector.core.similarity.SimilarityFunction;
-import com.spectrayan.spector.memory.*;
-import com.spectrayan.spector.memory.cortex.MemorySource;
-import com.spectrayan.spector.memory.sync.MemoryWal;
-import com.spectrayan.spector.memory.hippocampus.CircadianPolicy;
-import com.spectrayan.spector.commons.concurrent.MemoryPinning;
-
-import java.io.IOException;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.time.Duration;
-import java.time.Instant;
-import java.util.*;
-import java.util.concurrent.*;
-import java.util.concurrent.atomic.AtomicLong;
-
-/**
- * Standalone empirical benchmark suite for Spector's off-heap cognitive memory.
- * Validates hebbian plasticity counter throughput, page cache pre-touching,
- * and quantifies the "Truncation Trap" recall error delta compared to external databases.
- */
-public class CognitiveMemoryBenchmark {
-
-    private static final int DIMENSIONS = 128;
-    private static final int DATASET_SIZE = 5000;
-    private static final int CONCURRENCY_THREADS = 16;
-    private static final int MEASURE_ITERATIONS = 50000;
-
-    public static void main(String[] args) throws Exception {
-        System.out.println("╔══════════════════════════════════════════════════════════╗");
-        System.out.println("║        SPECTOR COGNITIVE MEMORY BENCHMARK HARNESS        ║");
-        System.out.println("╚══════════════════════════════════════════════════════════╝");
-        System.out.println();
-
-        Path walDir = Files.createTempDirectory("spector-wal-bench");
-        
-        try {
-            // Run 1: Hebbian Plasticity CAS Latency & Throughput Benchmark
-            runPlasticityCasBenchmark(walDir);
-
-            // Run 2: Fused SIMD vs. pgvector Truncation Trap Correctness Benchmark
-            runTruncationTrapBenchmark();
-
-            // Run 3: Multi-Segment Parallel Scatter-Gather Scan Benchmark
-            runParallelSegmentScansBenchmark();
-            
-        } finally {
-            // Cleanup
-            deleteDirectory(walDir);
-        }
-    }
-
-    // ─── Benchmark 1: Hebbian Plasticity CAS Throughput ───
-
-    private static void runPlasticityCasBenchmark(Path walDir) throws Exception {
-        System.out.println("▶ Benchmark 1: Hebbian Plasticity CAS Throughput");
-        
-        // Open file-backed MemoryWal
-        try (MemoryWal wal = new MemoryWal(walDir, 8L * 1024 * 1024, false, 1024, false)) {
-            // Append some base memories
-            for (int i = 0; i < 1000; i++) {
-                wal.appendRemember("mem-" + i, new byte[]{1});
-            }
-
-            ExecutorService executor = Executors.newFixedThreadPool(CONCURRENCY_THREADS);
-            AtomicLong totalOps = new AtomicLong();
-            long t0 = System.nanoTime();
-
-            List<Future<?>> futures = new ArrayList<>();
-            for (int t = 0; t < CONCURRENCY_THREADS; t++) {
-                final int threadId = t;
-                futures.add(executor.submit(() -> {
-                    Random rng = new Random(threadId);
-                    for (int i = 0; i < MEASURE_ITERATIONS; i++) {
-                        String targetMemId = "mem-" + rng.nextInt(1000);
-                        // Simulate a Hops recall-hit counters CAS increment or reinforcement mutation
-                        wal.appendReinforce(targetMemId, (byte) (rng.nextInt(128) - 64));
-                        totalOps.incrementAndGet();
-                    }
-                }));
-            }
-
-            for (var f : futures) f.get();
-            long elapsedNanos = System.nanoTime() - t0;
-            executor.shutdown();
-
-            double seconds = elapsedNanos / 1e9;
-            double throughput = totalOps.get() / seconds;
-            double avgLatencyUs = (elapsedNanos / (double) totalOps.get()) / 1000.0;
-
-            System.out.printf("  Threads: %2d  |  Total Mutations: %,d%n", CONCURRENCY_THREADS, totalOps.get());
-            System.out.printf("  Plasticity Throughput: %,.0f ops/sec%n", throughput);
-            System.out.printf("  Average CAS Latency  : %.2f µs%n", avgLatencyUs);
-            System.out.println();
-        }
-    }
-
-    // ─── Benchmark 2: Fused SIMD vs. pgvector Truncation Trap ───
-
-    private static void runTruncationTrapBenchmark() {
-        System.out.println("▶ Benchmark 2: Fused SIMD vs. pgvector Truncation Trap (Recall Correctness)");
-        
-        Random rng = new Random(42);
-        
-        // Generate mock cognitive memories with varying vectors, valence, tags, and importance scores
-        List<MockMemoryNode> nodes = new ArrayList<>(DATASET_SIZE);
-        for (int i = 0; i < DATASET_SIZE; i++) {
-            float[] vec = randomVector(DIMENSIONS, rng);
-            float importance = rng.nextFloat() * 10f; // importance score 0-10
-            byte valence = (byte) (rng.nextInt(128) - 64); // signed valence
-            long tags = rng.nextLong(); // bloom tags
-            nodes.add(new MockMemoryNode("mem-" + i, vec, importance, valence, tags));
-        }
-
-        // Generate query vector
-        float[] queryVec = randomVector(DIMENSIONS, rng);
-        long targetTagFilter = 0x7L; // filter condition: must have specific bloom flags set
-        
-        // 1. Fused Cognitive Scoring: Evaluate Fused L2 + importance + tags simultaneously over ALL records
-        List<MockScoredResult> fusedResults = new ArrayList<>();
-        for (var node : nodes) {
-            // Tag filtering
-            if ((node.tags & targetTagFilter) != targetTagFilter) {
-                continue;
-            }
-            float l2Dist = computeEuclideanDistance(queryVec, node.vector);
-            // Fuse score: lower Euclidean distance + higher importance + absolute valence
-            float cognitiveScore = (10f - l2Dist) + (node.importance * 0.5f) + (Math.abs(node.valence) * 0.05f);
-            fusedResults.add(new MockScoredResult(node.id, cognitiveScore));
-        }
-        fusedResults.sort((a, b) -> Float.compare(b.score, a.score)); // descending
-        List<MockScoredResult> top10Fused = fusedResults.subList(0, Math.min(10, fusedResults.size()));
-
-        // 2. pgvector-style Search: Retrieve top-50 pure vector Euclidean distance matches, THEN apply cognitive filter
-        List<MockScoredResult> vectorResults = new ArrayList<>();
-        for (var node : nodes) {
-            float l2Dist = computeEuclideanDistance(queryVec, node.vector);
-            vectorResults.add(new MockScoredResult(node.id, l2Dist, node)); // score = l2Dist (lower is better)
-        }
-        vectorResults.sort((a, b) -> Float.compare(a.score, b.score)); // ascending L2
-        List<MockScoredResult> top50Vector = vectorResults.subList(0, Math.min(50, vectorResults.size()));
-
-        // Post-filter the pre-truncated top-50 set
-        List<MockScoredResult> postFilteredResults = new ArrayList<>();
-        for (var res : top50Vector) {
-            MockMemoryNode node = res.node;
-            if ((node.tags & targetTagFilter) != targetTagFilter) {
-                continue;
-            }
-            float cognitiveScore = (10f - res.score) + (node.importance * 0.5f) + (Math.abs(node.valence) * 0.05f);
-            postFilteredResults.add(new MockScoredResult(node.id, cognitiveScore));
-        }
-        postFilteredResults.sort((a, b) -> Float.compare(b.score, a.score));
-
-        // Calculate overlap / recall loss
-        Set<String> fusedIds = new HashSet<>();
-        for (var r : top10Fused) fusedIds.add(r.id);
-
-        int overlap = 0;
-        for (int i = 0; i < Math.min(10, postFilteredResults.size()); i++) {
-            if (fusedIds.contains(postFilteredResults.get(i).id)) {
-                overlap++;
-            }
-        }
-
-        double recallErrorPercent = (10 - overlap) * 10.0;
-
-        System.out.printf("  Total Candidates meeting filter criteria: %,d%n", fusedResults.size());
-        System.out.println("  Top-10 Fused Cognitive Matches (Spector SIMD):");
-        int showFusedCount = Math.min(3, top10Fused.size());
-        for (int i = 0; i < showFusedCount; i++) {
-            System.out.printf("    #%d: id=%s  score=%.2f%n", i + 1, top10Fused.get(i).id, top10Fused.get(i).score);
-        }
-        System.out.println("  Top-10 pgvector-Style Post-Filtered Matches (External DB):");
-        int showCount = Math.min(3, postFilteredResults.size());
-        for (int i = 0; i < showCount; i++) {
-            System.out.printf("    #%d: id=%s  score=%.2f%n", i + 1, postFilteredResults.get(i).id, postFilteredResults.get(i).score);
-        }
-        System.out.println();
-        System.out.printf("  [TRUNCATION TRAP METRIC] Overlap: %d/10  |  Recall Loss Error: %.1f%%%n", overlap, recallErrorPercent);
-        System.out.println("  Verdict: " + (recallErrorPercent > 0 
-                ? "⚠️ Truncation Trap Verified! External DB missed high-importance cognitive nodes." 
-                : "Perfect overlap (low-selectivity filter)"));
-        System.out.println();
-    }
-
-    // ─── Benchmark 3: Multi-Segment Parallel Scatter-Gather Scans ───
-
-    private static void runParallelSegmentScansBenchmark() throws Exception {
-        System.out.println("▶ Benchmark 3: Parallel Scatter-Gather Segment Scans (Loom vs. Bandwidth)");
-        
-        int numSegments = 16;
-        int elementsPerSegment = 10000;
-        
-        System.out.printf("  Simulating parallel scans over %d partition segments (%d elements/segment)...%n", 
-                numSegments, elementsPerSegment);
-
-        ExecutorService loomExecutor = Executors.newVirtualThreadPerTaskExecutor();
-        float[] queryVec = randomVector(DIMENSIONS, new Random(42));
-        AtomicLong elementsScanned = new AtomicLong();
-
-        long t0 = System.nanoTime();
-        List<Future<Double>> futures = new ArrayList<>();
-        
-        for (int s = 0; s < numSegments; s++) {
-            final int segmentId = s;
-            futures.add(loomExecutor.submit(() -> {
-                Random rng = new Random(segmentId);
-                // Pre-allocate segment array to simulate off-heap segment scan
-                float[][] segmentVectors = new float[elementsPerSegment][DIMENSIONS];
-                for (int i = 0; i < elementsPerSegment; i++) {
-                    segmentVectors[i] = randomVector(DIMENSIONS, rng);
-                }
-                
-                double bestDist = Double.MAX_VALUE;
-                for (int i = 0; i < elementsPerSegment; i++) {
-                    double dist = computeEuclideanDistance(queryVec, segmentVectors[i]);
-                    bestDist = Math.min(bestDist, dist);
-                    elementsScanned.incrementAndGet();
-                }
-                return bestDist;
-            }));
-        }
-
-        for (var f : futures) f.get();
-        long elapsedNanos = System.nanoTime() - t0;
-        loomExecutor.shutdown();
-
-        double milliseconds = elapsedNanos / 1e6;
-        double throughput = elementsScanned.get() / (elapsedNanos / 1e9);
-
-        System.out.printf("  Scanned %,d vectors sequentially across %d virtual threads.%n", 
-                elementsScanned.get(), numSegments);
-        System.out.printf("  Wall-Clock Scan Duration: %.2f ms%n", milliseconds);
-        System.out.printf("  Aggregate Scan Rate     : %,.0f vectors/sec (SIMD/Loom bound)%n", throughput);
-        System.out.println();
-    }
-
-    // ─── Helpers ───
-
-    private static float[] randomVector(int dim, Random rng) {
-        float[] v = new float[dim];
-        for (int i = 0; i < dim; i++) {
-            v[i] = rng.nextFloat() * 2f - 1f;
-        }
-        return v;
-    }
-
-    private static float computeEuclideanDistance(float[] a, float[] b) {
-        float sum = 0f;
-        for (int i = 0; i < a.length; i++) {
-            float diff = a[i] - b[i];
-            sum += diff * diff;
-        }
-        return (float) Math.sqrt(sum);
-    }
-
-    private static void deleteDirectory(Path path) throws IOException {
-        if (Files.exists(path)) {
-            try (var stream = Files.walk(path)) {
-                stream.sorted(Comparator.reverseOrder())
-                      .forEach(p -> {
-                          try {
-                              Files.delete(p);
-                          } catch (IOException e) {
-                              // ignore
-                          }
-                      });
-            }
-        }
-    }
-
-    // ─── Inner Mock Classes ───
-
-    private static class MockMemoryNode {
-        String id;
-        float[] vector;
-        float importance;
-        byte valence;
-        long tags;
-
-        MockMemoryNode(String id, float[] vector, float importance, byte valence, long tags) {
-            this.id = id;
-            this.vector = vector;
-            this.importance = importance;
-            this.valence = valence;
-            this.tags = tags;
-        }
-    }
-
-    private static class MockScoredResult {
-        String id;
-        float score;
-        MockMemoryNode node;
-
-        MockScoredResult(String id, float score) {
-            this.id = id;
-            this.score = score;
-        }
-
-        MockScoredResult(String id, float score, MockMemoryNode node) {
-            this.id = id;
-            this.score = score;
-            this.node = node;
-        }
-    }
-}
diff --git a/spector-bench/src/main/java/com/spectrayan/spector/bench/ConcurrencyBenchmark.java b/spector-bench/src/main/java/com/spectrayan/spector/bench/ConcurrencyBenchmark.java
index 0ac0a75..2c24ca5 100644
--- a/spector-bench/src/main/java/com/spectrayan/spector/bench/ConcurrencyBenchmark.java
+++ b/spector-bench/src/main/java/com/spectrayan/spector/bench/ConcurrencyBenchmark.java
@@ -1,25 +1,9 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.bench;
 
-import com.spectrayan.spector.core.similarity.SimilarityFunction;
-import com.spectrayan.spector.config.SpectorConfig;
-import com.spectrayan.spector.engine.DefaultSpectorEngine;
+import com.spectrayan.spector.core.SimilarityFunction;
+import com.spectrayan.spector.engine.SpectorConfig;
 import com.spectrayan.spector.engine.SpectorEngine;
-import com.spectrayan.spector.config.HnswParams;
+import com.spectrayan.spector.index.HnswParams;
 import com.spectrayan.spector.query.SearchQuery;
 
 import org.openjdk.jmh.annotations.*;
@@ -69,7 +53,7 @@ public void setup() {
         var hnswParams = new HnswParams(16, 200, 64);
         var config = new SpectorConfig(DIMENSIONS, DATASET_SIZE + 1000,
                 SimilarityFunction.COSINE, hnswParams);
-        engine = new DefaultSpectorEngine(config);
+        engine = new SpectorEngine(config);
 
         Random rng = new Random(42);
         for (int i = 0; i < DATASET_SIZE; i++) {
diff --git a/spector-bench/src/main/java/com/spectrayan/spector/bench/CorePerformanceBenchmark.java b/spector-bench/src/main/java/com/spectrayan/spector/bench/CorePerformanceBenchmark.java
deleted file mode 100644
index 2a8f2db..0000000
--- a/spector-bench/src/main/java/com/spectrayan/spector/bench/CorePerformanceBenchmark.java
+++ /dev/null
@@ -1,751 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.bench;
-
-import com.spectrayan.spector.config.SpectorConfig;
-import com.spectrayan.spector.config.HnswParams;
-import com.spectrayan.spector.core.simd.SimdCapability;
-import com.spectrayan.spector.core.similarity.SimilarityFunction;
-import com.spectrayan.spector.engine.DefaultSpectorEngine;
-import com.spectrayan.spector.engine.SpectorEngine;
-
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.OutputStream;
-import java.lang.management.GarbageCollectorMXBean;
-import java.lang.management.ManagementFactory;
-import java.net.ServerSocket;
-import java.net.Socket;
-import java.nio.charset.StandardCharsets;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.time.LocalDateTime;
-import java.time.format.DateTimeFormatter;
-import java.util.*;
-import java.util.concurrent.*;
-import java.util.concurrent.atomic.AtomicLong;
-
-/**
- * Core performance benchmark suite for Spector.
- *
- * <p>Measures the fundamental performance characteristics of the in-process
- * SIMD-accelerated search engine: latency, throughput, GC impact, scalability,
- * and fused cognitive scoring correctness.</p>
- *
- * <h3>Benchmarks</h3>
- * <ul>
- *   <li>In-process vs network latency comparison</li>
- *   <li>Vector search latency at 10K/50K/100K scale</li>
- *   <li>GC pressure during sustained search</li>
- *   <li>Concurrent QPS scaling (1–64 threads)</li>
- *   <li>Search latency at 100K → 1M scale</li>
- *   <li>Fused cognitive scoring vs top-K-then-rerank</li>
- * </ul>
- *
- * <p>Run: {@code mvn -pl spector-bench exec:exec
- *   -Dexec.mainClass=com.spectrayan.spector.bench.CorePerformanceBenchmark}</p>
- */
-public class CorePerformanceBenchmark {
-
-    // ─────────────── Configuration ───────────────
-
-    private static final int DIMS = 384;
-    private static final int WARMUP_QUERIES = 500;
-    private static final int MEASURE_QUERIES = 2000;
-    private static final int TOP_K = 10;
-    private static final int NUM_CLUSTERS = 50;
-
-    // C5: Incremental scaling
-    private static final int[] SCALE_SIZES = {100_000, 300_000, 500_000, 700_000, 1_000_000};
-    private static final int SCALE_DIMS = 128; // keep smaller for 1M
-
-    // Results
-    private final List<String[]> verdicts = new ArrayList<>();
-
-    // ─────────────── Main ───────────────
-
-    public static void main(String[] args) throws Exception {
-        new CorePerformanceBenchmark().run();
-    }
-
-    public void run() throws Exception {
-        System.out.println("╔══════════════════════════════════════════════════════════════╗");
-        System.out.println("║   SPECTOR SEARCH — CORE PERFORMANCE BENCHMARK               ║");
-        System.out.println("╚══════════════════════════════════════════════════════════════╝");
-        System.out.println();
-        printSystemInfo();
-        System.out.println();
-
-        // C1: MCP latency comparison
-        runC1_McpLatencyComparison();
-
-        // C2: Search latency at scale
-        runC2_SearchLatency();
-
-        // C3: GC pressure
-        runC3_GcPressure();
-
-        // C4: QPS with virtual threads
-        runC4_ConcurrentQps();
-
-        // C5: Recall at 1M memories (incremental)
-        runC5_ScaleLatency();
-
-        // C6: Truncation trap
-        runC6_TruncationTrap();
-
-        // Summary
-        printVerdictTable();
-
-        // Write report
-        writeReport();
-    }
-
-    // ═══════════════════════════════════════════════════════════════
-    //  C1: "100× faster than Python MCP servers"
-    // ═══════════════════════════════════════════════════════════════
-
-    private void runC1_McpLatencyComparison() throws Exception {
-        System.out.println("▶ C1: MCP In-Process vs Network Roundtrip");
-
-        // Build a small engine for in-process measurement
-        var config = new SpectorConfig(DIMS, 11_000, SimilarityFunction.COSINE,
-                new HnswParams(16, 200, 64));
-        SpectorEngine engine = new DefaultSpectorEngine(config);
-        Random rng = new Random(42);
-
-        float[][] vectors = generateClusteredVectors(10_000, DIMS, rng);
-        for (int i = 0; i < 10_000; i++) {
-            engine.ingest("doc-" + i, "content " + i, vectors[i]);
-        }
-
-        // Warmup in-process
-        float[] qv = perturbVector(vectors[0], 0.3f, DIMS, new Random(999));
-        for (int i = 0; i < 200; i++) engine.vectorSearch(qv, TOP_K);
-
-        // Measure in-process search latency (what Spector MCP does)
-        long[] inProcessNanos = new long[MEASURE_QUERIES];
-        for (int i = 0; i < MEASURE_QUERIES; i++) {
-            long t0 = System.nanoTime();
-            engine.vectorSearch(qv, TOP_K);
-            inProcessNanos[i] = System.nanoTime() - t0;
-        }
-        var inProcessStats = computeStats(inProcessNanos);
-
-        // Measure actual localhost TCP roundtrip (network floor)
-        long[] networkNanos = measureLocalhostRoundtrip(1000);
-        var networkStats = computeStats(networkNanos);
-
-        double spectorUs = inProcessStats.p50 / 1000.0;
-
-        // Python MCP reference: README states 2–10ms for "network + Python GIL" based on
-        // typical Chroma/Weaviate/Qdrant MCP servers. We compare against both ends:
-        double pythonLowMs = 2.0;   // optimistic: well-tuned Python, localhost
-        double pythonHighMs = 10.0; // realistic: network + GIL + framework overhead
-        double speedupVsLow = (pythonLowMs * 1000) / spectorUs;
-        double speedupVsHigh = (pythonHighMs * 1000) / spectorUs;
-
-        // Also compute measured overhead: network roundtrip + JSON (conservative 200µs)
-        double measuredOverheadUs = (networkStats.mean / 1000.0) + 200;
-        double measuredSpeedup = (measuredOverheadUs + spectorUs) / spectorUs;
-
-        System.out.printf("  Spector in-process:       p50=%.0fµs  p99=%.0fµs  avg=%.0fµs%n",
-                spectorUs, inProcessStats.p99 / 1000.0, inProcessStats.mean / 1000.0);
-        System.out.printf("  Localhost TCP roundtrip:   p50=%.0fµs  p99=%.0fµs  avg=%.0fµs%n",
-                networkStats.p50 / 1000.0, networkStats.p99 / 1000.0, networkStats.mean / 1000.0);
-        System.out.println();
-        System.out.printf("  vs measured network floor: %.0f× (%.0fµs network+JSON overhead)%n",
-                measuredSpeedup, measuredOverheadUs);
-        System.out.printf("  vs Python MCP (2ms low):  %.0f× (Spector %.0fµs vs Python 2,000µs)%n",
-                speedupVsLow, spectorUs);
-        System.out.printf("  vs Python MCP (10ms high): %.0f× (Spector %.0fµs vs Python 10,000µs)%n",
-                speedupVsHigh, spectorUs);
-        System.out.println();
-
-        engine.close();
-
-        // The README claim "100×" refers to the high end (10ms Python MCP)
-        String verdict = speedupVsHigh >= 100 ? "✅ VALIDATED" :
-                (speedupVsLow >= 20 ? "⚠️ PARTIAL (" + String.format("%.0f–%.0f×", speedupVsLow, speedupVsHigh) + ")" :
-                        "❌ FAILED");
-        verdicts.add(new String[]{"C1: 100× faster than Python MCP",
-                String.format("%.0f–%.0f×", speedupVsLow, speedupVsHigh), verdict});
-    }
-
-    /**
-     * Measures actual localhost TCP roundtrip: connect → write → read → close.
-     * Simulates the absolute minimum network overhead a Python MCP server would have.
-     */
-    private long[] measureLocalhostRoundtrip(int iterations) throws Exception {
-        // Start a tiny echo server on localhost
-        try (ServerSocket serverSocket = new ServerSocket(0)) {
-            int port = serverSocket.getLocalPort();
-            serverSocket.setSoTimeout(5000);
-
-            // Echo server in background
-            Thread echoThread = Thread.ofVirtual().start(() -> {
-                try {
-                    for (int i = 0; i < iterations; i++) {
-                        try (Socket client = serverSocket.accept()) {
-                            InputStream in = client.getInputStream();
-                            OutputStream out = client.getOutputStream();
-                            byte[] buf = new byte[256];
-                            int n = in.read(buf);
-                            if (n > 0) out.write(buf, 0, n);
-                        }
-                    }
-                } catch (Exception e) {
-                    // server stopping
-                }
-            });
-
-            // Measure client roundtrips
-            long[] nanos = new long[iterations];
-            byte[] payload = "{\"tool\":\"vector_search\",\"query\":[0.1,0.2],\"top_k\":10}".getBytes(StandardCharsets.UTF_8);
-
-            for (int i = 0; i < iterations; i++) {
-                long t0 = System.nanoTime();
-                try (Socket sock = new Socket("127.0.0.1", port)) {
-                    sock.getOutputStream().write(payload);
-                    sock.getOutputStream().flush();
-                    byte[] resp = new byte[256];
-                    sock.getInputStream().read(resp);
-                }
-                nanos[i] = System.nanoTime() - t0;
-            }
-
-            echoThread.join(3000);
-            return nanos;
-        }
-    }
-
-    // ═══════════════════════════════════════════════════════════════
-    //  C2: "50–200µs search latency"
-    // ═══════════════════════════════════════════════════════════════
-
-    private void runC2_SearchLatency() {
-        System.out.println("▶ C2: Vector Search Latency at Scale");
-
-        int[] sizes = {10_000, 50_000, 100_000};
-        boolean allPassed = true;
-
-        for (int size : sizes) {
-            var config = new SpectorConfig(DIMS, size + 1000, SimilarityFunction.COSINE,
-                    new HnswParams(16, 200, 64));
-            SpectorEngine engine = new DefaultSpectorEngine(config);
-            Random rng = new Random(42);
-
-            float[][] vectors = generateClusteredVectors(size, DIMS, rng);
-            for (int i = 0; i < size; i++) {
-                engine.ingest("doc-" + i, "content " + i, vectors[i]);
-            }
-
-            float[] qv = perturbVector(vectors[0], 0.3f, DIMS, new Random(999));
-
-            // Warmup
-            for (int i = 0; i < WARMUP_QUERIES; i++) engine.vectorSearch(qv, TOP_K);
-
-            // Measure
-            long[] nanos = new long[MEASURE_QUERIES];
-            for (int i = 0; i < MEASURE_QUERIES; i++) {
-                long t0 = System.nanoTime();
-                engine.vectorSearch(qv, TOP_K);
-                nanos[i] = System.nanoTime() - t0;
-            }
-            var stats = computeStats(nanos);
-
-            double p50Us = stats.p50 / 1000.0;
-            double p99Us = stats.p99 / 1000.0;
-            String sizeLabel = size / 1000 + "K";
-            System.out.printf("  %5s docs: p50=%.0fµs  p95=%.0fµs  p99=%.0fµs  QPS=%.0f%n",
-                    sizeLabel, p50Us, stats.p95 / 1000.0, p99Us, 1e9 / stats.mean);
-
-            // Pass criteria: p50 < 1ms for all sizes
-            if (p50Us > 1000) allPassed = false;
-
-            engine.close();
-        }
-
-        System.out.println();
-        String verdict = allPassed ? "✅ VALIDATED" : "❌ FAILED";
-        verdicts.add(new String[]{"C2: 50–200µs search latency", "see above", verdict});
-    }
-
-    // ═══════════════════════════════════════════════════════════════
-    //  C3: "Zero GC pressure — 100% off-heap Panama"
-    // ═══════════════════════════════════════════════════════════════
-
-    private void runC3_GcPressure() {
-        System.out.println("▶ C3: Zero GC Pressure During Sustained Search");
-
-        var config = new SpectorConfig(DIMS, 11_000, SimilarityFunction.COSINE,
-                new HnswParams(16, 200, 64));
-        SpectorEngine engine = new DefaultSpectorEngine(config);
-        Random rng = new Random(42);
-
-        float[][] vectors = generateClusteredVectors(10_000, DIMS, rng);
-        for (int i = 0; i < 10_000; i++) {
-            engine.ingest("doc-" + i, "content " + i, vectors[i]);
-        }
-
-        float[] qv = perturbVector(vectors[0], 0.3f, DIMS, new Random(999));
-
-        // Warmup
-        for (int i = 0; i < WARMUP_QUERIES; i++) engine.vectorSearch(qv, TOP_K);
-
-        // Force GC before measurement
-        System.gc();
-        try { Thread.sleep(200); } catch (InterruptedException e) { /* ignore */ }
-
-        // Record GC state before
-        long gcCountBefore = totalGcCount();
-        long gcTimeBefore = totalGcTimeMs();
-
-        // Run 100K searches
-        int searchCount = 100_000;
-        long t0 = System.nanoTime();
-        for (int i = 0; i < searchCount; i++) {
-            engine.vectorSearch(qv, TOP_K);
-        }
-        long elapsed = System.nanoTime() - t0;
-
-        // Record GC state after
-        long gcCountAfter = totalGcCount();
-        long gcTimeAfter = totalGcTimeMs();
-
-        long gcPauses = gcCountAfter - gcCountBefore;
-        long gcTimeMs = gcTimeAfter - gcTimeBefore;
-        double searchMs = elapsed / 1e6;
-
-        System.out.printf("  Searches executed:  %,d%n", searchCount);
-        System.out.printf("  Total wall time:    %.1f ms%n", searchMs);
-        System.out.printf("  GC pauses during:   %d%n", gcPauses);
-        System.out.printf("  GC time during:     %d ms%n", gcTimeMs);
-        System.out.printf("  GC overhead:        %.4f%%%n", (gcTimeMs / searchMs) * 100);
-        System.out.println();
-
-        engine.close();
-
-        // Pass: ≤2 GC pauses (some minor GC may be unavoidable from JVM bookkeeping)
-        String verdict = gcPauses <= 2 ? "✅ VALIDATED" : "⚠️ PARTIAL";
-        verdicts.add(new String[]{"C3: Zero GC pressure",
-                gcPauses + " pauses, " + gcTimeMs + "ms", verdict});
-    }
-
-    private long totalGcCount() {
-        return ManagementFactory.getGarbageCollectorMXBeans().stream()
-                .mapToLong(GarbageCollectorMXBean::getCollectionCount)
-                .filter(c -> c >= 0).sum();
-    }
-
-    private long totalGcTimeMs() {
-        return ManagementFactory.getGarbageCollectorMXBeans().stream()
-                .mapToLong(GarbageCollectorMXBean::getCollectionTime)
-                .filter(c -> c >= 0).sum();
-    }
-
-    // ═══════════════════════════════════════════════════════════════
-    //  C4: "10,000+ QPS with Virtual Threads"
-    // ═══════════════════════════════════════════════════════════════
-
-    private void runC4_ConcurrentQps() throws Exception {
-        System.out.println("▶ C4: Concurrent QPS Scaling");
-
-        var config = new SpectorConfig(DIMS, 51_000, SimilarityFunction.COSINE,
-                new HnswParams(16, 200, 64));
-        SpectorEngine engine = new DefaultSpectorEngine(config);
-        Random rng = new Random(42);
-
-        float[][] vectors = generateClusteredVectors(50_000, DIMS, rng);
-        for (int i = 0; i < 50_000; i++) {
-            engine.ingest("doc-" + i, "content " + i, vectors[i]);
-        }
-
-        float[] qv = perturbVector(vectors[0], 0.3f, DIMS, new Random(999));
-        // Warmup (use vectorSearch — hybridSearch requires --enable-preview via ConcurrentTasks)
-        for (int i = 0; i < 200; i++) engine.vectorSearch(qv, TOP_K);
-
-        int[] threadCounts = {1, 4, 8, 16, 32, 64};
-        double maxQps = 0;
-
-        for (int threads : threadCounts) {
-            int opsPerThread = 500;
-            ExecutorService executor = Executors.newFixedThreadPool(threads);
-            AtomicLong totalOps = new AtomicLong();
-
-            long wallStart = System.nanoTime();
-            List<Future<?>> futures = new ArrayList<>();
-
-            for (int t = 0; t < threads; t++) {
-                final int tid = t;
-                futures.add(executor.submit(() -> {
-                    Random trng = new Random(tid + 1000);
-                    float[] threadQv = perturbVector(vectors[trng.nextInt(50_000)], 0.3f, DIMS, trng);
-                    for (int i = 0; i < opsPerThread; i++) {
-                        engine.vectorSearch(threadQv, TOP_K);
-                        totalOps.incrementAndGet();
-                    }
-                }));
-            }
-            for (var f : futures) f.get();
-            long wallElapsed = System.nanoTime() - wallStart;
-            executor.shutdown();
-
-            double qps = totalOps.get() / (wallElapsed / 1e9);
-            maxQps = Math.max(maxQps, qps);
-
-            System.out.printf("  threads=%2d  QPS=%,.0f  total_ops=%,d%n", threads, qps, totalOps.get());
-        }
-
-        System.out.println();
-        engine.close();
-
-        String verdict = maxQps >= 10_000 ? "✅ VALIDATED" :
-                (maxQps >= 5_000 ? "⚠️ PARTIAL" : "❌ FAILED");
-        verdicts.add(new String[]{"C4: 10,000+ QPS",
-                String.format("%,.0f QPS", maxQps), verdict});
-    }
-
-    // ═══════════════════════════════════════════════════════════════
-    //  C5: "~2ms recall at 1M memories" (incremental scaling)
-    // ═══════════════════════════════════════════════════════════════
-
-    private void runC5_ScaleLatency() {
-        System.out.println("▶ C5: Search Latency at Scale (100K → 1M)");
-
-        var hnswParams = new HnswParams(16, 200, 64);
-        var config = new SpectorConfig(SCALE_DIMS, 1_100_000, SimilarityFunction.COSINE, hnswParams);
-
-        SpectorEngine engine = new DefaultSpectorEngine(config);
-        Random rng = new Random(42);
-
-        int ingested = 0;
-        double latencyAt1M = -1;
-
-        for (int targetSize : SCALE_SIZES) {
-            // Ingest incrementally
-            while (ingested < targetSize) {
-                float[] vec = randomVector(SCALE_DIMS, rng);
-                engine.ingest("mem-" + ingested, "memory content " + ingested, vec);
-                ingested++;
-
-                // Progress every 100K
-                if (ingested % 100_000 == 0) {
-                    System.out.printf("    Ingested %,d...%n", ingested);
-                }
-            }
-
-            // Measure search latency at this scale
-            float[] qv = randomVector(SCALE_DIMS, new Random(999));
-
-            // Warmup
-            for (int i = 0; i < 100; i++) engine.vectorSearch(qv, TOP_K);
-
-            long[] nanos = new long[500];
-            for (int i = 0; i < 500; i++) {
-                long t0 = System.nanoTime();
-                engine.vectorSearch(qv, TOP_K);
-                nanos[i] = System.nanoTime() - t0;
-            }
-            var stats = computeStats(nanos);
-            double p50Ms = stats.p50 / 1e6;
-            double p99Ms = stats.p99 / 1e6;
-
-            System.out.printf("  %,7d memories: p50=%.2fms  p99=%.2fms  QPS=%.0f%n",
-                    targetSize, p50Ms, p99Ms, 1e9 / stats.mean);
-
-            if (targetSize == 1_000_000) latencyAt1M = p50Ms;
-        }
-
-        System.out.println();
-        engine.close();
-
-        String verdict = latencyAt1M <= 5.0 ? "✅ VALIDATED" :
-                (latencyAt1M <= 10.0 ? "⚠️ PARTIAL" : "❌ FAILED");
-        verdicts.add(new String[]{"C5: ~2ms at 1M memories",
-                String.format("p50=%.2fms", latencyAt1M), verdict});
-    }
-
-    // ═══════════════════════════════════════════════════════════════
-    //  C6: "Fused scoring — no truncation trap"
-    // ═══════════════════════════════════════════════════════════════
-
-    private void runC6_TruncationTrap() {
-        System.out.println("▶ C6: Fused Scoring vs Top-K-Then-Rerank (Truncation Trap)");
-
-        int datasetSize = 50_000;
-        Random rng = new Random(42);
-
-        // Generate memories with cognitive metadata
-        List<CognitiveNode> nodes = new ArrayList<>(datasetSize);
-        for (int i = 0; i < datasetSize; i++) {
-            float[] vec = randomVector(DIMS, rng);
-            float importance = rng.nextFloat() * 10f;
-            byte valence = (byte) (rng.nextInt(128) - 64);
-            long tags = rng.nextLong();
-            float decayFactor = 0.3f + rng.nextFloat() * 0.7f; // 0.3–1.0
-            nodes.add(new CognitiveNode("mem-" + i, vec, importance, valence, tags, decayFactor));
-        }
-
-        float[] queryVec = randomVector(DIMS, new Random(999));
-        long tagFilter = 0x7L; // require specific bloom bits
-
-        // ── Strategy 1: Fused Cognitive Scoring (Spector) ──
-        // Evaluate ALL candidates with combined score: similarity + importance × decay + valence
-        List<ScoredResult> fusedResults = new ArrayList<>();
-        for (var node : nodes) {
-            if ((node.tags & tagFilter) != tagFilter) continue;
-            float sim = cosineSim(queryVec, node.vector);
-            float cogScore = sim + (node.importance * node.decayFactor * 0.3f)
-                    + (Math.abs(node.valence) * 0.01f);
-            fusedResults.add(new ScoredResult(node.id, cogScore));
-        }
-        fusedResults.sort((a, b) -> Float.compare(b.score, a.score));
-        List<ScoredResult> fusedTop10 = fusedResults.subList(0, Math.min(10, fusedResults.size()));
-
-        // ── Strategy 2: pgvector-style (External DB) ──
-        // Top-50 by pure vector similarity, then post-filter with cognitive scoring
-        List<ScoredResult> vectorOnly = new ArrayList<>();
-        for (var node : nodes) {
-            float sim = cosineSim(queryVec, node.vector);
-            vectorOnly.add(new ScoredResult(node.id, sim, node));
-        }
-        vectorOnly.sort((a, b) -> Float.compare(b.score, a.score));
-        List<ScoredResult> top50Vec = vectorOnly.subList(0, Math.min(50, vectorOnly.size()));
-
-        // Post-filter
-        List<ScoredResult> postFiltered = new ArrayList<>();
-        for (var res : top50Vec) {
-            var node = res.node;
-            if ((node.tags & tagFilter) != tagFilter) continue;
-            float cogScore = res.score + (node.importance * node.decayFactor * 0.3f)
-                    + (Math.abs(node.valence) * 0.01f);
-            postFiltered.add(new ScoredResult(node.id, cogScore));
-        }
-        postFiltered.sort((a, b) -> Float.compare(b.score, a.score));
-
-        // Also test with top-100 and top-200
-        int[] truncationLevels = {50, 100, 200};
-        for (int topN : truncationLevels) {
-            List<ScoredResult> topNVec = vectorOnly.subList(0, Math.min(topN, vectorOnly.size()));
-            List<ScoredResult> reranked = new ArrayList<>();
-            for (var res : topNVec) {
-                var node = res.node;
-                if ((node.tags & tagFilter) != tagFilter) continue;
-                float cogScore = res.score + (node.importance * node.decayFactor * 0.3f)
-                        + (Math.abs(node.valence) * 0.01f);
-                reranked.add(new ScoredResult(node.id, cogScore));
-            }
-            reranked.sort((a, b) -> Float.compare(b.score, a.score));
-
-            Set<String> fusedIds = new HashSet<>();
-            for (var r : fusedTop10) fusedIds.add(r.id);
-
-            int overlap = 0;
-            for (int i = 0; i < Math.min(10, reranked.size()); i++) {
-                if (fusedIds.contains(reranked.get(i).id)) overlap++;
-            }
-            double recallLoss = (10 - overlap) * 10.0;
-
-            System.out.printf("  top-%d then rerank: overlap=%d/10  recall_loss=%.0f%%%n",
-                    topN, overlap, recallLoss);
-        }
-
-        // Use top-50 result for the verdict
-        Set<String> fusedIds = new HashSet<>();
-        for (var r : fusedTop10) fusedIds.add(r.id);
-        int overlap50 = 0;
-        for (int i = 0; i < Math.min(10, postFiltered.size()); i++) {
-            if (fusedIds.contains(postFiltered.get(i).id)) overlap50++;
-        }
-        double recallLoss50 = (10 - overlap50) * 10.0;
-
-        System.out.printf("%n  Candidates passing filter:  %,d / %,d%n", fusedResults.size(), datasetSize);
-        System.out.printf("  Truncation Trap recall loss (top-50): %.0f%%%n", recallLoss50);
-
-        // Show top-3 fused vs top-3 postfiltered
-        System.out.println("  Top-3 Fused (Spector):     " + formatTop3(fusedTop10));
-        System.out.println("  Top-3 External DB (top50): " + formatTop3(postFiltered));
-        System.out.println();
-
-        String verdict = recallLoss50 >= 20 ? "✅ VALIDATED" :
-                (recallLoss50 >= 10 ? "⚠️ PARTIAL" : "❌ NOT PROVEN");
-        verdicts.add(new String[]{"C6: Truncation trap proven",
-                String.format("%.0f%% recall loss", recallLoss50), verdict});
-    }
-
-    // ═══════════════════════════════════════════════════════════════
-    //  Results & Report
-    // ═══════════════════════════════════════════════════════════════
-
-    private void printVerdictTable() {
-        System.out.println("═══════════════════════════════════════════════════════════════");
-        System.out.println("                  CORE PERFORMANCE REPORT                     ");
-        System.out.println("═══════════════════════════════════════════════════════════════");
-        System.out.printf("  %-38s %-20s %-15s%n", "BENCHMARK", "RESULT", "VERDICT");
-        System.out.println("  " + "─".repeat(73));
-        for (var v : verdicts) {
-            System.out.printf("  %-38s %-20s %-15s%n", v[0], v[1], v[2]);
-        }
-        System.out.println("═══════════════════════════════════════════════════════════════");
-    }
-
-    private void writeReport() throws IOException {
-        StringBuilder sb = new StringBuilder();
-        sb.append("# Spector — Core Performance Report\n\n");
-        sb.append("**Generated:** ").append(LocalDateTime.now().format(DateTimeFormatter.ISO_LOCAL_DATE_TIME)).append("\n\n");
-
-        // System info
-        sb.append("## System\n\n");
-        sb.append("| Property | Value |\n");
-        sb.append("|---|---|\n");
-        sb.append("| OS | ").append(System.getProperty("os.name")).append(" ").append(System.getProperty("os.arch")).append(" |\n");
-        sb.append("| Java | ").append(System.getProperty("java.version")).append(" |\n");
-        sb.append("| CPUs | ").append(Runtime.getRuntime().availableProcessors()).append(" logical cores |\n");
-        sb.append("| CPU | ").append(getCpuModel()).append(" |\n");
-        sb.append("| Max Heap | ").append(Runtime.getRuntime().maxMemory() / (1024 * 1024)).append(" MB |\n");
-        sb.append("| SIMD | ").append(SimdCapability.report()).append(" |\n\n");
-
-        // Results
-        sb.append("## Results\n\n");
-        sb.append("| Benchmark | Result | Verdict |\n");
-        sb.append("|---|---|---|\n");
-        for (var v : verdicts) {
-            sb.append("| ").append(v[0]).append(" | ").append(v[1]).append(" | ").append(v[2]).append(" |\n");
-        }
-
-        Path reportPath = Path.of("spector-bench", "target", "core-performance-report.md");
-        Files.createDirectories(reportPath.getParent());
-        Files.writeString(reportPath, sb.toString());
-        System.out.printf("%nReport saved: %s%n", reportPath.toAbsolutePath());
-    }
-
-    // ─────────────── System Info ───────────────
-
-    private void printSystemInfo() {
-        long totalMem = Runtime.getRuntime().maxMemory() / (1024 * 1024);
-        System.out.printf("  OS:    %s %s%n", System.getProperty("os.name"), System.getProperty("os.arch"));
-        System.out.printf("  Java:  %s%n", System.getProperty("java.version"));
-        System.out.printf("  CPU:   %s (%d logical cores)%n", getCpuModel(), Runtime.getRuntime().availableProcessors());
-        System.out.printf("  Heap:  %d MB%n", totalMem);
-        System.out.printf("  SIMD:  %s%n", SimdCapability.report());
-        System.out.printf("  Time:  %s%n", LocalDateTime.now().format(DateTimeFormatter.ISO_LOCAL_DATE_TIME));
-    }
-
-    private static String getCpuModel() {
-        // Try Windows
-        try {
-            Process p = new ProcessBuilder("powershell", "-Command",
-                    "(Get-CimInstance Win32_Processor).Name").start();
-            String result = new String(p.getInputStream().readAllBytes()).trim();
-            p.waitFor();
-            if (!result.isBlank()) return result;
-        } catch (Exception ignored) {}
-        // Try Linux
-        try {
-            Process p = new ProcessBuilder("sh", "-c",
-                    "grep 'model name' /proc/cpuinfo | head -1 | cut -d: -f2").start();
-            String result = new String(p.getInputStream().readAllBytes()).trim();
-            p.waitFor();
-            if (!result.isBlank()) return result;
-        } catch (Exception ignored) {}
-        return System.getProperty("os.arch");
-    }
-
-    // ─────────────── Helpers ───────────────
-
-    private static float[] randomVector(int dim, Random rng) {
-        float[] v = new float[dim];
-        for (int i = 0; i < dim; i++) v[i] = rng.nextFloat() * 2f - 1f;
-        normalize(v);
-        return v;
-    }
-
-    private static float[][] generateClusteredVectors(int count, int dims, Random rng) {
-        float[][] centers = new float[NUM_CLUSTERS][dims];
-        for (int c = 0; c < NUM_CLUSTERS; c++) {
-            for (int d = 0; d < dims; d++) centers[c][d] = (float) rng.nextGaussian() * 0.5f;
-            normalize(centers[c]);
-        }
-        float[][] vectors = new float[count][dims];
-        for (int i = 0; i < count; i++) {
-            int cluster = rng.nextInt(NUM_CLUSTERS);
-            for (int d = 0; d < dims; d++) vectors[i][d] = centers[cluster][d] + (float) rng.nextGaussian() * 0.15f;
-            normalize(vectors[i]);
-        }
-        return vectors;
-    }
-
-    private static float[] perturbVector(float[] base, float noise, int dims, Random rng) {
-        float[] result = new float[dims];
-        for (int d = 0; d < dims; d++) result[d] = base[d] + (float) rng.nextGaussian() * noise;
-        normalize(result);
-        return result;
-    }
-
-    private static void normalize(float[] v) {
-        float norm = 0;
-        for (float f : v) norm += f * f;
-        norm = (float) Math.sqrt(norm);
-        if (norm > 1e-10f) for (int i = 0; i < v.length; i++) v[i] /= norm;
-    }
-
-    private static float cosineSim(float[] a, float[] b) {
-        float dot = 0, na = 0, nb = 0;
-        for (int i = 0; i < a.length; i++) {
-            dot += a[i] * b[i];
-            na += a[i] * a[i];
-            nb += b[i] * b[i];
-        }
-        return (float) (dot / (Math.sqrt(na) * Math.sqrt(nb) + 1e-10));
-    }
-
-    private String formatTop3(List<ScoredResult> results) {
-        StringBuilder sb = new StringBuilder();
-        for (int i = 0; i < Math.min(3, results.size()); i++) {
-            if (i > 0) sb.append(", ");
-            sb.append(results.get(i).id).append("(").append(String.format("%.3f", results.get(i).score)).append(")");
-        }
-        return sb.toString();
-    }
-
-    // ─────────────── Statistics ───────────────
-
-    record Stats(double min, double max, double mean, double p50, double p95, double p99) {}
-
-    private Stats computeStats(long[] nanos) {
-        Arrays.sort(nanos);
-        int n = nanos.length;
-        double sum = 0;
-        for (long v : nanos) sum += v;
-        return new Stats(nanos[0], nanos[n - 1], sum / n,
-                nanos[(int) (n * 0.50)], nanos[(int) (n * 0.95)], nanos[(int) (n * 0.99)]);
-    }
-
-    // ─────────────── Inner Types ───────────────
-
-    private record CognitiveNode(String id, float[] vector, float importance,
-                                  byte valence, long tags, float decayFactor) {}
-
-    private static class ScoredResult {
-        final String id;
-        final float score;
-        final CognitiveNode node;
-
-        ScoredResult(String id, float score) { this.id = id; this.score = score; this.node = null; }
-        ScoredResult(String id, float score, CognitiveNode node) { this.id = id; this.score = score; this.node = node; }
-    }
-}
diff --git a/spector-bench/src/main/java/com/spectrayan/spector/bench/DiskPersistenceBenchmark.java b/spector-bench/src/main/java/com/spectrayan/spector/bench/DiskPersistenceBenchmark.java
deleted file mode 100644
index bd19200..0000000
--- a/spector-bench/src/main/java/com/spectrayan/spector/bench/DiskPersistenceBenchmark.java
+++ /dev/null
@@ -1,610 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.bench;
-
-import com.spectrayan.spector.config.HnswParams;
-import com.spectrayan.spector.config.PersistenceMode;
-import com.spectrayan.spector.config.SpectorConfig;
-import com.spectrayan.spector.core.simd.SimdCapability;
-import com.spectrayan.spector.core.similarity.SimilarityFunction;
-import com.spectrayan.spector.embed.ollama.OllamaEmbeddingProvider;
-import com.spectrayan.spector.engine.DefaultSpectorEngine;
-import com.spectrayan.spector.engine.SpectorEngine;
-import com.spectrayan.spector.memory.*;
-import com.spectrayan.spector.memory.cortex.MemorySource;
-import com.spectrayan.spector.memory.sync.MemoryWal;
-
-import java.io.IOException;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.time.Duration;
-import java.time.Instant;
-import java.time.LocalDateTime;
-import java.time.format.DateTimeFormatter;
-import java.util.*;
-import java.util.concurrent.*;
-import java.util.concurrent.atomic.AtomicLong;
-
-/**
- * Benchmarks Spector in DISK persistence mode — engine index, cognitive memory,
- * and Write-Ahead Log (WAL) with real Ollama embeddings.
- *
- * <h3>Tests</h3>
- * <ul>
- *   <li>D1: Engine DISK mode — mmap'd sharded vector store search latency</li>
- *   <li>D2: Engine DISK mode — cold-start (first search after open) vs warm</li>
- *   <li>D3: Cognitive Memory — remember + recall with real Ollama embeddings</li>
- *   <li>D4: WAL — append throughput and replay speed (file-backed, fsync'd)</li>
- *   <li>D5: Memory DISK mode — full pipeline: ingest → recall → reinforce → reflect</li>
- * </ul>
- *
- * <p>Requires Ollama running at localhost:11434 with an embedding model.</p>
- *
- * <p>Run: {@code mvn exec:java -pl spector-bench
- *   -Dexec.mainClass=com.spectrayan.spector.bench.DiskPersistenceBenchmark}</p>
- */
-public class DiskPersistenceBenchmark {
-
-    // ─── Configuration ───
-    private static final int TOP_K = 10;
-    private static final String EMBEDDING_MODEL = "qwen3-embedding:latest";
-    private int DIMS;  // auto-detected from Ollama
-
-    private final List<String[]> verdicts = new ArrayList<>();
-
-    // ─── Main ───
-
-    public static void main(String[] args) throws Exception {
-        new DiskPersistenceBenchmark().run();
-    }
-
-    public void run() throws Exception {
-        System.out.println("╔══════════════════════════════════════════════════════════════╗");
-        System.out.println("║   SPECTOR — DISK PERSISTENCE + MEMORY BENCHMARK             ║");
-        System.out.println("╚══════════════════════════════════════════════════════════════╝");
-        System.out.println();
-        printSystemInfo();
-        System.out.println();
-
-        // Verify Ollama connectivity
-        OllamaEmbeddingProvider embedder = OllamaEmbeddingProvider.create(EMBEDDING_MODEL);
-        DIMS = embedder.dimensions();
-        System.out.printf("  Ollama model: %s (%d-dim)%n%n", EMBEDDING_MODEL, DIMS);
-
-        // D1: Engine DISK mode search latency
-        runD1_DiskEngineLatency(embedder);
-
-        // D2: Cold start vs warm
-        runD2_ColdVsWarm();
-
-        // D3: Cognitive memory with real embeddings
-        runD3_CognitiveMemoryRecall(embedder);
-
-        // D4: WAL throughput
-        runD4_WalThroughput();
-
-        // D5: Full memory pipeline
-        runD5_FullMemoryPipeline(embedder);
-
-        // Summary
-        printVerdictTable();
-        writeReport();
-    }
-
-    // ═══════════════════════════════════════════════════════════════
-    //  D1: Engine DISK mode — search latency with mmap'd vectors
-    // ═══════════════════════════════════════════════════════════════
-
-    private void runD1_DiskEngineLatency(OllamaEmbeddingProvider embedder) throws Exception {
-        System.out.println("▶ D1: Engine DISK Mode — Search Latency (mmap sharded store)");
-
-        Path dataDir = Files.createTempDirectory("spector-disk-bench");
-        int datasetSize = 5_000;
-
-        var config = new SpectorConfig(DIMS, datasetSize + 1000,
-                SimilarityFunction.COSINE, new HnswParams(16, 200, 64))
-                .withPersistence(PersistenceMode.DISK, dataDir);
-
-        SpectorEngine engine = new DefaultSpectorEngine(config);
-        Random rng = new Random(42);
-
-        // Ingest with synthetic vectors (skip Ollama for scale — embeddings are slow)
-        float[][] vectors = generateClusteredVectors(datasetSize, DIMS, rng);
-        Instant ingestStart = Instant.now();
-        for (int i = 0; i < datasetSize; i++) {
-            engine.ingest("doc-" + i, "document content " + i, vectors[i]);
-        }
-        Duration ingestTime = Duration.between(ingestStart, Instant.now());
-        System.out.printf("  Ingested %,d docs to disk in %.1fs (%.0f docs/s)%n",
-                datasetSize, ingestTime.toMillis() / 1000.0,
-                datasetSize / (ingestTime.toMillis() / 1000.0));
-
-        // Warmup
-        float[] qv = perturbVector(vectors[0], 0.3f, DIMS, new Random(999));
-        for (int i = 0; i < 200; i++) engine.vectorSearch(qv, TOP_K);
-
-        // Measure search
-        long[] nanos = new long[1000];
-        for (int i = 0; i < 1000; i++) {
-            long t0 = System.nanoTime();
-            engine.vectorSearch(qv, TOP_K);
-            nanos[i] = System.nanoTime() - t0;
-        }
-        var stats = computeStats(nanos);
-
-        System.out.printf("  DISK search: p50=%.0fµs  p95=%.0fµs  p99=%.0fµs  QPS=%.0f%n",
-                stats.p50 / 1000.0, stats.p95 / 1000.0, stats.p99 / 1000.0, 1e9 / stats.mean);
-
-        // Compare with IN_MEMORY baseline on same data
-        var memConfig = new SpectorConfig(DIMS, datasetSize + 1000,
-                SimilarityFunction.COSINE, new HnswParams(16, 200, 64));
-        SpectorEngine memEngine = new DefaultSpectorEngine(memConfig);
-        for (int i = 0; i < datasetSize; i++) {
-            memEngine.ingest("doc-" + i, "content " + i, vectors[i]);
-        }
-        for (int i = 0; i < 200; i++) memEngine.vectorSearch(qv, TOP_K);
-
-        long[] memNanos = new long[1000];
-        for (int i = 0; i < 1000; i++) {
-            long t0 = System.nanoTime();
-            memEngine.vectorSearch(qv, TOP_K);
-            memNanos[i] = System.nanoTime() - t0;
-        }
-        var memStats = computeStats(memNanos);
-
-        double overhead = (stats.p50 / memStats.p50 - 1.0) * 100;
-        System.out.printf("  IN_MEMORY:   p50=%.0fµs  p95=%.0fµs  p99=%.0fµs  QPS=%.0f%n",
-                memStats.p50 / 1000.0, memStats.p95 / 1000.0, memStats.p99 / 1000.0, 1e9 / memStats.mean);
-        System.out.printf("  DISK overhead: %.1f%% (vs IN_MEMORY p50)%n%n", overhead);
-
-        engine.close();
-        memEngine.close();
-        deleteDirectory(dataDir);
-
-        verdicts.add(new String[]{"D1: DISK search latency",
-                String.format("p50=%.0fµs (%.1f%% overhead)", stats.p50 / 1000.0, overhead),
-                overhead < 50 ? "✅ VALIDATED" : "⚠️ OVERHEAD"});
-    }
-
-    // ═══════════════════════════════════════════════════════════════
-    //  D2: Cold-start vs warm (page cache populated)
-    // ═══════════════════════════════════════════════════════════════
-
-    private void runD2_ColdVsWarm() throws Exception {
-        System.out.println("▶ D2: Cold-Start vs Warm Search (page cache effects)");
-
-        Path dataDir = Files.createTempDirectory("spector-cold-bench");
-        int datasetSize = 10_000;
-
-        var config = new SpectorConfig(DIMS, datasetSize + 1000,
-                SimilarityFunction.COSINE, new HnswParams(16, 200, 64))
-                .withPersistence(PersistenceMode.DISK, dataDir);
-
-        // Build and close (writes to disk)
-        SpectorEngine engine = new DefaultSpectorEngine(config);
-        Random rng = new Random(42);
-        float[][] vectors = generateClusteredVectors(datasetSize, DIMS, rng);
-        for (int i = 0; i < datasetSize; i++) {
-            engine.ingest("doc-" + i, "content " + i, vectors[i]);
-        }
-        engine.close();
-
-        // Reopen — first search is "cold" (mmap page faults)
-        float[] qv = perturbVector(vectors[0], 0.3f, DIMS, new Random(999));
-
-        SpectorEngine engine2 = new DefaultSpectorEngine(config);
-        long coldStart = System.nanoTime();
-        engine2.vectorSearch(qv, TOP_K);
-        long coldNanos = System.nanoTime() - coldStart;
-
-        // Warm up — pages are now in OS cache
-        for (int i = 0; i < 200; i++) engine2.vectorSearch(qv, TOP_K);
-        long[] warmNanos = new long[500];
-        for (int i = 0; i < 500; i++) {
-            long t0 = System.nanoTime();
-            engine2.vectorSearch(qv, TOP_K);
-            warmNanos[i] = System.nanoTime() - t0;
-        }
-        var warmStats = computeStats(warmNanos);
-
-        System.out.printf("  Cold-start (first search): %.2fms%n", coldNanos / 1e6);
-        System.out.printf("  Warm (page-cached):        p50=%.0fµs  p99=%.0fµs%n",
-                warmStats.p50 / 1000.0, warmStats.p99 / 1000.0);
-        System.out.printf("  Cold/warm ratio:           %.0f×%n%n", (coldNanos / warmStats.p50));
-
-        engine2.close();
-        deleteDirectory(dataDir);
-
-        verdicts.add(new String[]{"D2: Cold-start vs warm",
-                String.format("cold=%.1fms, warm=%.0fµs", coldNanos / 1e6, warmStats.p50 / 1000.0),
-                "✅ MEASURED"});
-    }
-
-    // ═══════════════════════════════════════════════════════════════
-    //  D3: Cognitive Memory — real Ollama embeddings recall
-    // ═══════════════════════════════════════════════════════════════
-
-    private void runD3_CognitiveMemoryRecall(OllamaEmbeddingProvider embedder) throws Exception {
-        System.out.println("▶ D3: Cognitive Memory — Remember + Recall with Ollama Embeddings");
-
-        Path memDir = Files.createTempDirectory("spector-mem-bench");
-
-        SpectorMemory memory = DefaultSpectorMemory.builder()
-                .dimensions(DIMS)
-                .embeddingProvider(embedder)
-                .persistence(memDir)
-                .persistenceMode(MemoryPersistenceMode.DISK)
-                .semanticCapacity(10_000)
-                .build();
-
-        // Ingest real memories
-        String[] memories = {
-                "User prefers dark mode with high contrast colors for accessibility.",
-                "The project uses Java 25 with Panama FFI for zero-copy vector operations.",
-                "Meeting scheduled for Friday at 3 PM with the engineering team about SIMD optimizations.",
-                "The HNSW index uses M=16, efConstruction=200 for production workloads.",
-                "User's favorite programming language is Java, followed by Rust and Go.",
-                "Database migration from PostgreSQL to Spector completed on March 15th.",
-                "API rate limits set to 1000 requests per minute for free tier users.",
-                "The neural network training uses cosine similarity as the loss function.",
-                "Deployment uses Kubernetes with 3 replicas and auto-scaling enabled.",
-                "Bug fix: resolved memory leak in the vector quantization pipeline last sprint."
-        };
-
-        System.out.printf("  Ingesting %d memories via Ollama...%n", memories.length);
-        long ingestStart = System.nanoTime();
-        for (int i = 0; i < memories.length; i++) {
-            memory.remember("mem-" + i, memories[i], MemoryType.SEMANTIC,
-                    MemorySource.USER_STATED, "benchmark").join();
-        }
-        long ingestElapsed = System.nanoTime() - ingestStart;
-        System.out.printf("  Ingestion: %d memories in %.1fs (%.0fms/memory, Ollama embedding included)%n",
-                memories.length, ingestElapsed / 1e9, ingestElapsed / 1e6 / memories.length);
-
-        // Recall queries
-        String[] queries = {
-                "What color theme does the user prefer?",
-                "What programming language is used?",
-                "When is the next meeting?",
-                "How is the deployment configured?",
-                "What database was migrated?"
-        };
-
-        System.out.println("  Recall latencies (includes Ollama embedding):");
-        long[] recallNanos = new long[queries.length];
-        for (int i = 0; i < queries.length; i++) {
-            long t0 = System.nanoTime();
-            List<CognitiveResult> results = memory.recall(queries[i]);
-            recallNanos[i] = System.nanoTime() - t0;
-            String topMatch = results.isEmpty() ? "none" : results.getFirst().id();
-            System.out.printf("    Q: \"%s\"%n      → %s (%.1fms, %d results)%n",
-                    queries[i], topMatch, recallNanos[i] / 1e6, results.size());
-        }
-
-        // Measure repeated recall (shows consistency)
-        System.out.println("  Recall consistency (5 rounds):");
-        for (int r = 0; r < 5; r++) {
-            long t0 = System.nanoTime();
-            memory.recall("What color theme?");
-            long ms = (System.nanoTime() - t0) / 1_000_000;
-            System.out.printf("    Round %d: %dms%n", r + 1, ms);
-        }
-        System.out.println();
-
-        memory.close();
-        deleteDirectory(memDir);
-
-        double avgRecallMs = 0;
-        for (long n : recallNanos) avgRecallMs += n / 1e6;
-        avgRecallMs /= recallNanos.length;
-
-        verdicts.add(new String[]{"D3: Cognitive recall (Ollama)",
-                String.format("avg=%.0fms (embed+score)", avgRecallMs),
-                "✅ MEASURED"});
-    }
-
-    // ═══════════════════════════════════════════════════════════════
-    //  D4: WAL — append throughput and replay speed
-    // ═══════════════════════════════════════════════════════════════
-
-    private void runD4_WalThroughput() throws Exception {
-        System.out.println("▶ D4: WAL Append + Replay Throughput (file-backed, fsync'd)");
-
-        Path walDir = Files.createTempDirectory("spector-wal-bench");
-        int eventCount = 50_000;
-
-        // Test 1: WAL with fsync per write (durability guarantee)
-        try (MemoryWal walSync = new MemoryWal(walDir.resolve("fsync"),
-                8L * 1024 * 1024, false, 1024, true)) {
-
-            long t0 = System.nanoTime();
-            for (int i = 0; i < eventCount; i++) {
-                walSync.appendRemember("mem-" + i, ("content-" + i).getBytes());
-            }
-            long appendSyncNanos = System.nanoTime() - t0;
-
-            double syncOpsPerSec = eventCount / (appendSyncNanos / 1e9);
-            double syncLatencyUs = appendSyncNanos / (double) eventCount / 1000.0;
-
-            System.out.printf("  fsync WAL:    %,d appends in %.1fs  (%.0f ops/s, %.0fµs/op)%n",
-                    eventCount, appendSyncNanos / 1e9, syncOpsPerSec, syncLatencyUs);
-
-            // Replay from disk
-            long replayStart = System.nanoTime();
-            var replayed = walSync.replayFromDisk();
-            long replayNanos = System.nanoTime() - replayStart;
-            System.out.printf("  fsync replay: %,d events in %.1fms (%.0f events/s)%n",
-                    replayed.size(), replayNanos / 1e6, replayed.size() / (replayNanos / 1e9));
-
-            verdicts.add(new String[]{"D4a: WAL fsync append",
-                    String.format("%.0f ops/s, %.0fµs/op", syncOpsPerSec, syncLatencyUs),
-                    "✅ MEASURED"});
-        }
-
-        // Test 2: WAL without fsync (buffered — much faster)
-        try (MemoryWal walBuf = new MemoryWal(walDir.resolve("buffered"),
-                8L * 1024 * 1024, false, 1024, false)) {
-
-            long t0 = System.nanoTime();
-            for (int i = 0; i < eventCount; i++) {
-                walBuf.appendRemember("mem-" + i, ("content-" + i).getBytes());
-            }
-            long appendBufNanos = System.nanoTime() - t0;
-
-            double bufOpsPerSec = eventCount / (appendBufNanos / 1e9);
-            double bufLatencyUs = appendBufNanos / (double) eventCount / 1000.0;
-
-            System.out.printf("  buffered WAL: %,d appends in %.1fms (%.0f ops/s, %.1fµs/op)%n",
-                    eventCount, appendBufNanos / 1e6, bufOpsPerSec, bufLatencyUs);
-
-            verdicts.add(new String[]{"D4b: WAL buffered append",
-                    String.format("%.0f ops/s, %.1fµs/op", bufOpsPerSec, bufLatencyUs),
-                    "✅ MEASURED"});
-        }
-
-        // Test 3: Concurrent WAL writes (simulating multi-agent scenario)
-        try (MemoryWal walConc = new MemoryWal(walDir.resolve("concurrent"),
-                8L * 1024 * 1024, false, 1024, false)) {
-
-            int threads = 8;
-            int opsPerThread = 10_000;
-            ExecutorService executor = Executors.newFixedThreadPool(threads);
-            AtomicLong totalOps = new AtomicLong();
-
-            long wallStart = System.nanoTime();
-            List<Future<?>> futures = new ArrayList<>();
-            for (int t = 0; t < threads; t++) {
-                final int tid = t;
-                futures.add(executor.submit(() -> {
-                    for (int i = 0; i < opsPerThread; i++) {
-                        walConc.appendRemember("t" + tid + "-mem-" + i,
-                                ("concurrent-" + tid + "-" + i).getBytes());
-                        totalOps.incrementAndGet();
-                    }
-                }));
-            }
-            for (var f : futures) f.get();
-            long wallElapsed = System.nanoTime() - wallStart;
-            executor.shutdown();
-
-            double concOpsPerSec = totalOps.get() / (wallElapsed / 1e9);
-            System.out.printf("  concurrent:   %d threads × %,d ops = %,.0f ops/s%n",
-                    threads, opsPerThread, concOpsPerSec);
-
-            verdicts.add(new String[]{"D4c: WAL concurrent writes",
-                    String.format("%,.0f ops/s (%d threads)", concOpsPerSec, threads),
-                    "✅ MEASURED"});
-        }
-
-        System.out.println();
-        deleteDirectory(walDir);
-    }
-
-    // ═══════════════════════════════════════════════════════════════
-    //  D5: Full Memory Pipeline — ingest → recall → reinforce → reflect
-    // ═══════════════════════════════════════════════════════════════
-
-    private void runD5_FullMemoryPipeline(OllamaEmbeddingProvider embedder) throws Exception {
-        System.out.println("▶ D5: Full Cognitive Pipeline (remember → recall → reinforce → reflect)");
-
-        Path memDir = Files.createTempDirectory("spector-pipeline-bench");
-
-        SpectorMemory memory = DefaultSpectorMemory.builder()
-                .dimensions(DIMS)
-                .embeddingProvider(embedder)
-                .persistence(memDir)
-                .persistenceMode(MemoryPersistenceMode.DISK)
-                .semanticCapacity(10_000)
-                .build();
-
-        // Phase 1: Remember
-        String[] texts = {
-                "Implemented SIMD-accelerated cosine similarity using Java Vector API with AVX-512.",
-                "The Panama FFI provides zero-copy access to native memory segments without JNI overhead.",
-                "HNSW graph construction uses M=16, efConstruction=200 for 95%+ recall at 10K scale.",
-                "Write-Ahead Log uses append-only binary format with CRC32 checksums for crash recovery.",
-                "Cognitive memory scoring fuses similarity, importance, decay, and valence in one SIMD pass."
-        };
-
-        System.out.printf("  Phase 1: Remember (%d memories)...%n", texts.length);
-        long rememberStart = System.nanoTime();
-        for (int i = 0; i < texts.length; i++) {
-            memory.remember("pipeline-" + i, texts[i], MemoryType.SEMANTIC,
-                    MemorySource.OBSERVED, "pipeline", "benchmark").join();
-        }
-        long rememberMs = (System.nanoTime() - rememberStart) / 1_000_000;
-        System.out.printf("    Done: %dms total (%.0fms/memory)%n", rememberMs, (double) rememberMs / texts.length);
-
-        // Phase 2: Recall
-        System.out.println("  Phase 2: Recall...");
-        long recallStart = System.nanoTime();
-        List<CognitiveResult> results = memory.recall("What is the HNSW configuration?");
-        long recallMs = (System.nanoTime() - recallStart) / 1_000_000;
-        System.out.printf("    Recall: %dms, %d results%n", recallMs, results.size());
-        if (!results.isEmpty()) {
-            System.out.printf("    Top: %s (score=%.3f)%n", results.getFirst().id(),
-                    results.getFirst().score());
-        }
-
-        // Phase 3: Reinforce
-        System.out.println("  Phase 3: Reinforce...");
-        if (!results.isEmpty()) {
-            long reinforceStart = System.nanoTime();
-            memory.reinforce(results.getFirst().id(), (byte) 64);
-            long reinforceUs = (System.nanoTime() - reinforceStart) / 1000;
-            System.out.printf("    Reinforced '%s' in %dµs%n", results.getFirst().id(), reinforceUs);
-        }
-
-        // Phase 4: Reflect (sleep consolidation)
-        System.out.println("  Phase 4: Reflect (sleep consolidation)...");
-        long reflectStart = System.nanoTime();
-        ReflectReport report = memory.reflect();
-        long reflectMs = (System.nanoTime() - reflectStart) / 1_000_000;
-        System.out.printf("    Reflect: %dms (promoted=%d, pruned=%d)%n",
-                reflectMs, report.consolidatedCount(), report.tombstonedCount());
-
-        // Phase 5: Stats
-        System.out.println("  Phase 5: Final stats...");
-        System.out.printf("    Total memories: %d%n", memory.totalMemories());
-        System.out.printf("    Working:  %d%n", memory.memoryCount(MemoryType.WORKING));
-        System.out.printf("    Episodic: %d%n", memory.memoryCount(MemoryType.EPISODIC));
-        System.out.printf("    Semantic: %d%n", memory.memoryCount(MemoryType.SEMANTIC));
-        System.out.printf("    Procedural: %d%n", memory.memoryCount(MemoryType.PROCEDURAL));
-        System.out.println();
-
-        memory.close();
-        deleteDirectory(memDir);
-
-        verdicts.add(new String[]{"D5: Full pipeline cycle",
-                String.format("remember=%dms, recall=%dms, reflect=%dms", rememberMs, recallMs, reflectMs),
-                "✅ MEASURED"});
-    }
-
-    // ═══════════════════════════════════════════════════════════════
-    //  Results & Report
-    // ═══════════════════════════════════════════════════════════════
-
-    private void printVerdictTable() {
-        System.out.println("═══════════════════════════════════════════════════════════════");
-        System.out.println("             DISK PERSISTENCE BENCHMARK REPORT                ");
-        System.out.println("═══════════════════════════════════════════════════════════════");
-        System.out.printf("  %-38s %-35s %-15s%n", "TEST", "RESULT", "VERDICT");
-        System.out.println("  " + "─".repeat(88));
-        for (var v : verdicts) {
-            System.out.printf("  %-38s %-35s %-15s%n", v[0], v[1], v[2]);
-        }
-        System.out.println("═══════════════════════════════════════════════════════════════");
-    }
-
-    private void writeReport() throws IOException {
-        StringBuilder sb = new StringBuilder();
-        sb.append("# Spector — Disk Persistence Benchmark Report\n\n");
-        sb.append("**Generated:** ").append(LocalDateTime.now().format(DateTimeFormatter.ISO_LOCAL_DATE_TIME)).append("\n\n");
-
-        sb.append("## System\n\n");
-        sb.append("| Property | Value |\n|---|---|\n");
-        sb.append("| CPU | ").append(getCpuModel()).append(" |\n");
-        sb.append("| Java | ").append(System.getProperty("java.version")).append(" |\n");
-        sb.append("| SIMD | ").append(SimdCapability.report()).append(" |\n");
-        sb.append("| Embedding | ").append(EMBEDDING_MODEL).append(" (Ollama, localhost) |\n\n");
-
-        sb.append("## Results\n\n");
-        sb.append("| Test | Result | Verdict |\n|---|---|---|\n");
-        for (var v : verdicts) {
-            sb.append("| ").append(v[0]).append(" | ").append(v[1]).append(" | ").append(v[2]).append(" |\n");
-        }
-
-        Path reportPath = Path.of("spector-bench", "target", "disk-persistence-report.md");
-        Files.createDirectories(reportPath.getParent());
-        Files.writeString(reportPath, sb.toString());
-        System.out.printf("%nReport saved: %s%n", reportPath.toAbsolutePath());
-    }
-
-    // ─── System Info ───
-
-    private void printSystemInfo() {
-        System.out.printf("  OS:    %s %s%n", System.getProperty("os.name"), System.getProperty("os.arch"));
-        System.out.printf("  Java:  %s%n", System.getProperty("java.version"));
-        System.out.printf("  CPU:   %s (%d cores)%n", getCpuModel(), Runtime.getRuntime().availableProcessors());
-        System.out.printf("  Heap:  %d MB%n", Runtime.getRuntime().maxMemory() / (1024 * 1024));
-        System.out.printf("  SIMD:  %s%n", SimdCapability.report());
-        System.out.printf("  Time:  %s%n", LocalDateTime.now().format(DateTimeFormatter.ISO_LOCAL_DATE_TIME));
-    }
-
-    private static String getCpuModel() {
-        try {
-            Process p = new ProcessBuilder("powershell", "-Command",
-                    "(Get-CimInstance Win32_Processor).Name").start();
-            String result = new String(p.getInputStream().readAllBytes()).trim();
-            p.waitFor();
-            if (!result.isBlank()) return result;
-        } catch (Exception ignored) {}
-        return System.getProperty("os.arch");
-    }
-
-    // ─── Helpers ───
-
-    private static float[][] generateClusteredVectors(int count, int dims, Random rng) {
-        int clusters = 50;
-        float[][] centers = new float[clusters][dims];
-        for (int c = 0; c < clusters; c++) {
-            for (int d = 0; d < dims; d++) centers[c][d] = (float) rng.nextGaussian() * 0.5f;
-            normalize(centers[c]);
-        }
-        float[][] vectors = new float[count][dims];
-        for (int i = 0; i < count; i++) {
-            int cluster = rng.nextInt(clusters);
-            for (int d = 0; d < dims; d++) vectors[i][d] = centers[cluster][d] + (float) rng.nextGaussian() * 0.15f;
-            normalize(vectors[i]);
-        }
-        return vectors;
-    }
-
-    private static float[] perturbVector(float[] base, float noise, int dims, Random rng) {
-        float[] result = new float[dims];
-        for (int d = 0; d < dims; d++) result[d] = base[d] + (float) rng.nextGaussian() * noise;
-        normalize(result);
-        return result;
-    }
-
-    private static void normalize(float[] v) {
-        float norm = 0;
-        for (float f : v) norm += f * f;
-        norm = (float) Math.sqrt(norm);
-        if (norm > 1e-10f) for (int i = 0; i < v.length; i++) v[i] /= norm;
-    }
-
-    private static void deleteDirectory(Path path) throws IOException {
-        if (Files.exists(path)) {
-            try (var stream = Files.walk(path)) {
-                stream.sorted(Comparator.reverseOrder()).forEach(p -> {
-                    try { Files.delete(p); } catch (IOException ignored) {}
-                });
-            }
-        }
-    }
-
-    record Stats(double min, double max, double mean, double p50, double p95, double p99) {}
-
-    private Stats computeStats(long[] nanos) {
-        Arrays.sort(nanos);
-        int n = nanos.length;
-        double sum = 0;
-        for (long v : nanos) sum += v;
-        return new Stats(nanos[0], nanos[n - 1], sum / n,
-                nanos[(int) (n * 0.50)], nanos[(int) (n * 0.95)], nanos[(int) (n * 0.99)]);
-    }
-}
diff --git a/spector-bench/src/main/java/com/spectrayan/spector/bench/FlatScanBenchmark.java b/spector-bench/src/main/java/com/spectrayan/spector/bench/FlatScanBenchmark.java
deleted file mode 100644
index 465bf4b..0000000
--- a/spector-bench/src/main/java/com/spectrayan/spector/bench/FlatScanBenchmark.java
+++ /dev/null
@@ -1,182 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.bench;
-
-import com.spectrayan.spector.core.quantization.strategy.DistanceContext;
-import com.spectrayan.spector.core.quantization.strategy.SvasqStrategy;
-import com.spectrayan.spector.core.quantization.svasq.SvasqCalibrator;
-import com.spectrayan.spector.core.quantization.svasq.SvasqEncoder;
-import com.spectrayan.spector.core.quantization.svasq.SvasqParams;
-import com.spectrayan.spector.core.similarity.SimilarityFunction;
-
-import org.openjdk.jmh.annotations.*;
-import org.openjdk.jmh.infra.Blackhole;
-
-import java.lang.foreign.Arena;
-import java.lang.foreign.MemorySegment;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.PriorityQueue;
-import java.util.Random;
-import java.util.concurrent.TimeUnit;
-
-/**
- * JMH benchmarks for the SpectorShard flat-scan path.
- *
- * <p>The flat scan is the critical mode for small shards (&lt; shardThreshold). It performs
- * exhaustive exact L2 over float32 residuals and is expected to outperform HNSW for
- * sizes below ~20K due to contiguous memory access patterns and SIMD-friendly layout.</p>
- *
- * <p>Benchmarks:</p>
- * <ul>
- *   <li><b>float32 flat scan</b> — exhaustive exact similarity over raw float residuals</li>
- *   <li><b>SVASQ flat scan</b> — exhaustive scan using the SVASQ distance kernel over encoded
- *       off-heap residuals. Simulates what the shard would do post-calibration in a fully
- *       quantized shard (not yet promoted to HNSW).</li>
- * </ul>
- *
- * <p>Run via:</p>
- * <pre>
- *   java -jar spector-bench/target/benchmarks.jar FlatScanBenchmark
- * </pre>
- */
-@BenchmarkMode({Mode.Throughput, Mode.AverageTime})
-@OutputTimeUnit(TimeUnit.MICROSECONDS)
-@State(Scope.Benchmark)
-@Warmup(iterations = 3, time = 2)
-@Measurement(iterations = 5, time = 3)
-@Fork(value = 1, jvmArgsAppend = {
-        "--add-modules", "jdk.incubator.vector",
-        "--enable-native-access=ALL-UNNAMED",
-        "-Xmx2g"
-})
-public class FlatScanBenchmark {
-
-    @Param({"128", "384"})
-    int dims;
-
-    /** Shard size — spans the flat-mode range and one post-threshold point. */
-    @Param({"1000", "5000", "20000"})
-    int shardSize;
-
-    @Param({"10"})
-    int topK;
-
-    private float[] queryResidual;
-    private float[][] floatResiduals;   // float32 exact residuals (flat mode)
-    private MemorySegment encodedSegment;
-    private Arena arena;
-    private SvasqStrategy svasqStrategy;
-    private int bpv;
-    private SimilarityFunction fn = SimilarityFunction.COSINE;
-
-    @Setup(Level.Trial)
-    public void setup() {
-        Random rng = new Random(42L);
-
-        // Build calibrated SVASQ strategy
-        List<float[]> sample = new ArrayList<>(Math.min(shardSize, 2000));
-        for (int i = 0; i < sample.size(); i++) sample.add(gaussianUnit(rng, dims));
-        // Ensure we have enough for calibration
-        while (sample.size() < 200) sample.add(gaussianUnit(rng, dims));
-        SvasqParams params = SvasqCalibrator.calibrate(sample, dims);
-        SvasqEncoder encoder = new SvasqEncoder(params);
-        svasqStrategy = new SvasqStrategy(params, fn);
-        bpv = svasqStrategy.bytesPerVector();
-
-        // Query residual
-        queryResidual = gaussianUnit(rng, dims);
-
-        // Float32 residuals (heap)
-        floatResiduals = new float[shardSize][dims];
-        for (int i = 0; i < shardSize; i++) floatResiduals[i] = gaussianUnit(rng, dims);
-
-        // SVASQ-encoded residuals (off-heap)
-        arena = Arena.ofShared();
-        encodedSegment = arena.allocate((long) shardSize * bpv, 8L);
-        for (int i = 0; i < shardSize; i++) {
-            encoder.encode(floatResiduals[i], encodedSegment, (long) i * bpv);
-        }
-    }
-
-    @TearDown(Level.Trial)
-    public void tearDown() {
-        arena.close();
-    }
-
-    // ── Float32 exact flat scan (current SpectorShard flat mode) ─────────────
-
-    /**
-     * Exhaustive exact similarity scan over float32 residuals.
-     * Uses a min-heap of size k to track the best candidates.
-     * This is what {@link com.spectrayan.spector.index.spectrum.SpectorShard#flatScan} does.
-     */
-    @Benchmark
-    public void flatScan_exact_float32(Blackhole bh) {
-        PriorityQueue<float[]> heap = new PriorityQueue<>(topK,
-                (a, b) -> Float.compare(a[0], b[0]));  // min-heap by score
-
-        for (int i = 0; i < shardSize; i++) {
-            float score = fn.compute(queryResidual, floatResiduals[i]);
-            if (heap.size() < topK) {
-                heap.offer(new float[]{score, i});
-            } else if (score > heap.peek()[0]) {
-                heap.poll();
-                heap.offer(new float[]{score, i});
-            }
-        }
-        bh.consume(heap);
-    }
-
-    // ── SVASQ quantized flat scan (hypothetical fully-quantized shard mode) ───
-
-    /**
-     * Exhaustive SVASQ distance scan over off-heap encoded residuals.
-     * Demonstrates the throughput possible if the flat-scan path also used SVASQ
-     * instead of float32 (useful for very large pre-promotion shards).
-     */
-    @Benchmark
-    public void flatScan_svasq_encoded(Blackhole bh) {
-        DistanceContext ctx = svasqStrategy.prepareQueryContext(queryResidual);
-        PriorityQueue<float[]> heap = new PriorityQueue<>(topK,
-                (a, b) -> Float.compare(a[0], b[0]));
-
-        for (int i = 0; i < shardSize; i++) {
-            float score = svasqStrategy.distance(encodedSegment, (long) i * bpv, ctx);
-            if (heap.size() < topK) {
-                heap.offer(new float[]{score, i});
-            } else if (score > heap.peek()[0]) {
-                heap.poll();
-                heap.offer(new float[]{score, i});
-            }
-        }
-        bh.consume(heap);
-    }
-
-    // ── Helpers ──────────────────────────────────────────────────────────────
-
-    private static float[] gaussianUnit(Random rng, int dims) {
-        float[] v = new float[dims];
-        double norm = 0;
-        for (int i = 0; i < dims; i++) {
-            v[i] = (float) rng.nextGaussian();
-            norm += (double) v[i] * v[i];
-        }
-        float scale = (float) (1.0 / Math.sqrt(norm));
-        for (int i = 0; i < dims; i++) v[i] *= scale;
-        return v;
-    }
-}
diff --git a/spector-bench/src/main/java/com/spectrayan/spector/bench/FwhtBenchmark.java b/spector-bench/src/main/java/com/spectrayan/spector/bench/FwhtBenchmark.java
deleted file mode 100644
index 0cc1abf..0000000
--- a/spector-bench/src/main/java/com/spectrayan/spector/bench/FwhtBenchmark.java
+++ /dev/null
@@ -1,99 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.bench;
-
-import com.spectrayan.spector.core.quantization.svasq.SvasqFwht;
-
-import org.openjdk.jmh.annotations.*;
-import org.openjdk.jmh.infra.Blackhole;
-
-import java.util.Random;
-import java.util.concurrent.TimeUnit;
-
-/**
- * JMH benchmarks for {@link SvasqFwht} — the FWHT rotation step in the SVASQ pipeline.
- *
- * <p>FWHT is applied once per query preparation ({@code O(N log N)} additions, zero multiplications)
- * and once per indexed vector during encode. This benchmark isolates the rotation cost so it
- * can be tracked separately from the SVASQ quantization overhead.</p>
- *
- * <p>Run via:</p>
- * <pre>
- *   java -jar spector-bench/target/benchmarks.jar FwhtBenchmark
- * </pre>
- */
-@BenchmarkMode({Mode.Throughput, Mode.AverageTime})
-@OutputTimeUnit(TimeUnit.MICROSECONDS)
-@State(Scope.Benchmark)
-@Warmup(iterations = 3, time = 2)
-@Measurement(iterations = 5, time = 3)
-@Fork(value = 1, jvmArgsAppend = {
-        "--add-modules", "jdk.incubator.vector",
-        "--enable-native-access=ALL-UNNAMED",
-        "-Xmx2g"
-})
-public class FwhtBenchmark {
-
-    /** Vector dimensionality — 128 (small), 768 (BERT), 1024 (padded BERT). */
-    @Param({"128", "768", "1024"})
-    int dims;
-
-    private SvasqFwht fwht;
-    private float[] inputVector;
-    private float[] outputBuffer;
-
-    @Setup(Level.Trial)
-    public void setup() {
-        fwht = new SvasqFwht(dims, 42L);
-        int paddedDim = fwht.paddedDim();
-        Random rng = new Random(1L);
-        inputVector = new float[dims];
-        outputBuffer = new float[paddedDim];
-        for (int i = 0; i < dims; i++) {
-            inputVector[i] = (float) rng.nextGaussian();
-        }
-    }
-
-    /**
-     * Allocating variant — creates a new output buffer each call.
-     * Represents the encode path at index time.
-     */
-    @Benchmark
-    public float[] rotate_allocating(Blackhole bh) {
-        return fwht.rotate(inputVector);
-    }
-
-    /**
-     * Zero-copy variant — writes into a pre-allocated buffer.
-     * Represents the query preparation path (called once per search).
-     */
-    @Benchmark
-    public void rotate_intoBuffer(Blackhole bh) {
-        fwht.rotate(inputVector, outputBuffer);
-        bh.consume(outputBuffer);
-    }
-
-    /**
-     * Raw FWHT butterfly on an already-prepared array.
-     * Isolates the O(N log N) butterfly cost without sign-flip or normalization overhead.
-     */
-    @Benchmark
-    public void rawFwht_butterfly(Blackhole bh) {
-        System.arraycopy(inputVector, 0, outputBuffer, 0, dims);
-        SvasqFwht.applyFwht(outputBuffer);
-        bh.consume(outputBuffer);
-    }
-}
diff --git a/spector-bench/src/main/java/com/spectrayan/spector/bench/GpuDetectTest.java b/spector-bench/src/main/java/com/spectrayan/spector/bench/GpuDetectTest.java
deleted file mode 100644
index b1f4e4d..0000000
--- a/spector-bench/src/main/java/com/spectrayan/spector/bench/GpuDetectTest.java
+++ /dev/null
@@ -1,25 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.bench;
-
-import com.spectrayan.spector.gpu.GpuCapability;
-
-public class GpuDetectTest {
-    public static void main(String[] args) {
-        System.out.println(GpuCapability.detect().report());
-        System.out.println("Available: " + GpuCapability.isAvailable());
-    }
-}
diff --git a/spector-bench/src/main/java/com/spectrayan/spector/bench/GpuKernelBenchmark.java b/spector-bench/src/main/java/com/spectrayan/spector/bench/GpuKernelBenchmark.java
index 04d4d07..23b9a01 100644
--- a/spector-bench/src/main/java/com/spectrayan/spector/bench/GpuKernelBenchmark.java
+++ b/spector-bench/src/main/java/com/spectrayan/spector/bench/GpuKernelBenchmark.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.bench;
 
 import java.util.Random;
diff --git a/spector-bench/src/main/java/com/spectrayan/spector/bench/GpuPerfTest.java b/spector-bench/src/main/java/com/spectrayan/spector/bench/GpuPerfTest.java
deleted file mode 100644
index 26d86d5..0000000
--- a/spector-bench/src/main/java/com/spectrayan/spector/bench/GpuPerfTest.java
+++ /dev/null
@@ -1,113 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.bench;
-
-import java.util.Random;
-
-import com.spectrayan.spector.core.similarity.CosineSimilarity;
-import com.spectrayan.spector.gpu.CudaKernelLauncher;
-import com.spectrayan.spector.gpu.GpuBatchSimilarity;
-import com.spectrayan.spector.gpu.GpuCapability;
-
-/**
- * Quick GPU vs CPU SIMD performance comparison.
- * Tests batch cosine similarity at various batch sizes.
- */
-public class GpuPerfTest {
-
-    private static final int DIMENSIONS = 384;
-    private static final int WARMUP = 20;
-    private static final int MEASURE = 100;
-    private static final int[] BATCH_SIZES = {1, 8, 32, 128, 512, 1024, 4096, 10000, 50000, 100000};
-
-    public static void main(String[] args) {
-        System.out.println("GPU: " + GpuCapability.detect().report());
-        System.out.println("Dimensions: " + DIMENSIONS);
-        System.out.println();
-
-        if (!GpuCapability.isAvailable()) {
-            System.out.println("ERROR: No GPU available!");
-            return;
-        }
-
-        Random rng = new Random(42);
-        GpuBatchSimilarity gpu = new GpuBatchSimilarity();
-
-        System.out.printf("%-10s %12s %12s %12s%n", "Batch", "CPU SIMD", "GPU", "Speedup");
-        System.out.println("-".repeat(52));
-
-        for (int batchSize : BATCH_SIZES) {
-            float[] query = randomVec(DIMENSIONS, rng);
-            float[] database = new float[batchSize * DIMENSIONS];
-            for (int i = 0; i < database.length; i++) {
-                database[i] = rng.nextFloat() * 2f - 1f;
-            }
-
-            // Warmup both
-            for (int i = 0; i < WARMUP; i++) {
-                cpuBatchCosine(query, database, batchSize, DIMENSIONS);
-                gpu.batchCosineSimilarity(query, database, batchSize, DIMENSIONS);
-            }
-
-            // Measure CPU
-            long cpuTotal = 0;
-            for (int i = 0; i < MEASURE; i++) {
-                long t0 = System.nanoTime();
-                cpuBatchCosine(query, database, batchSize, DIMENSIONS);
-                cpuTotal += System.nanoTime() - t0;
-            }
-            double cpuAvgMs = (cpuTotal / (double) MEASURE) / 1e6;
-
-            // Measure GPU (direct kernel launch, bypassing threshold)
-            long gpuTotal = 0;
-            CudaKernelLauncher directLauncher = null;
-            try { directLauncher = new CudaKernelLauncher(); } catch (Exception ignored) {}
-            if (directLauncher != null) {
-                for (int i = 0; i < WARMUP; i++) {
-                    directLauncher.batchCosine(query, database, batchSize, DIMENSIONS);
-                }
-                for (int i = 0; i < MEASURE; i++) {
-                    long t0 = System.nanoTime();
-                    directLauncher.batchCosine(query, database, batchSize, DIMENSIONS);
-                    gpuTotal += System.nanoTime() - t0;
-                }
-                directLauncher.close();
-            }
-            double gpuAvgMs = directLauncher != null ? (gpuTotal / (double) MEASURE) / 1e6 : -1;
-
-            double speedup = cpuAvgMs / gpuAvgMs;
-            System.out.printf("%-10d %10.3f ms %10.3f ms %10.1f×%n",
-                    batchSize, cpuAvgMs, gpuAvgMs, speedup);
-        }
-
-        gpu.close();
-    }
-
-    private static float[] cpuBatchCosine(float[] query, float[] database,
-                                           int n, int dims) {
-        float[] results = new float[n];
-        for (int i = 0; i < n; i++) {
-            results[i] = CosineSimilarity.compute(query, 0, database, i * dims, dims);
-        }
-        return results;
-    }
-
-    private static float[] randomVec(int dims, Random rng) {
-        float[] v = new float[dims];
-        for (int i = 0; i < dims; i++) v[i] = rng.nextFloat() * 2f - 1f;
-        return v;
-    }
-}
diff --git a/spector-bench/src/main/java/com/spectrayan/spector/bench/GpuResidentBench.java b/spector-bench/src/main/java/com/spectrayan/spector/bench/GpuResidentBench.java
deleted file mode 100644
index 4f326f9..0000000
--- a/spector-bench/src/main/java/com/spectrayan/spector/bench/GpuResidentBench.java
+++ /dev/null
@@ -1,93 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.bench;
-
-import java.util.Random;
-
-import com.spectrayan.spector.gpu.GpuCapability;
-import com.spectrayan.spector.gpu.GpuVectorIndex;
-
-/**
- * Benchmark for GPU-resident vector search (persistent device memory model).
- * Database is uploaded to VRAM once, then queries only transfer the query vector.
- */
-public class GpuResidentBench {
-
-    private static final int DIMS = 384;
-    private static final int WARMUP = 10;
-    private static final int MEASURE = 50;
-
-    public static void main(String[] args) {
-        System.out.println("GPU: " + GpuCapability.detect().report());
-        System.out.println("Dimensions: " + DIMS);
-        System.out.println();
-
-        int[] sizes = {10_000, 100_000, 500_000, 1_000_000};
-
-        for (int n : sizes) {
-            long memMB = (long) n * DIMS * 4 / (1024 * 1024);
-            System.out.printf("▶ %,d vectors (%d MB)%n", n, memMB);
-
-            Random rng = new Random(42);
-            float[] database = new float[n * DIMS];
-            for (int i = 0; i < database.length; i++) {
-                database[i] = rng.nextFloat() * 2f - 1f;
-            }
-            float[] query = new float[DIMS];
-            for (int i = 0; i < DIMS; i++) query[i] = rng.nextFloat() * 2f - 1f;
-
-            // Create GPU index (uploads to VRAM)
-            long uploadStart = System.nanoTime();
-            GpuVectorIndex gpuIndex = GpuVectorIndex.create(database, n, DIMS, true);
-            long uploadMs = (System.nanoTime() - uploadStart) / 1_000_000;
-            System.out.printf("  Upload: %dms | GPU active: %s%n", uploadMs, gpuIndex.isGpuActive());
-
-            // Create CPU-only index for comparison
-            GpuVectorIndex cpuIndex = GpuVectorIndex.create(database, n, DIMS, false);
-
-            // Warmup
-            for (int i = 0; i < WARMUP; i++) {
-                gpuIndex.search(query);
-                cpuIndex.search(query);
-            }
-
-            // Measure GPU
-            long gpuTotal = 0;
-            for (int i = 0; i < MEASURE; i++) {
-                long t0 = System.nanoTime();
-                gpuIndex.search(query);
-                gpuTotal += System.nanoTime() - t0;
-            }
-            double gpuMs = (gpuTotal / (double) MEASURE) / 1e6;
-
-            // Measure CPU
-            long cpuTotal = 0;
-            for (int i = 0; i < MEASURE; i++) {
-                long t0 = System.nanoTime();
-                cpuIndex.search(query);
-                cpuTotal += System.nanoTime() - t0;
-            }
-            double cpuMs = (cpuTotal / (double) MEASURE) / 1e6;
-
-            double speedup = cpuMs / gpuMs;
-            System.out.printf("  CPU SIMD: %.2f ms | GPU: %.2f ms | Speedup: %.1f×%n%n",
-                    cpuMs, gpuMs, speedup);
-
-            gpuIndex.close();
-            cpuIndex.close();
-        }
-    }
-}
diff --git a/spector-bench/src/main/java/com/spectrayan/spector/bench/HeavyPerformanceBenchmark.java b/spector-bench/src/main/java/com/spectrayan/spector/bench/HeavyPerformanceBenchmark.java
index 37e4f82..4ef80a4 100644
--- a/spector-bench/src/main/java/com/spectrayan/spector/bench/HeavyPerformanceBenchmark.java
+++ b/spector-bench/src/main/java/com/spectrayan/spector/bench/HeavyPerformanceBenchmark.java
@@ -1,25 +1,9 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.bench;
 
-import com.spectrayan.spector.core.similarity.SimilarityFunction;
-import com.spectrayan.spector.config.SpectorConfig;
-import com.spectrayan.spector.engine.DefaultSpectorEngine;
+import com.spectrayan.spector.core.SimilarityFunction;
+import com.spectrayan.spector.engine.SpectorConfig;
 import com.spectrayan.spector.engine.SpectorEngine;
-import com.spectrayan.spector.config.HnswParams;
+import com.spectrayan.spector.index.HnswParams;
 import com.spectrayan.spector.query.SearchQuery;
 import com.spectrayan.spector.query.SearchResponse;
 
@@ -81,7 +65,7 @@ public void setup() {
         var hnswParams = new HnswParams(16, 200, 64);
         var config = new SpectorConfig(dimensions, datasetSize + 1000,
                 SimilarityFunction.COSINE, hnswParams);
-        engine = new DefaultSpectorEngine(config);
+        engine = new SpectorEngine(config);
 
         Random rng = new Random(42);
 
diff --git a/spector-bench/src/main/java/com/spectrayan/spector/bench/HnswBenchmark.java b/spector-bench/src/main/java/com/spectrayan/spector/bench/HnswBenchmark.java
index af8f6b5..c6f736d 100644
--- a/spector-bench/src/main/java/com/spectrayan/spector/bench/HnswBenchmark.java
+++ b/spector-bench/src/main/java/com/spectrayan/spector/bench/HnswBenchmark.java
@@ -1,23 +1,8 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.bench;
 
-import com.spectrayan.spector.core.similarity.SimilarityFunction;
+import com.spectrayan.spector.core.SimilarityFunction;
 import com.spectrayan.spector.index.HnswIndex;
-import com.spectrayan.spector.config.HnswParams;
+import com.spectrayan.spector.index.HnswParams;
 import com.spectrayan.spector.index.ScoredResult;
 
 import org.openjdk.jmh.annotations.*;
diff --git a/spector-bench/src/main/java/com/spectrayan/spector/bench/IndexOperationBenchmark.java b/spector-bench/src/main/java/com/spectrayan/spector/bench/IndexOperationBenchmark.java
index c860863..037b13e 100644
--- a/spector-bench/src/main/java/com/spectrayan/spector/bench/IndexOperationBenchmark.java
+++ b/spector-bench/src/main/java/com/spectrayan/spector/bench/IndexOperationBenchmark.java
@@ -1,25 +1,9 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.bench;
 
-import com.spectrayan.spector.core.similarity.SimilarityFunction;
-import com.spectrayan.spector.config.SpectorConfig;
-import com.spectrayan.spector.engine.DefaultSpectorEngine;
+import com.spectrayan.spector.core.SimilarityFunction;
+import com.spectrayan.spector.engine.SpectorConfig;
 import com.spectrayan.spector.engine.SpectorEngine;
-import com.spectrayan.spector.config.HnswParams;
+import com.spectrayan.spector.index.HnswParams;
 
 import org.openjdk.jmh.annotations.*;
 import org.openjdk.jmh.infra.Blackhole;
@@ -69,7 +53,7 @@ public void setup() {
         var hnswParams = new HnswParams(16, 200, 64);
         var config = new SpectorConfig(dimensions, datasetSize + 10_000,
                 SimilarityFunction.COSINE, hnswParams);
-        engine = new DefaultSpectorEngine(config);
+        engine = new SpectorEngine(config);
 
         Random rng = new Random(42);
         for (int i = 0; i < datasetSize; i++) {
diff --git a/spector-bench/src/main/java/com/spectrayan/spector/bench/IndustryBenchmark.java b/spector-bench/src/main/java/com/spectrayan/spector/bench/IndustryBenchmark.java
deleted file mode 100644
index 35b9463..0000000
--- a/spector-bench/src/main/java/com/spectrayan/spector/bench/IndustryBenchmark.java
+++ /dev/null
@@ -1,523 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.bench;
-
-import java.io.IOException;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.time.Duration;
-import java.time.Instant;
-import java.time.LocalDateTime;
-import java.time.format.DateTimeFormatter;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Random;
-import java.util.Set;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-import java.util.concurrent.Future;
-import java.util.concurrent.atomic.AtomicLong;
-
-import com.spectrayan.spector.core.simd.SimdCapability;
-import com.spectrayan.spector.core.similarity.SimilarityFunction;
-import com.spectrayan.spector.config.SpectorConfig;
-import com.spectrayan.spector.engine.DefaultSpectorEngine;
-import com.spectrayan.spector.engine.SpectorEngine;
-import com.spectrayan.spector.config.HnswParams;
-
-/**
- * Industry-standard benchmark following ann-benchmarks methodology.
- *
- * <p>Key differences from the previous PerformanceTestRunner:</p>
- * <ul>
- *   <li>Uses clustered (realistic) vectors, not uniform random</li>
- *   <li>Measures recall@K against brute-force ground truth</li>
- *   <li>Tests multiple dimensions: 128, 384, 768</li>
- *   <li>Uses realistic document sizes: 200-2000 words (like real paragraphs/pages)</li>
- *   <li>Reports QPS at specific recall thresholds</li>
- *   <li>Records system state (CPU%, RAM) during test</li>
- * </ul>
- *
- * <p>Run: {@code mvn -pl spector-bench exec:java -Dexec.mainClass=com.spectrayan.spector.bench.IndustryBenchmark}</p>
- */
-public class IndustryBenchmark {
-
-    // ─── Configuration ───
-    private static final int[] DATASET_SIZES = {10_000, 50_000, 100_000};
-    private static final int[] DIMENSIONS = {128, 384, 768};
-    private static final int WARMUP_QUERIES = 100;
-    private static final int MEASURE_QUERIES = 500;
-    private static final int[] CONCURRENCY_LEVELS = {1, 4, 8, 16};
-    private static final int TOP_K = 10;
-    private static final int NUM_CLUSTERS = 50; // for realistic vector generation
-
-    // Realistic document corpus words (varied topics, longer vocabulary)
-    private static final String[] CORPUS = {
-        "machine", "learning", "algorithm", "neural", "network", "deep",
-        "transformer", "attention", "embedding", "vector", "semantic",
-        "retrieval", "augmented", "generation", "language", "model",
-        "inference", "training", "gradient", "optimization", "batch",
-        "epoch", "loss", "function", "activation", "layer", "weight",
-        "bias", "dropout", "regularization", "normalization", "encoder",
-        "decoder", "tokenizer", "vocabulary", "context", "window",
-        "position", "encoding", "multi-head", "self-attention", "cross",
-        "architecture", "parameter", "fine-tuning", "pre-training",
-        "benchmark", "evaluation", "metric", "accuracy", "precision",
-        "recall", "f1-score", "latency", "throughput", "scalability",
-        "distributed", "parallel", "concurrent", "asynchronous", "pipeline",
-        "streaming", "real-time", "indexing", "search", "query",
-        "document", "passage", "chunk", "sentence", "paragraph",
-        "knowledge", "base", "graph", "ontology", "taxonomy",
-        "classification", "clustering", "similarity", "distance",
-        "nearest", "neighbor", "approximate", "exact", "brute-force",
-        "quantization", "compression", "pruning", "distillation",
-        "deployment", "production", "monitoring", "observability",
-        "infrastructure", "cloud", "server", "client", "api",
-        "endpoint", "request", "response", "authentication", "authorization",
-        "database", "storage", "memory", "cache", "buffer",
-        "performance", "optimization", "profiling", "bottleneck"
-    };
-
-    private final List<BenchResult> results = new ArrayList<>();
-    private final Runtime runtime = Runtime.getRuntime();
-
-    public static void main(String[] args) throws Exception {
-        new IndustryBenchmark().run();
-    }
-
-    public void run() throws Exception {
-        System.out.println("╔══════════════════════════════════════════════════════════════╗");
-        System.out.println("║   SPECTOR SEARCH — INDUSTRY-STANDARD BENCHMARK SUITE        ║");
-        System.out.println("╚══════════════════════════════════════════════════════════════╝");
-        System.out.println();
-        printSystemInfo();
-        System.out.println();
-
-        // Phase 1: Recall + Latency at different scales and dimensions
-        for (int dims : DIMENSIONS) {
-            for (int size : DATASET_SIZES) {
-                if (dims == 768 && size == 100_000) continue; // skip largest combo to keep runtime reasonable
-                runRecallLatencyBenchmark(dims, size);
-            }
-        }
-
-        // Phase 2: Document size impact (does content byte size affect search?)
-        runDocumentSizeImpact();
-
-        // Phase 3: Concurrency at 50K/384-dim (realistic production scenario)
-        runConcurrencyBenchmark(384, 50_000);
-
-        // Generate report
-        printSummary();
-        Path reportPath = Path.of("spector-bench", "target", "industry-benchmark.txt");
-        Files.createDirectories(reportPath.getParent());
-        writeReport(reportPath);
-        System.out.printf("%n  Report saved: %s%n", reportPath.toAbsolutePath());
-    }
-
-    private void printSystemInfo() {
-        long totalMem = runtime.maxMemory() / (1024 * 1024);
-        System.out.printf("  OS:         %s %s%n", System.getProperty("os.name"), System.getProperty("os.arch"));
-        System.out.printf("  Java:       %s%n", System.getProperty("java.version"));
-        System.out.printf("  CPUs:       %d logical cores%n", runtime.availableProcessors());
-        System.out.printf("  Max Heap:   %d MB%n", totalMem);
-        System.out.printf("  SIMD:       %s%n", SimdCapability.report());
-        System.out.printf("  Timestamp:  %s%n", LocalDateTime.now().format(DateTimeFormatter.ISO_LOCAL_DATE_TIME));
-    }
-
-    // ─────────────── Recall + Latency Benchmark ───────────────
-
-    private void runRecallLatencyBenchmark(int dims, int datasetSize) {
-        System.out.printf("▶ Recall+Latency: %,d docs × %d-dim%n", datasetSize, dims);
-
-        var hnswParams = new HnswParams(16, 200, 64);
-        var config = new SpectorConfig(dims, datasetSize + 1000,
-                SimilarityFunction.COSINE, hnswParams);
-
-        SpectorEngine engine = new DefaultSpectorEngine(config);
-        Random rng = new Random(42);
-
-        // Generate clustered vectors (realistic: embeddings form clusters in practice)
-        float[][] allVectors = generateClusteredVectors(datasetSize, dims, rng);
-
-        // Ingest with realistic document content
-        Instant ingestStart = Instant.now();
-        for (int i = 0; i < datasetSize; i++) {
-            String content = generateRealisticDocument(rng);
-            engine.ingest("doc-" + i, content, allVectors[i]);
-        }
-        Duration ingestTime = Duration.between(ingestStart, Instant.now());
-        double ingestRate = datasetSize / (ingestTime.toMillis() / 1000.0);
-        System.out.printf("  Ingested in %.1fs (%.0f docs/s)%n",
-                ingestTime.toMillis() / 1000.0, ingestRate);
-
-        // Generate query vectors from same distribution (realistic: queries are similar to corpus)
-        int numQueries = MEASURE_QUERIES;
-        float[][] queryVectors = new float[numQueries][];
-        Random qrng = new Random(999);
-        for (int i = 0; i < numQueries; i++) {
-            // Pick a random cluster center and add noise (simulates real queries)
-            int cluster = qrng.nextInt(NUM_CLUSTERS);
-            queryVectors[i] = perturbVector(allVectors[cluster * (datasetSize / NUM_CLUSTERS)], 0.3f, dims, qrng);
-        }
-
-        // Compute brute-force ground truth for recall measurement
-        int[][] groundTruth = computeGroundTruth(queryVectors, allVectors, TOP_K);
-
-        // Warmup
-        for (int i = 0; i < WARMUP_QUERIES; i++) {
-            engine.vectorSearch(queryVectors[i % numQueries], TOP_K);
-        }
-
-        // Measure vector search
-        long[] vectorNanos = new long[numQueries];
-        int totalRecallHits = 0;
-        for (int i = 0; i < numQueries; i++) {
-            long t0 = System.nanoTime();
-            var response = engine.vectorSearch(queryVectors[i], TOP_K);
-            vectorNanos[i] = System.nanoTime() - t0;
-
-            // Compute recall
-            Set<String> retrieved = new HashSet<>();
-            for (var r : response.results()) retrieved.add(r.id());
-            for (int gt : groundTruth[i]) {
-                if (retrieved.contains("doc-" + gt)) totalRecallHits++;
-            }
-        }
-        double recall = (double) totalRecallHits / (numQueries * TOP_K);
-        var vecStats = computeStats(vectorNanos);
-
-        System.out.printf("  Vector:  avg=%.3fms  p99=%.3fms  recall@%d=%.1f%%  QPS=%.0f%n",
-                vecStats.mean / 1e6, vecStats.p99 / 1e6, TOP_K, recall * 100, 1e9 / vecStats.mean);
-
-        results.add(new BenchResult("Vector Search", dims, datasetSize,
-                vecStats.mean / 1e6, vecStats.p99 / 1e6, 1e9 / vecStats.mean, recall));
-
-        // Measure keyword search
-        String[] queryTexts = {"machine learning neural network architecture",
-                "retrieval augmented generation language model",
-                "distributed parallel concurrent optimization",
-                "quantization compression approximate nearest neighbor",
-                "performance latency throughput scalability benchmark"};
-        long[] kwNanos = new long[numQueries];
-        for (int i = 0; i < numQueries; i++) {
-            String q = queryTexts[i % queryTexts.length];
-            long t0 = System.nanoTime();
-            engine.keywordSearch(q, TOP_K);
-            kwNanos[i] = System.nanoTime() - t0;
-        }
-        var kwStats = computeStats(kwNanos);
-        System.out.printf("  Keyword: avg=%.3fms  p99=%.3fms  QPS=%.0f%n",
-                kwStats.mean / 1e6, kwStats.p99 / 1e6, 1e9 / kwStats.mean);
-
-        results.add(new BenchResult("Keyword Search", dims, datasetSize,
-                kwStats.mean / 1e6, kwStats.p99 / 1e6, 1e9 / kwStats.mean, -1));
-
-        // Measure hybrid search
-        long[] hybNanos = new long[numQueries];
-        for (int i = 0; i < numQueries; i++) {
-            String q = queryTexts[i % queryTexts.length];
-            long t0 = System.nanoTime();
-            engine.hybridSearch(q, queryVectors[i], TOP_K);
-            hybNanos[i] = System.nanoTime() - t0;
-        }
-        var hybStats = computeStats(hybNanos);
-        System.out.printf("  Hybrid:  avg=%.3fms  p99=%.3fms  QPS=%.0f%n",
-                hybStats.mean / 1e6, hybStats.p99 / 1e6, 1e9 / hybStats.mean);
-
-        results.add(new BenchResult("Hybrid Search", dims, datasetSize,
-                hybStats.mean / 1e6, hybStats.p99 / 1e6, 1e9 / hybStats.mean, -1));
-
-        // Record ingestion
-        results.add(new BenchResult("Ingestion", dims, datasetSize,
-                ingestTime.toMillis(), 0, ingestRate, -1));
-
-        engine.close();
-        System.out.println();
-    }
-
-    // ─────────────── Document Size Impact ───────────────
-
-    private void runDocumentSizeImpact() {
-        System.out.println("▶ Document Size Impact Test (10K docs, 384-dim)");
-        int dims = 384;
-        int size = 10_000;
-        Random rng = new Random(42);
-        float[][] vectors = generateClusteredVectors(size, dims, rng);
-        float[] queryVec = perturbVector(vectors[0], 0.3f, dims, new Random(999));
-
-        int[][] docWordCounts = {{50, 100}, {200, 500}, {500, 1500}, {1000, 3000}};
-        String[] labels = {"Short (50-100w)", "Medium (200-500w)", "Long (500-1500w)", "Very Long (1-3Kw)"};
-
-        for (int t = 0; t < docWordCounts.length; t++) {
-            var hnswParams = new HnswParams(16, 200, 64);
-            var config = new SpectorConfig(dims, size + 1000, SimilarityFunction.COSINE, hnswParams);
-            SpectorEngine engine = new DefaultSpectorEngine(config);
-
-            int minWords = docWordCounts[t][0];
-            int maxWords = docWordCounts[t][1];
-            long totalBytes = 0;
-
-            for (int i = 0; i < size; i++) {
-                int wordCount = minWords + rng.nextInt(maxWords - minWords);
-                String content = generateDocument(wordCount, rng);
-                totalBytes += content.length();
-                engine.ingest("doc-" + i, content, vectors[i]);
-            }
-
-            // Warmup
-            for (int i = 0; i < 50; i++) engine.vectorSearch(queryVec, TOP_K);
-
-            // Measure
-            long[] nanos = new long[200];
-            for (int i = 0; i < 200; i++) {
-                long t0 = System.nanoTime();
-                engine.vectorSearch(queryVec, TOP_K);
-                nanos[i] = System.nanoTime() - t0;
-            }
-            var stats = computeStats(nanos);
-            long avgDocBytes = totalBytes / size;
-
-            System.out.printf("  %-20s avgDoc=%,dB  vecSearch=%.3fms  QPS=%.0f%n",
-                    labels[t], avgDocBytes, stats.mean / 1e6, 1e9 / stats.mean);
-
-            results.add(new BenchResult("DocSize:" + labels[t], dims, size,
-                    stats.mean / 1e6, stats.p99 / 1e6, 1e9 / stats.mean, -1));
-            engine.close();
-        }
-        System.out.println();
-    }
-
-    // ─────────────── Concurrency Benchmark ───────────────
-
-    private void runConcurrencyBenchmark(int dims, int datasetSize) throws Exception {
-        System.out.printf("▶ Concurrency Scaling: %,d docs × %d-dim%n", datasetSize, dims);
-
-        var hnswParams = new HnswParams(16, 200, 64);
-        var config = new SpectorConfig(dims, datasetSize + 1000,
-                SimilarityFunction.COSINE, hnswParams);
-        SpectorEngine engine = new DefaultSpectorEngine(config);
-        Random rng = new Random(42);
-
-        float[][] vectors = generateClusteredVectors(datasetSize, dims, rng);
-        for (int i = 0; i < datasetSize; i++) {
-            engine.ingest("doc-" + i, generateRealisticDocument(rng), vectors[i]);
-        }
-
-        for (int threads : CONCURRENCY_LEVELS) {
-            int opsPerThread = 300;
-            ExecutorService executor = Executors.newFixedThreadPool(threads);
-            AtomicLong totalOps = new AtomicLong();
-            AtomicLong totalNanos = new AtomicLong();
-
-            // Warmup
-            float[] wv = perturbVector(vectors[0], 0.3f, dims, new Random(999));
-            for (int i = 0; i < 50; i++) engine.hybridSearch("neural network", wv, TOP_K);
-
-            long wallStart = System.nanoTime();
-            List<Future<?>> futures = new ArrayList<>();
-
-            for (int t = 0; t < threads; t++) {
-                final int tid = t;
-                futures.add(executor.submit(() -> {
-                    Random trng = new Random(tid + 1000);
-                    float[] qv = perturbVector(vectors[trng.nextInt(datasetSize)], 0.3f, dims, trng);
-                    for (int i = 0; i < opsPerThread; i++) {
-                        long t0 = System.nanoTime();
-                        engine.hybridSearch("machine learning optimization", qv, TOP_K);
-                        totalNanos.addAndGet(System.nanoTime() - t0);
-                        totalOps.incrementAndGet();
-                    }
-                }));
-            }
-            for (var f : futures) f.get();
-            long wallElapsed = System.nanoTime() - wallStart;
-            executor.shutdown();
-
-            double wallSec = wallElapsed / 1e9;
-            double throughput = totalOps.get() / wallSec;
-            double avgLatencyMs = (totalNanos.get() / (double) totalOps.get()) / 1e6;
-
-            System.out.printf("  threads=%2d  throughput=%.0f ops/s  avgLatency=%.2fms%n",
-                    threads, throughput, avgLatencyMs);
-
-            results.add(new BenchResult("Concurrent(t=" + threads + ")", dims, datasetSize,
-                    avgLatencyMs, 0, throughput, -1));
-        }
-        engine.close();
-        System.out.println();
-    }
-
-    // ─────────────── Vector Generation (Clustered, Realistic) ───────────────
-
-    /**
-     * Generates vectors that form clusters (like real embeddings).
-     * Real embeddings from transformer models form clusters around topics/concepts.
-     */
-    private float[][] generateClusteredVectors(int count, int dims, Random rng) {
-        // Generate cluster centers
-        float[][] centers = new float[NUM_CLUSTERS][dims];
-        for (int c = 0; c < NUM_CLUSTERS; c++) {
-            for (int d = 0; d < dims; d++) {
-                centers[c][d] = (float) rng.nextGaussian() * 0.5f;
-            }
-            normalize(centers[c]);
-        }
-
-        // Generate vectors around cluster centers
-        float[][] vectors = new float[count][dims];
-        for (int i = 0; i < count; i++) {
-            int cluster = rng.nextInt(NUM_CLUSTERS);
-            for (int d = 0; d < dims; d++) {
-                vectors[i][d] = centers[cluster][d] + (float) rng.nextGaussian() * 0.15f;
-            }
-            normalize(vectors[i]);
-        }
-        return vectors;
-    }
-
-    private float[] perturbVector(float[] base, float noise, int dims, Random rng) {
-        float[] result = new float[dims];
-        for (int d = 0; d < dims; d++) {
-            result[d] = base[d] + (float) rng.nextGaussian() * noise;
-        }
-        normalize(result);
-        return result;
-    }
-
-    private void normalize(float[] v) {
-        float norm = 0;
-        for (float f : v) norm += f * f;
-        norm = (float) Math.sqrt(norm);
-        if (norm > 1e-10f) {
-            for (int i = 0; i < v.length; i++) v[i] /= norm;
-        }
-    }
-
-    // ─────────────── Ground Truth (Brute-Force KNN) ───────────────
-
-    private int[][] computeGroundTruth(float[][] queries, float[][] database, int k) {
-        int[][] truth = new int[queries.length][k];
-        for (int q = 0; q < queries.length; q++) {
-            // Compute all distances
-            float[] dists = new float[database.length];
-            for (int i = 0; i < database.length; i++) {
-                dists[i] = cosineSim(queries[q], database[i]);
-            }
-            // Find top-K by sorting indices
-            Integer[] indices = new Integer[database.length];
-            for (int i = 0; i < database.length; i++) indices[i] = i;
-            Arrays.sort(indices, (a, b) -> Float.compare(dists[b], dists[a]));
-            for (int i = 0; i < k; i++) truth[q][i] = indices[i];
-        }
-        return truth;
-    }
-
-    private float cosineSim(float[] a, float[] b) {
-        float dot = 0, na = 0, nb = 0;
-        for (int i = 0; i < a.length; i++) {
-            dot += a[i] * b[i];
-            na += a[i] * a[i];
-            nb += b[i] * b[i];
-        }
-        return (float) (dot / (Math.sqrt(na) * Math.sqrt(nb) + 1e-10));
-    }
-
-    // ─────────────── Document Generation ───────────────
-
-    /** Generates a realistic document (200-1500 words, paragraph structure). */
-    private String generateRealisticDocument(Random rng) {
-        return generateDocument(200 + rng.nextInt(1300), rng);
-    }
-
-    /** Generates a document of specified word count with paragraph breaks. */
-    private String generateDocument(int wordCount, Random rng) {
-        StringBuilder sb = new StringBuilder(wordCount * 8);
-        int sentenceLen = 8 + rng.nextInt(15);
-        int paraLen = 3 + rng.nextInt(5);
-        int sentenceCount = 0;
-
-        for (int w = 0; w < wordCount; w++) {
-            sb.append(CORPUS[rng.nextInt(CORPUS.length)]);
-            if ((w + 1) % sentenceLen == 0) {
-                sb.append(". ");
-                sentenceCount++;
-                sentenceLen = 8 + rng.nextInt(15);
-                if (sentenceCount % paraLen == 0) {
-                    sb.append("\n\n");
-                    paraLen = 3 + rng.nextInt(5);
-                }
-            } else {
-                sb.append(' ');
-            }
-        }
-        return sb.toString();
-    }
-
-    // ─────────────── Statistics ───────────────
-
-    record Stats(double min, double max, double mean, double p50, double p95, double p99) {}
-
-    private Stats computeStats(long[] nanos) {
-        Arrays.sort(nanos);
-        int n = nanos.length;
-        double sum = 0;
-        for (long v : nanos) sum += v;
-        double mean = sum / n;
-        return new Stats(nanos[0], nanos[n - 1], mean,
-                nanos[(int) (n * 0.50)], nanos[(int) (n * 0.95)], nanos[(int) (n * 0.99)]);
-    }
-
-    // ─────────────── Results ───────────────
-
-    record BenchResult(String name, int dims, int datasetSize,
-                       double avgMs, double p99Ms, double qps, double recall) {}
-
-    private void printSummary() {
-        System.out.println("═══════════════════════════════════════════════════════════════");
-        System.out.println("  SUMMARY");
-        System.out.println("═══════════════════════════════════════════════════════════════");
-        System.out.printf("  %-35s %8s %8s %10s %8s%n", "Benchmark", "Avg(ms)", "P99(ms)", "QPS", "Recall");
-        System.out.println("  " + "-".repeat(75));
-        for (var r : results) {
-            String recallStr = r.recall >= 0 ? String.format("%.1f%%", r.recall * 100) : "—";
-            System.out.printf("  %-35s %8.3f %8.3f %10.0f %8s%n",
-                    r.name + " " + r.dims + "d/" + r.datasetSize / 1000 + "K",
-                    r.avgMs, r.p99Ms, r.qps, recallStr);
-        }
-    }
-
-    private void writeReport(Path path) throws IOException {
-        StringBuilder sb = new StringBuilder();
-        sb.append("Spector Industry Benchmark\n");
-        sb.append("Generated: ").append(LocalDateTime.now()).append("\n");
-        sb.append("Java: ").append(System.getProperty("java.version")).append("\n");
-        sb.append("CPUs: ").append(runtime.availableProcessors()).append("\n");
-        sb.append("SIMD: ").append(SimdCapability.report()).append("\n\n");
-
-        sb.append(String.format("%-35s %8s %8s %10s %8s%n", "Benchmark", "Avg(ms)", "P99(ms)", "QPS", "Recall"));
-        sb.append("-".repeat(80)).append("\n");
-        for (var r : results) {
-            String recallStr = r.recall >= 0 ? String.format("%.1f%%", r.recall * 100) : "—";
-            sb.append(String.format("%-35s %8.3f %8.3f %10.0f %8s%n",
-                    r.name + " " + r.dims + "d/" + r.datasetSize / 1000 + "K",
-                    r.avgMs, r.p99Ms, r.qps, recallStr));
-        }
-        Files.writeString(path, sb.toString());
-    }
-}
diff --git a/spector-bench/src/main/java/com/spectrayan/spector/bench/IngestionBenchmark.java b/spector-bench/src/main/java/com/spectrayan/spector/bench/IngestionBenchmark.java
index e499cb3..7e88aa0 100644
--- a/spector-bench/src/main/java/com/spectrayan/spector/bench/IngestionBenchmark.java
+++ b/spector-bench/src/main/java/com/spectrayan/spector/bench/IngestionBenchmark.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.bench;
 
 import java.util.Random;
@@ -34,11 +19,10 @@
 import org.openjdk.jmh.annotations.Warmup;
 import org.openjdk.jmh.infra.Blackhole;
 
-import com.spectrayan.spector.core.similarity.SimilarityFunction;
-import com.spectrayan.spector.config.SpectorConfig;
-import com.spectrayan.spector.engine.DefaultSpectorEngine;
+import com.spectrayan.spector.core.SimilarityFunction;
+import com.spectrayan.spector.engine.SpectorConfig;
 import com.spectrayan.spector.engine.SpectorEngine;
-import com.spectrayan.spector.config.HnswParams;
+import com.spectrayan.spector.index.HnswParams;
 
 /**
  * Benchmarks measuring ingestion throughput for SpectorEngine.
@@ -89,7 +73,7 @@ public void setup() {
         var hnswParams = new HnswParams(16, 200, 64);
         var config = new SpectorConfig(dimensions, MAX_CAPACITY,
                 SimilarityFunction.COSINE, hnswParams);
-        engine = new DefaultSpectorEngine(config);
+        engine = new SpectorEngine(config);
         docCounter = 0;
         rng = new Random(42);
     }
diff --git a/spector-bench/src/main/java/com/spectrayan/spector/bench/IvfPqBenchmark.java b/spector-bench/src/main/java/com/spectrayan/spector/bench/IvfPqBenchmark.java
index 4ebc118..5293bd7 100644
--- a/spector-bench/src/main/java/com/spectrayan/spector/bench/IvfPqBenchmark.java
+++ b/spector-bench/src/main/java/com/spectrayan/spector/bench/IvfPqBenchmark.java
@@ -1,21 +1,6 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.bench;
 
-import com.spectrayan.spector.core.similarity.SimilarityFunction;
+import com.spectrayan.spector.core.SimilarityFunction;
 import com.spectrayan.spector.index.ScoredResult;
 import com.spectrayan.spector.index.ivf.IvfPqIndex;
 import com.spectrayan.spector.index.pq.ProductQuantizer;
diff --git a/spector-bench/src/main/java/com/spectrayan/spector/bench/PerformanceTestRunner.java b/spector-bench/src/main/java/com/spectrayan/spector/bench/PerformanceTestRunner.java
index a8d7328..b0ae675 100644
--- a/spector-bench/src/main/java/com/spectrayan/spector/bench/PerformanceTestRunner.java
+++ b/spector-bench/src/main/java/com/spectrayan/spector/bench/PerformanceTestRunner.java
@@ -1,28 +1,12 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.bench;
 
-import com.spectrayan.spector.core.similarity.CosineSimilarity;
-import com.spectrayan.spector.core.similarity.DotProduct;
-import com.spectrayan.spector.core.simd.SimdCapability;
-import com.spectrayan.spector.core.similarity.SimilarityFunction;
-import com.spectrayan.spector.config.SpectorConfig;
-import com.spectrayan.spector.engine.DefaultSpectorEngine;
+import com.spectrayan.spector.core.CosineSimilarity;
+import com.spectrayan.spector.core.DotProduct;
+import com.spectrayan.spector.core.SimdCapability;
+import com.spectrayan.spector.core.SimilarityFunction;
+import com.spectrayan.spector.engine.SpectorConfig;
 import com.spectrayan.spector.engine.SpectorEngine;
-import com.spectrayan.spector.config.HnswParams;
+import com.spectrayan.spector.index.HnswParams;
 
 import java.io.IOException;
 import java.io.PrintWriter;
@@ -155,7 +139,7 @@ private void runScaleBenchmark(int datasetSize) {
         long memBefore = usedMemoryMB();
         Instant ingestStart = Instant.now();
 
-        SpectorEngine engine = new DefaultSpectorEngine(config);
+        SpectorEngine engine = new SpectorEngine(config);
         Random rng = new Random(42);
 
         // Ingestion
@@ -230,7 +214,7 @@ private void runConcurrencyTest() throws Exception {
         var config = new SpectorConfig(DIMENSIONS, 51_000,
                 SimilarityFunction.COSINE, hnswParams);
 
-        SpectorEngine engine = new DefaultSpectorEngine(config);
+        SpectorEngine engine = new SpectorEngine(config);
         Random rng = new Random(42);
         for (int i = 0; i < 50_000; i++) {
             engine.ingest("doc-" + i, generateText(30, rng), randomVector(DIMENSIONS, rng));
@@ -417,7 +401,7 @@ private void generateHtmlReport(Path path) throws IOException {
         <head>
         <meta charset="UTF-8">
         <meta name="viewport" content="width=device-width, initial-scale=1.0">
-        <title>Spector — Performance Report</title>
+        <title>Spector Search — Performance Report</title>
         <script src="https://cdn.jsdelivr.net/npm/chart.js@4.4.4/dist/chart.umd.min.js"></script>
         <style>
           :root {
@@ -475,7 +459,7 @@ private void generateHtmlReport(Path path) throws IOException {
         </head>
         <body>
         <div class="header">
-          <h1>⚡ Spector Performance Report</h1>
+          <h1>⚡ Spector Search Performance Report</h1>
           <div class="meta">Generated: %s | Java %s | CPUs: %d | SIMD: %s</div>
         </div>
 
diff --git a/spector-bench/src/main/java/com/spectrayan/spector/bench/RealEmbeddingBench.java b/spector-bench/src/main/java/com/spectrayan/spector/bench/RealEmbeddingBench.java
deleted file mode 100644
index 55c13f3..0000000
--- a/spector-bench/src/main/java/com/spectrayan/spector/bench/RealEmbeddingBench.java
+++ /dev/null
@@ -1,418 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.bench;
-
-import com.spectrayan.spector.core.similarity.SimilarityFunction;
-import com.spectrayan.spector.config.HnswParams;
-import com.spectrayan.spector.index.ScoredResult;
-import com.spectrayan.spector.index.spectrum.SpectorIndex;
-
-import java.io.*;
-import java.net.URI;
-import java.net.http.HttpClient;
-import java.net.http.HttpRequest;
-import java.net.http.HttpResponse;
-import java.nio.ByteBuffer;
-import java.nio.ByteOrder;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.time.Duration;
-import java.util.*;
-import java.util.concurrent.*;
-
-/**
- * Real-embedding SpectorIndex benchmark using Ollama local embeddings.
- *
- * <p>Generates diverse text, embeds via Ollama (qwen3-embedding, 4096-dim),
- * caches embeddings to disk, then benchmarks SpectorIndex recall vs brute-force.</p>
- *
- * <p>Run: {@code java --add-modules jdk.incubator.vector -Xmx12g -cp ... RealEmbeddingBench}</p>
- */
-public class RealEmbeddingBench {
-
-    // Use smaller CORPUS for faster embedding; can increase later
-    private static final int DATASET_SIZE = 10_000;
-    private static final int BATCH_SIZE = 50;
-    private static final int CONCURRENT_BATCHES = 4;
-    private static final String MODEL = "qwen3-embedding";
-    private static final String OLLAMA_URL = "http://localhost:11434/api/embed";
-    private static final int N_QUERIES = 100;
-    private static final int WARMUP = 100;
-    private static final int MEASURE = 500;
-
-    // Sentence templates for diverse text generation
-    private static final String[][] TOPICS = {
-        // Science
-        {"The study of %s reveals fundamental principles about %s in the natural world",
-         "quantum mechanics", "particle physics", "thermodynamics", "electromagnetism",
-         "molecular biology", "organic chemistry", "astrophysics", "genetics",
-         "neuroscience", "biochemistry", "ecology", "paleontology"},
-        // Technology
-        {"Recent advances in %s have transformed how we approach %s in modern computing",
-         "machine learning", "cloud computing", "cybersecurity", "blockchain",
-         "quantum computing", "edge computing", "natural language processing", "robotics",
-         "computer vision", "distributed systems", "microservices", "DevOps"},
-        // History
-        {"The %s period was marked by significant developments in %s across civilizations",
-         "Renaissance", "Medieval", "Victorian", "Industrial Revolution",
-         "Ancient Greek", "Roman Empire", "Ming Dynasty", "Ottoman",
-         "Enlightenment", "Bronze Age", "Colonial", "Postwar"},
-        // Geography
-        {"The %s region is characterized by its unique %s and diverse ecosystems",
-         "Amazon rainforest", "Saharan desert", "Arctic tundra", "Mediterranean coastal",
-         "Himalayan mountain", "Pacific island", "African savanna", "European alpine",
-         "Southeast Asian tropical", "North American prairie", "Australian outback", "Antarctic"},
-        // Medicine
-        {"Clinical research on %s has led to breakthroughs in treating %s conditions",
-         "immunotherapy", "gene therapy", "stem cells", "CRISPR editing",
-         "mRNA vaccines", "monoclonal antibodies", "precision medicine", "regenerative medicine",
-         "pharmacogenomics", "biomarkers", "clinical trials", "drug delivery"},
-        // Arts
-        {"The influence of %s on contemporary %s continues to shape creative expression",
-         "impressionism", "surrealism", "minimalism", "abstract expressionism",
-         "baroque music", "jazz improvisation", "digital art", "street photography",
-         "postmodern literature", "experimental film", "modern dance", "installation art"},
-        // Economics
-        {"Global %s patterns indicate shifting trends in %s across major economies",
-         "trade", "investment", "inflation", "employment",
-         "monetary policy", "fiscal spending", "supply chain", "commodity pricing",
-         "currency exchange", "interest rate", "GDP growth", "market volatility"},
-        // Environment
-        {"The impact of %s on %s requires urgent attention from policymakers worldwide",
-         "deforestation", "ocean acidification", "carbon emissions", "plastic pollution",
-         "biodiversity loss", "water scarcity", "soil degradation", "air quality",
-         "glacier retreat", "coral bleaching", "species extinction", "urban sprawl"},
-    };
-
-    public static void main(String[] args) throws Exception {
-        System.out.println("╔══════════════════════════════════════════════════════════╗");
-        System.out.println("║   REAL EMBEDDING BENCHMARK (Ollama + SpectorIndex)      ║");
-        System.out.println("╚══════════════════════════════════════════════════════════╝");
-
-        Path cacheDir = Path.of("spector-bench/target/embedding-cache");
-        Files.createDirectories(cacheDir);
-        Path cacheFile = cacheDir.resolve(MODEL + "-" + DATASET_SIZE + ".bin");
-
-        float[][] embeddings;
-        int dims;
-
-        if (Files.exists(cacheFile)) {
-            System.out.printf("Loading cached embeddings from %s%n", cacheFile);
-            embeddings = loadEmbeddings(cacheFile);
-            dims = embeddings[0].length;
-            System.out.printf("Loaded %d vectors, %d dims%n", embeddings.length, dims);
-        } else {
-            System.out.printf("Generating %,d sentences...%n", DATASET_SIZE);
-            String[] sentences = generateSentences(DATASET_SIZE);
-            System.out.printf("Embedding via Ollama (%s, batch=%d, concurrent=%d)...%n",
-                    MODEL, BATCH_SIZE, CONCURRENT_BATCHES);
-            embeddings = embedAll(sentences);
-            dims = embeddings[0].length;
-            System.out.printf("Embedded %d vectors, %d dims%n", embeddings.length, dims);
-            saveEmbeddings(cacheFile, embeddings);
-            System.out.printf("Cached to %s%n", cacheFile);
-        }
-
-        // Generate query embeddings (embed fresh sentences)
-        System.out.printf("Embedding %d query sentences...%n", N_QUERIES);
-        String[] querySentences = generateQuerySentences(N_QUERIES);
-        float[][] queries = embedAll(querySentences);
-        System.out.printf("Query dims: %d%n%n", queries[0].length);
-
-        // Normalize all vectors for cosine comparability
-        for (float[] v : embeddings) normalize(v);
-        for (float[] q : queries) normalize(q);
-
-        // Compute brute-force ground truth (L2 on normalized = equivalent to cosine rank)
-        System.out.println("Computing brute-force ground truth...");
-        long gtStart = System.nanoTime();
-        int[][] groundTruth = computeGroundTruth(embeddings, queries, 10);
-        System.out.printf("Ground truth computed in %dms%n%n", (System.nanoTime() - gtStart) / 1_000_000);
-
-        // Test different centroid counts
-        int[] centroidCounts = {32, 64, 128};
-        int[] nProbes = {4, 8, 16, 32, 64};
-
-        for (int nCentroids : centroidCounts) {
-            System.out.printf("═══════════════════════════════════════════════════%n");
-            System.out.printf("▶ nCentroids=%d, dataset=%,d × %d-dim%n", nCentroids, DATASET_SIZE, dims);
-
-            for (int nProbe : nProbes) {
-                if (nProbe > nCentroids) continue;
-
-                SpectorIndex index = SpectorIndex.builder()
-                        .dimensions(dims)
-                        .nCentroids(nCentroids)
-                        .nProbe(nProbe)
-                        .shardThreshold(20_000)
-                        .oversamplingFactor(4)
-                        .similarityFunction(SimilarityFunction.COSINE)
-                        .hnswParams(new HnswParams(16, 128, 64))
-                        .build();
-
-                // Train on first 5000 vectors
-                int trainSize = Math.min(5000, DATASET_SIZE);
-                float[][] trainVecs = Arrays.copyOf(embeddings, trainSize);
-                index.train(trainVecs);
-
-                // Ingest
-                long t0 = System.nanoTime();
-                for (int i = 0; i < DATASET_SIZE; i++) {
-                    index.add("doc-" + i, i, embeddings[i]);
-                }
-                long ingestMs = (System.nanoTime() - t0) / 1_000_000;
-
-                // Warmup
-                for (int w = 0; w < WARMUP; w++) {
-                    index.search(queries[w % N_QUERIES], 10);
-                }
-
-                // Measure
-                long[] nanos = new long[MEASURE];
-                ScoredResult[][] results = new ScoredResult[N_QUERIES][];
-                for (int m = 0; m < MEASURE; m++) {
-                    int q = m % N_QUERIES;
-                    long start = System.nanoTime();
-                    results[q] = index.search(queries[q], 10);
-                    nanos[m] = System.nanoTime() - start;
-                }
-
-                // Recall
-                double recall = computeRecall(results, groundTruth, N_QUERIES);
-
-                // Latency stats
-                Arrays.sort(nanos);
-                double avg = Arrays.stream(nanos).average().orElse(0) / 1e6;
-                double p50 = nanos[MEASURE / 2] / 1e6;
-                double p99 = nanos[(int) (MEASURE * 0.99)] / 1e6;
-                double qps = 1e9 / (Arrays.stream(nanos).average().orElse(1));
-
-                System.out.printf("  nProbe=%-3d  avg=%.3fms  p50=%.3fms  p99=%.3fms  QPS=%-6.0f  recall@10=%.4f  ingest=%dms%n",
-                        nProbe, avg, p50, p99, qps, recall, ingestMs);
-
-                index.close();
-            }
-        }
-
-        System.out.println("═══════════════════════════════════════════════════");
-    }
-
-    // ── Sentence Generation ──
-
-    private static String[] generateSentences(int count) {
-        Random rng = new Random(42L);
-        String[] sentences = new String[count];
-        for (int i = 0; i < count; i++) {
-            String[] topic = TOPICS[rng.nextInt(TOPICS.length)];
-            String template = topic[0];
-            String arg1 = topic[1 + rng.nextInt(topic.length - 1)];
-            String arg2 = topic[1 + rng.nextInt(topic.length - 1)];
-            sentences[i] = String.format(template, arg1, arg2) + " (variant " + i + ")";
-        }
-        return sentences;
-    }
-
-    private static String[] generateQuerySentences(int count) {
-        Random rng = new Random(999L);
-        String[] sentences = new String[count];
-        for (int i = 0; i < count; i++) {
-            String[] topic = TOPICS[rng.nextInt(TOPICS.length)];
-            String template = topic[0];
-            String arg1 = topic[1 + rng.nextInt(topic.length - 1)];
-            String arg2 = topic[1 + rng.nextInt(topic.length - 1)];
-            sentences[i] = String.format(template, arg1, arg2);
-        }
-        return sentences;
-    }
-
-    // ── Ollama Embedding ──
-
-    private static float[][] embedAll(String[] sentences) throws Exception {
-        int total = sentences.length;
-        float[][] allEmbeddings = new float[total][];
-        int dims = -1;
-
-        ExecutorService pool = Executors.newFixedThreadPool(CONCURRENT_BATCHES);
-        HttpClient client = HttpClient.newBuilder()
-                .connectTimeout(Duration.ofSeconds(30))
-                .build();
-
-        List<Future<float[][]>> futures = new ArrayList<>();
-        int batchCount = 0;
-
-        for (int start = 0; start < total; start += BATCH_SIZE) {
-            final int batchStart = start;
-            final int batchEnd = Math.min(start + BATCH_SIZE, total);
-            final int batchNum = ++batchCount;
-            final int totalBatches = (total + BATCH_SIZE - 1) / BATCH_SIZE;
-
-            futures.add(pool.submit(() -> {
-                String[] batch = Arrays.copyOfRange(sentences, batchStart, batchEnd);
-                float[][] result = embedBatch(client, batch);
-                System.out.printf("  Batch %d/%d embedded (%d vectors)%n", batchNum, totalBatches, result.length);
-                return result;
-            }));
-        }
-
-        int idx = 0;
-        for (int start = 0; start < total; start += BATCH_SIZE) {
-            int batchEnd = Math.min(start + BATCH_SIZE, total);
-            float[][] batchResult = futures.get(idx++).get();
-            if (dims < 0) dims = batchResult[0].length;
-            System.arraycopy(batchResult, 0, allEmbeddings, start, batchEnd - start);
-        }
-
-        pool.shutdown();
-        return allEmbeddings;
-    }
-
-    private static float[][] embedBatch(HttpClient client, String[] texts) throws Exception {
-        // Build JSON manually for speed
-        StringBuilder json = new StringBuilder();
-        json.append("{\"model\":\"").append(MODEL).append("\",\"input\":[");
-        for (int i = 0; i < texts.length; i++) {
-            if (i > 0) json.append(",");
-            json.append("\"").append(escapeJson(texts[i])).append("\"");
-        }
-        json.append("]}");
-
-        HttpRequest request = HttpRequest.newBuilder()
-                .uri(URI.create(OLLAMA_URL))
-                .header("Content-Type", "application/json")
-                .timeout(Duration.ofSeconds(120))
-                .POST(HttpRequest.BodyPublishers.ofString(json.toString()))
-                .build();
-
-        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
-        if (response.statusCode() != 200) {
-            throw new RuntimeException("Ollama error " + response.statusCode() + ": " + response.body());
-        }
-
-        // Parse embeddings from JSON response
-        return parseEmbeddings(response.body());
-    }
-
-    private static float[][] parseEmbeddings(String json) {
-        // Simple parser for {"embeddings":[[1.0,2.0,...],[3.0,4.0,...],...]}
-        int embStart = json.indexOf("\"embeddings\"");
-        if (embStart < 0) throw new RuntimeException("No embeddings in response: " + json.substring(0, Math.min(200, json.length())));
-
-        int arrayStart = json.indexOf("[[", embStart);
-        int arrayEnd = json.lastIndexOf("]]");
-        if (arrayStart < 0 || arrayEnd < 0) throw new RuntimeException("Cannot parse embeddings array");
-
-        String inner = json.substring(arrayStart + 1, arrayEnd + 1); // "[1.0,...],[2.0,...]"
-        List<float[]> vectors = new ArrayList<>();
-
-        int pos = 0;
-        while (pos < inner.length()) {
-            int vecStart = inner.indexOf('[', pos);
-            if (vecStart < 0) break;
-            int vecEnd = inner.indexOf(']', vecStart);
-            if (vecEnd < 0) break;
-
-            String vecStr = inner.substring(vecStart + 1, vecEnd);
-            String[] parts = vecStr.split(",");
-            float[] vec = new float[parts.length];
-            for (int i = 0; i < parts.length; i++) {
-                vec[i] = Float.parseFloat(parts[i].trim());
-            }
-            vectors.add(vec);
-            pos = vecEnd + 1;
-        }
-
-        return vectors.toArray(new float[0][]);
-    }
-
-    private static String escapeJson(String s) {
-        return s.replace("\\", "\\\\")
-                .replace("\"", "\\\"")
-                .replace("\n", "\\n")
-                .replace("\r", "\\r")
-                .replace("\t", "\\t");
-    }
-
-    // ── Embedding Cache ──
-
-    private static void saveEmbeddings(Path path, float[][] embeddings) throws IOException {
-        int n = embeddings.length;
-        int dims = embeddings[0].length;
-        try (DataOutputStream out = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(path.toFile())))) {
-            out.writeInt(n);
-            out.writeInt(dims);
-            for (float[] vec : embeddings) {
-                for (float v : vec) out.writeFloat(v);
-            }
-        }
-    }
-
-    private static float[][] loadEmbeddings(Path path) throws IOException {
-        try (DataInputStream in = new DataInputStream(new BufferedInputStream(new FileInputStream(path.toFile())))) {
-            int n = in.readInt();
-            int dims = in.readInt();
-            float[][] embeddings = new float[n][dims];
-            for (int i = 0; i < n; i++) {
-                for (int d = 0; d < dims; d++) {
-                    embeddings[i][d] = in.readFloat();
-                }
-            }
-            return embeddings;
-        }
-    }
-
-    // ── Math ──
-
-    private static void normalize(float[] v) {
-        double norm = 0;
-        for (float f : v) norm += (double) f * f;
-        float scale = (float) (1.0 / Math.sqrt(norm));
-        for (int i = 0; i < v.length; i++) v[i] *= scale;
-    }
-
-    private static int[][] computeGroundTruth(float[][] data, float[][] queries, int k) {
-        int[][] truth = new int[queries.length][k];
-        for (int q = 0; q < queries.length; q++) {
-            float[] dists = new float[data.length];
-            for (int i = 0; i < data.length; i++) {
-                float sum = 0;
-                for (int d = 0; d < data[i].length; d++) {
-                    float diff = queries[q][d] - data[i][d];
-                    sum += diff * diff;
-                }
-                dists[i] = sum;
-            }
-            Integer[] indices = new Integer[data.length];
-            for (int i = 0; i < data.length; i++) indices[i] = i;
-            Arrays.sort(indices, (a, b) -> Float.compare(dists[a], dists[b]));
-            for (int i = 0; i < k; i++) truth[q][i] = indices[i];
-        }
-        return truth;
-    }
-
-    private static double computeRecall(ScoredResult[][] results, int[][] groundTruth, int nQueries) {
-        int hits = 0, total = 0;
-        for (int q = 0; q < nQueries; q++) {
-            if (results[q] == null) continue;
-            var truthSet = new HashSet<Integer>();
-            for (int idx : groundTruth[q]) truthSet.add(idx);
-            for (ScoredResult r : results[q]) {
-                if (truthSet.contains(r.index())) hits++;
-            }
-            total += groundTruth[q].length;
-        }
-        return total > 0 ? (double) hits / total : 0;
-    }
-}
diff --git a/spector-bench/src/main/java/com/spectrayan/spector/bench/RealEmbeddingScaleBench.java b/spector-bench/src/main/java/com/spectrayan/spector/bench/RealEmbeddingScaleBench.java
deleted file mode 100644
index 58e140a..0000000
--- a/spector-bench/src/main/java/com/spectrayan/spector/bench/RealEmbeddingScaleBench.java
+++ /dev/null
@@ -1,416 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.bench;
-
-import com.spectrayan.spector.core.similarity.SimilarityFunction;
-import com.spectrayan.spector.config.HnswParams;
-import com.spectrayan.spector.index.ScoredResult;
-import com.spectrayan.spector.index.spectrum.SpectorIndex;
-
-import java.io.*;
-import java.net.URI;
-import java.net.http.HttpClient;
-import java.net.http.HttpRequest;
-import java.net.http.HttpResponse;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.time.Duration;
-import java.util.*;
-import java.util.concurrent.*;
-
-/**
- * Optimized large-scale real-embedding benchmark for SpectorIndex (50K–100K).
- *
- * <p>Features:
- * 1. Persistent cache directory at project root (survives mvn clean).
- * 2. Optimized batch size (500) to maximize GPU utilization in local Ollama.
- * 3. Scalable to 50,000 or 100,000 vectors.
- * 4. Measures recall@10 against exact brute-force L2 ground-truth.</p>
- *
- * <p>Run: {@code java --add-modules jdk.incubator.vector -Xmx12g -cp ... com.spectrayan.spector.bench.RealEmbeddingScaleBench [size]}</p>
- */
-public class RealEmbeddingScaleBench {
-
-    private static int DATASET_SIZE = 50_000; // default, can override via args
-    private static final int BATCH_SIZE = 500; // Large batch size for high GPU throughput
-    private static final int CONCURRENT_BATCHES = 4;
-    private static final String MODEL = "qwen3-embedding";
-    private static final String OLLAMA_URL = "http://localhost:11434/api/embed";
-    private static final int N_QUERIES = 100;
-    private static final int WARMUP = 100;
-    private static final int MEASURE = 500;
-
-    // Sentence templates for diverse text generation
-    private static final String[][] TOPICS = {
-        {"The study of %s reveals fundamental principles about %s in the natural world",
-         "quantum mechanics", "particle physics", "thermodynamics", "electromagnetism",
-         "molecular biology", "organic chemistry", "astrophysics", "genetics",
-         "neuroscience", "biochemistry", "ecology", "paleontology"},
-        {"Recent advances in %s have transformed how we approach %s in modern computing",
-         "machine learning", "cloud computing", "cybersecurity", "blockchain",
-         "quantum computing", "edge computing", "natural language processing", "robotics",
-         "computer vision", "distributed systems", "microservices", "DevOps"},
-        {"The %s period was marked by significant developments in %s across civilizations",
-         "Renaissance", "Medieval", "Victorian", "Industrial Revolution",
-         "Ancient Greek", "Roman Empire", "Ming Dynasty", "Ottoman",
-         "Enlightenment", "Bronze Age", "Colonial", "Postwar"},
-        {"The %s region is characterized by its unique %s and diverse ecosystems",
-         "Amazon rainforest", "Saharan desert", "Arctic tundra", "Mediterranean coastal",
-         "Himalayan mountain", "Pacific island", "African savanna", "European alpine",
-         "Southeast Asian tropical", "North American prairie", "Australian outback", "Antarctic"},
-        {"Clinical research on %s has led to breakthroughs in treating %s conditions",
-         "immunotherapy", "gene therapy", "stem cells", "CRISPR editing",
-         "mRNA vaccines", "monoclonal antibodies", "precision medicine", "regenerative medicine",
-         "pharmacogenomics", "biomarkers", "clinical trials", "drug delivery"},
-        {"The influence of %s on contemporary %s continues to shape creative expression",
-         "impressionism", "surrealism", "minimalism", "abstract expressionism",
-         "baroque music", "jazz improvisation", "digital art", "street photography",
-         "postmodern literature", "experimental film", "modern dance", "installation art"},
-        {"Global %s patterns indicate shifting trends in %s across major economies",
-         "trade", "investment", "inflation", "employment",
-         "monetary policy", "fiscal spending", "supply chain", "commodity pricing",
-         "currency exchange", "interest rate", "GDP growth", "market volatility"},
-        {"The impact of %s on %s requires urgent attention from policymakers worldwide",
-         "deforestation", "ocean acidification", "carbon emissions", "plastic pollution",
-         "biodiversity loss", "water scarcity", "soil degradation", "air quality",
-         "glacier retreat", "coral bleaching", "species extinction", "urban sprawl"}
-    };
-
-    public static void main(String[] args) throws Exception {
-        if (args.length > 0) {
-            try {
-                DATASET_SIZE = Integer.parseInt(args[0]);
-            } catch (NumberFormatException e) {
-                System.out.println("Invalid size argument, using default: " + DATASET_SIZE);
-            }
-        }
-
-        System.out.println("╔══════════════════════════════════════════════════════════╗");
-        System.out.printf("║ REAL EMBEDDING LARGE SCALE BENCHMARK (%,d vectors)  ║%n", DATASET_SIZE);
-        System.out.println("╚══════════════════════════════════════════════════════════╝");
-
-        // Persistent cache directory at project root (independent of maven target)
-        Path cacheDir = Path.of("embedding-cache");
-        Files.createDirectories(cacheDir);
-        Path cacheFile = cacheDir.resolve(MODEL + "-" + DATASET_SIZE + ".bin");
-
-        float[][] embeddings;
-        int dims;
-
-        if (Files.exists(cacheFile)) {
-            System.out.printf("Loading cached embeddings from %s%n", cacheFile);
-            embeddings = loadEmbeddings(cacheFile);
-            dims = embeddings[0].length;
-            System.out.printf("Loaded %,d vectors, %d dims%n", embeddings.length, dims);
-        } else {
-            System.out.printf("Generating %,d sentences...%n", DATASET_SIZE);
-            String[] sentences = generateSentences(DATASET_SIZE);
-            System.out.printf("Embedding via Ollama (%s, batch=%d, concurrent=%d)...%n",
-                    MODEL, BATCH_SIZE, CONCURRENT_BATCHES);
-            embeddings = embedAll(sentences);
-            dims = embeddings[0].length;
-            System.out.printf("Embedded %,d vectors, %d dims%n", embeddings.length, dims);
-            saveEmbeddings(cacheFile, embeddings);
-            System.out.printf("Cached to %s%n", cacheFile);
-        }
-
-        // Generate query embeddings (embed fresh sentences)
-        System.out.printf("Embedding %d query sentences...%n", N_QUERIES);
-        String[] querySentences = generateQuerySentences(N_QUERIES);
-        float[][] queries = embedAll(querySentences);
-        System.out.printf("Query dims: %d%n%n", queries[0].length);
-
-        // Normalize all vectors for cosine comparability
-        for (float[] v : embeddings) normalize(v);
-        for (float[] q : queries) normalize(q);
-
-        // Compute brute-force ground truth (L2 on normalized = equivalent to cosine rank)
-        System.out.println("Computing brute-force ground truth...");
-        long gtStart = System.nanoTime();
-        int[][] groundTruth = computeGroundTruth(embeddings, queries, 10);
-        System.out.printf("Ground truth computed in %dms%n%n", (System.nanoTime() - gtStart) / 1_000_000);
-
-        // Test configurations
-        int[] centroidCounts = {128, 256};
-        int[] nProbes = {4, 8, 16, 32, 64};
-
-        for (int nCentroids : centroidCounts) {
-            System.out.printf("═══════════════════════════════════════════════════%n");
-            System.out.printf("▶ nCentroids=%d, dataset=%,d × %d-dim%n", nCentroids, DATASET_SIZE, dims);
-
-            for (int nProbe : nProbes) {
-                if (nProbe > nCentroids) continue;
-
-                SpectorIndex index = SpectorIndex.builder()
-                        .dimensions(dims)
-                        .nCentroids(nCentroids)
-                        .nProbe(nProbe)
-                        .shardThreshold(100_000) // Keep flat mode for direct comparisons
-                        .oversamplingFactor(4)
-                        .similarityFunction(SimilarityFunction.COSINE)
-                        .hnswParams(new HnswParams(16, 128, 64))
-                        .build();
-
-                // Train on first 10,000 vectors
-                int trainSize = Math.min(10_000, DATASET_SIZE);
-                float[][] trainVecs = Arrays.copyOf(embeddings, trainSize);
-                index.train(trainVecs);
-
-                // Ingest
-                long t0 = System.nanoTime();
-                for (int i = 0; i < DATASET_SIZE; i++) {
-                    index.add("doc-" + i, i, embeddings[i]);
-                }
-                long ingestMs = (System.nanoTime() - t0) / 1_000_000;
-
-                // Warmup
-                for (int w = 0; w < WARMUP; w++) {
-                    index.search(queries[w % N_QUERIES], 10);
-                }
-
-                // Measure
-                long[] nanos = new long[MEASURE];
-                ScoredResult[][] results = new ScoredResult[N_QUERIES][];
-                for (int m = 0; m < MEASURE; m++) {
-                    int q = m % N_QUERIES;
-                    long start = System.nanoTime();
-                    results[q] = index.search(queries[q], 10);
-                    nanos[m] = System.nanoTime() - start;
-                }
-
-                // Recall
-                double recall = computeRecall(results, groundTruth, N_QUERIES);
-
-                // Latency stats
-                Arrays.sort(nanos);
-                double avg = Arrays.stream(nanos).average().orElse(0) / 1e6;
-                double p50 = nanos[MEASURE / 2] / 1e6;
-                double p99 = nanos[(int) (MEASURE * 0.99)] / 1e6;
-                double qps = 1e9 / (Arrays.stream(nanos).average().orElse(1));
-
-                System.out.printf("  nProbe=%-3d  avg=%.3fms  p50=%.3fms  p99=%.3fms  QPS=%-6.0f  recall@10=%.4f  ingest=%dms%n",
-                        nProbe, avg, p50, p99, qps, recall, ingestMs);
-
-                index.close();
-            }
-        }
-
-        System.out.println("═══════════════════════════════════════════════════");
-    }
-
-    // ── Sentence Generation ──
-
-    private static String[] generateSentences(int count) {
-        Random rng = new Random(42L);
-        String[] sentences = new String[count];
-        for (int i = 0; i < count; i++) {
-            String[] topic = TOPICS[rng.nextInt(TOPICS.length)];
-            String template = topic[0];
-            String arg1 = topic[1 + rng.nextInt(topic.length - 1)];
-            String arg2 = topic[1 + rng.nextInt(topic.length - 1)];
-            sentences[i] = String.format(template, arg1, arg2) + " (variant " + i + ")";
-        }
-        return sentences;
-    }
-
-    private static String[] generateQuerySentences(int count) {
-        Random rng = new Random(999L);
-        String[] sentences = new String[count];
-        for (int i = 0; i < count; i++) {
-            String[] topic = TOPICS[rng.nextInt(TOPICS.length)];
-            String template = topic[0];
-            String arg1 = topic[1 + rng.nextInt(topic.length - 1)];
-            String arg2 = topic[1 + rng.nextInt(topic.length - 1)];
-            sentences[i] = String.format(template, arg1, arg2);
-        }
-        return sentences;
-    }
-
-    // ── Ollama Embedding ──
-
-    private static float[][] embedAll(String[] sentences) throws Exception {
-        int total = sentences.length;
-        float[][] allEmbeddings = new float[total][];
-        int dims = -1;
-
-        ExecutorService pool = Executors.newFixedThreadPool(CONCURRENT_BATCHES);
-        HttpClient client = HttpClient.newBuilder()
-                .connectTimeout(Duration.ofSeconds(60))
-                .build();
-
-        List<Future<float[][]>> futures = new ArrayList<>();
-        int batchCount = 0;
-
-        for (int start = 0; start < total; start += BATCH_SIZE) {
-            final int batchStart = start;
-            final int batchEnd = Math.min(start + BATCH_SIZE, total);
-            final int batchNum = ++batchCount;
-            final int totalBatches = (total + BATCH_SIZE - 1) / BATCH_SIZE;
-
-            futures.add(pool.submit(() -> {
-                String[] batch = Arrays.copyOfRange(sentences, batchStart, batchEnd);
-                float[][] result = embedBatch(client, batch);
-                System.out.printf("  Batch %d/%d embedded (%d vectors)%n", batchNum, totalBatches, result.length);
-                return result;
-            }));
-        }
-
-        int idx = 0;
-        for (int start = 0; start < total; start += BATCH_SIZE) {
-            int batchEnd = Math.min(start + BATCH_SIZE, total);
-            float[][] batchResult = futures.get(idx++).get();
-            if (dims < 0) dims = batchResult[0].length;
-            System.arraycopy(batchResult, 0, allEmbeddings, start, batchEnd - start);
-        }
-
-        pool.shutdown();
-        return allEmbeddings;
-    }
-
-    private static float[][] embedBatch(HttpClient client, String[] texts) throws Exception {
-        StringBuilder json = new StringBuilder();
-        json.append("{\"model\":\"").append(MODEL).append("\",\"input\":[");
-        for (int i = 0; i < texts.length; i++) {
-            if (i > 0) json.append(",");
-            json.append("\"").append(escapeJson(texts[i])).append("\"");
-        }
-        json.append("]}");
-
-        HttpRequest request = HttpRequest.newBuilder()
-                .uri(URI.create(OLLAMA_URL))
-                .header("Content-Type", "application/json")
-                .timeout(Duration.ofSeconds(300))
-                .POST(HttpRequest.BodyPublishers.ofString(json.toString()))
-                .build();
-
-        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
-        if (response.statusCode() != 200) {
-            throw new RuntimeException("Ollama error " + response.statusCode() + ": " + response.body());
-        }
-
-        return parseEmbeddings(response.body());
-    }
-
-    private static float[][] parseEmbeddings(String json) {
-        int embStart = json.indexOf("\"embeddings\"");
-        if (embStart < 0) throw new RuntimeException("No embeddings in response: " + json.substring(0, Math.min(200, json.length())));
-
-        int arrayStart = json.indexOf("[[", embStart);
-        int arrayEnd = json.lastIndexOf("]]");
-        if (arrayStart < 0 || arrayEnd < 0) throw new RuntimeException("Cannot parse embeddings array");
-
-        String inner = json.substring(arrayStart + 1, arrayEnd + 1);
-        List<float[]> vectors = new ArrayList<>();
-
-        int pos = 0;
-        while (pos < inner.length()) {
-            int vecStart = inner.indexOf('[', pos);
-            if (vecStart < 0) break;
-            int vecEnd = inner.indexOf(']', vecStart);
-            if (vecEnd < 0) break;
-
-            String vecStr = inner.substring(vecStart + 1, vecEnd);
-            String[] parts = vecStr.split(",");
-            float[] vec = new float[parts.length];
-            for (int i = 0; i < parts.length; i++) {
-                vec[i] = Float.parseFloat(parts[i].trim());
-            }
-            vectors.add(vec);
-            pos = vecEnd + 1;
-        }
-
-        return vectors.toArray(new float[0][]);
-    }
-
-    private static String escapeJson(String s) {
-        return s.replace("\\", "\\\\")
-                .replace("\"", "\\\"")
-                .replace("\n", "\\n")
-                .replace("\r", "\\r")
-                .replace("\t", "\\t");
-    }
-
-    // ── Embedding Cache ──
-
-    private static void saveEmbeddings(Path path, float[][] embeddings) throws IOException {
-        int n = embeddings.length;
-        int dims = embeddings[0].length;
-        try (DataOutputStream out = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(path.toFile())))) {
-            out.writeInt(n);
-            out.writeInt(dims);
-            for (float[] vec : embeddings) {
-                for (float v : vec) out.writeFloat(v);
-            }
-        }
-    }
-
-    private static float[][] loadEmbeddings(Path path) throws IOException {
-        try (DataInputStream in = new DataInputStream(new BufferedInputStream(new FileInputStream(path.toFile())))) {
-            int n = in.readInt();
-            int dims = in.readInt();
-            float[][] embeddings = new float[n][dims];
-            for (int i = 0; i < n; i++) {
-                for (int d = 0; d < dims; d++) {
-                    embeddings[i][d] = in.readFloat();
-                }
-            }
-            return embeddings;
-        }
-    }
-
-    // ── Math ──
-
-    private static void normalize(float[] v) {
-        double norm = 0;
-        for (float f : v) norm += (double) f * f;
-        float scale = (float) (1.0 / Math.sqrt(norm));
-        for (int i = 0; i < v.length; i++) v[i] *= scale;
-    }
-
-    private static int[][] computeGroundTruth(float[][] data, float[][] queries, int k) {
-        int[][] truth = new int[queries.length][k];
-        for (int q = 0; q < queries.length; q++) {
-            float[] dists = new float[data.length];
-            for (int i = 0; i < data.length; i++) {
-                float sum = 0;
-                for (int d = 0; d < data[i].length; d++) {
-                    float diff = queries[q][d] - data[i][d];
-                    sum += diff * diff;
-                }
-                dists[i] = sum;
-            }
-            Integer[] indices = new Integer[data.length];
-            for (int i = 0; i < data.length; i++) indices[i] = i;
-            Arrays.sort(indices, (a, b) -> Float.compare(dists[a], dists[b]));
-            for (int i = 0; i < k; i++) truth[q][i] = indices[i];
-        }
-        return truth;
-    }
-
-    private static double computeRecall(ScoredResult[][] results, int[][] groundTruth, int nQueries) {
-        int hits = 0, total = 0;
-        for (int q = 0; q < nQueries; q++) {
-            if (results[q] == null) continue;
-            var truthSet = new HashSet<Integer>();
-            for (int idx : groundTruth[q]) truthSet.add(idx);
-            for (ScoredResult r : results[q]) {
-                if (truthSet.contains(r.index())) hits++;
-            }
-            total += groundTruth[q].length;
-        }
-        return total > 0 ? (double) hits / total : 0;
-    }
-}
diff --git a/spector-bench/src/main/java/com/spectrayan/spector/bench/RecallVsQpsBenchmark.java b/spector-bench/src/main/java/com/spectrayan/spector/bench/RecallVsQpsBenchmark.java
deleted file mode 100644
index 0138194..0000000
--- a/spector-bench/src/main/java/com/spectrayan/spector/bench/RecallVsQpsBenchmark.java
+++ /dev/null
@@ -1,200 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.bench;
-
-import com.spectrayan.spector.core.similarity.SimilarityFunction;
-import com.spectrayan.spector.config.HnswParams;
-import com.spectrayan.spector.index.HnswIndex;
-import com.spectrayan.spector.index.QuantizedHnswIndex;
-import com.spectrayan.spector.index.ScoredResult;
-import com.spectrayan.spector.index.spectrum.SpectorIndex;
-
-import org.openjdk.jmh.annotations.*;
-import org.openjdk.jmh.infra.Blackhole;
-
-import java.util.*;
-import java.util.concurrent.TimeUnit;
-
-/**
- * Recall@10 vs QPS benchmark: compares SpectorIndex against plain HNSW and exact brute force.
- *
- * <p>This is the primary <b>quality benchmark</b> — it measures the recall/speed trade-off
- * curve that determines whether SpectorIndex is worth using over simpler alternatives.</p>
- *
- * <h3>Methodology</h3>
- * <ol>
- *   <li>Build an exact brute-force index (all vectors in RAM) to generate ground truth.</li>
- *   <li>Build the candidate index (SpectorIndex or plain HNSW).</li>
- *   <li>Run {@link #QUERY_COUNT} queries, compare top-K against ground truth.</li>
- *   <li>Report recall@K = |approx ∩ exact| / K.</li>
- * </ol>
- *
- * <p>The JMH throughput measurement gives QPS for the search phase only
- * (index build is in {@code @Setup}).</p>
- *
- * <p>Run via:</p>
- * <pre>
- *   java -jar spector-bench/target/benchmarks.jar RecallVsQpsBenchmark
- * </pre>
- */
-@BenchmarkMode(Mode.Throughput)
-@OutputTimeUnit(TimeUnit.SECONDS)
-@State(Scope.Benchmark)
-@Warmup(iterations = 3, time = 3)
-@Measurement(iterations = 5, time = 5)
-@Fork(value = 1, jvmArgsAppend = {
-        "--add-modules", "jdk.incubator.vector",
-        "--enable-native-access=ALL-UNNAMED",
-        "-Xmx6g", "-Xms4g",
-        "-XX:+UseZGC"
-})
-public class RecallVsQpsBenchmark {
-
-    private static final int K            = 10;
-    private static final int QUERY_COUNT  = 100;
-
-    @Param({"128"})
-    int dims;
-
-    @Param({"50000"})
-    int totalVectors;
-
-    // nProbe for SpectorIndex — drives the recall/QPS curve
-    @Param({"2", "4", "8", "16", "32"})
-    int nProbe;
-
-    private SpectorIndex spectorIndex;
-    private HnswIndex    exactHnswIndex;
-    private float[][]    queryVectors;
-
-    // Recall is computed in setup and reported via System.out (not JMH metrics)
-    private double spectorRecallAtK;
-    private double hnswRecallAtK;
-
-    @Setup(Level.Trial)
-    public void setup() {
-        Random rng = new Random(42L);
-        HnswParams hnswParams = new HnswParams(16, 128, 64);
-
-        // ── Build SpectorIndex ────────────────────────────────────────────────
-        spectorIndex = SpectorIndex.builder()
-                .dimensions(dims)
-                .nCentroids(32)
-                .nProbe(nProbe)
-                .shardThreshold(20_000)
-                .oversamplingFactor(3)
-                .similarityFunction(SimilarityFunction.COSINE)
-                .hnswParams(hnswParams)
-                .build();
-
-        // ── Build exact HNSW (ground truth) ──────────────────────────────────
-        exactHnswIndex = new HnswIndex(dims, totalVectors + 10,
-                SimilarityFunction.COSINE, hnswParams);
-
-        // Train SpectorIndex
-        int trainSize = Math.min(10_000, totalVectors);
-        float[][] trainVectors = new float[trainSize][dims];
-        for (int i = 0; i < trainSize; i++) trainVectors[i] = gaussianUnit(rng, dims);
-        spectorIndex.train(trainVectors);
-
-        // Index all vectors
-        float[][] vectors = new float[totalVectors][dims];
-        for (int i = 0; i < totalVectors; i++) {
-            vectors[i] = gaussianUnit(rng, dims);
-            spectorIndex.add("doc-" + i, i, vectors[i]);
-            exactHnswIndex.add("doc-" + i, i, vectors[i]);
-        }
-
-        // ── Build query set ───────────────────────────────────────────────────
-        queryVectors = new float[QUERY_COUNT][dims];
-        Random queryRng = new Random(999L);
-        for (int q = 0; q < QUERY_COUNT; q++) {
-            queryVectors[q] = gaussianUnit(queryRng, dims);
-        }
-
-        // ── Pre-compute recall for reporting ─────────────────────────────────
-        spectorRecallAtK = measureRecall(spectorIndex, exactHnswIndex, queryVectors, K);
-        System.out.printf(
-                "%n[RecallVsQpsBenchmark] dims=%d, N=%d, nProbe=%d → SpectorIndex recall@%d = %.4f%n",
-                dims, totalVectors, nProbe, K, spectorRecallAtK);
-    }
-
-    @TearDown(Level.Trial)
-    public void tearDown() {
-        spectorIndex.close();
-        exactHnswIndex.close();
-    }
-
-    // ── Search throughput benchmarks ─────────────────────────────────────────
-
-    /**
-     * SpectorIndex search throughput — the primary metric.
-     * Cycles through all QUERY_COUNT queries to avoid query-vector cache effects.
-     */
-    @Benchmark
-    public ScoredResult[] spectorIndex_search(org.openjdk.jmh.infra.BenchmarkParams bp,
-                                               Blackhole bh) {
-        // Rotate through queries so the same query vector isn't always in cache
-        int q = (int) (System.nanoTime() % QUERY_COUNT);
-        ScoredResult[] results = spectorIndex.search(queryVectors[q], K);
-        bh.consume(results);
-        return results;
-    }
-
-    /**
-     * Exact HNSW search throughput — the quality baseline.
-     * SpectorIndex must get close to this recall while beating its QPS at large N.
-     */
-    @Benchmark
-    public ScoredResult[] exactHnsw_search(Blackhole bh) {
-        int q = (int) (System.nanoTime() % QUERY_COUNT);
-        ScoredResult[] results = exactHnswIndex.search(queryVectors[q], K);
-        bh.consume(results);
-        return results;
-    }
-
-    // ── Recall helper ────────────────────────────────────────────────────────
-
-    private static double measureRecall(SpectorIndex approx, HnswIndex exact,
-                                         float[][] queries, int k) {
-        int totalHits = 0;
-        for (float[] q : queries) {
-            ScoredResult[] approxResults = approx.search(q, k);
-            ScoredResult[] exactResults  = exact.search(q, k);
-
-            Set<String> exactIds = new HashSet<>();
-            for (ScoredResult r : exactResults) exactIds.add(r.id());
-            for (ScoredResult r : approxResults) {
-                if (exactIds.contains(r.id())) totalHits++;
-            }
-        }
-        return (double) totalHits / ((double) queries.length * k);
-    }
-
-    // ── Helpers ──────────────────────────────────────────────────────────────
-
-    private static float[] gaussianUnit(Random rng, int dims) {
-        float[] v = new float[dims];
-        double norm = 0;
-        for (int i = 0; i < dims; i++) {
-            v[i] = (float) rng.nextGaussian();
-            norm += (double) v[i] * v[i];
-        }
-        float scale = (float) (1.0 / Math.sqrt(norm));
-        for (int i = 0; i < dims; i++) v[i] *= scale;
-        return v;
-    }
-}
diff --git a/spector-bench/src/main/java/com/spectrayan/spector/bench/Sift1MAnnBenchmark.java b/spector-bench/src/main/java/com/spectrayan/spector/bench/Sift1MAnnBenchmark.java
deleted file mode 100644
index e568199..0000000
--- a/spector-bench/src/main/java/com/spectrayan/spector/bench/Sift1MAnnBenchmark.java
+++ /dev/null
@@ -1,226 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.bench;
-
-import com.spectrayan.spector.core.similarity.SimilarityFunction;
-import com.spectrayan.spector.index.HnswIndex;
-import com.spectrayan.spector.config.HnswParams;
-import com.spectrayan.spector.index.ScoredResult;
-import com.spectrayan.spector.index.spectrum.SpectorIndex;
-
-import java.io.*;
-import java.nio.*;
-import java.nio.channels.FileChannel;
-import java.nio.file.*;
-import java.util.*;
-
-/**
- * Standard ANN benchmark using the SIFT1M dataset.
- *
- * <p>SIFT1M is the canonical dataset for ANN algorithm comparison (ann-benchmarks.github.io).
- * It contains 1 million 128-dimensional SIFT descriptors, 10,000 queries, and precomputed
- * ground-truth nearest neighbors for the top 100 candidates per query.</p>
- *
- * <h3>Dataset download</h3>
- * <pre>
- *   # Download from http://corpus-texmex.irisa.fr/
- *   wget ftp://ftp.irisa.fr/local/texmex/corpus/sift.tar.gz
- *   tar -xf sift.tar.gz
- * </pre>
- *
- * <h3>Running</h3>
- * <p>This is a standalone main-class benchmark (not JMH) because the 1M-vector
- * setup cost is too high for JMH's fork/warmup lifecycle. It measures:</p>
- * <ul>
- *   <li>Ingest throughput (vectors/sec)</li>
- *   <li>Recall@10 at various nProbe values {1, 2, 4, 8, 16, 32}</li>
- *   <li>QPS (queries/sec) at each nProbe</li>
- * </ul>
- *
- * <p>Run via:</p>
- * <pre>
- *   mvn -pl spector-bench exec:java \
- *     -Dexec.mainClass=com.spectrayan.spector.bench.Sift1MAnnBenchmark \
- *     -Dexec.args="path/to/sift"
- * </pre>
- */
-public class Sift1MAnnBenchmark {
-
-    private static final int DIMS        = 128;
-    private static final int K           = 10;
-    private static final int N_CENTROIDS = 256;
-    private static final int TRAIN_SIZE  = 50_000;  // K-Means sample from base
-
-    public static void main(String[] args) throws Exception {
-        String dataDir = args.length > 0 ? args[0] : "sift";
-
-        System.out.println("=== Spector SIFT1M ANN Benchmark ===");
-        System.out.println("Dataset: " + dataDir);
-
-        // ── Load dataset ──────────────────────────────────────────────────────
-        System.out.print("Loading sift_base.fvecs (1M × 128)... ");
-        float[][] base    = readFvecs(Paths.get(dataDir, "sift_base.fvecs"));
-        System.out.printf("done (%d vectors)%n", base.length);
-
-        System.out.print("Loading sift_query.fvecs (10K × 128)... ");
-        float[][] queries = readFvecs(Paths.get(dataDir, "sift_query.fvecs"));
-        System.out.printf("done (%d queries)%n", queries.length);
-
-        System.out.print("Loading sift_groundtruth.ivecs (10K × 100)... ");
-        int[][] gt        = readIvecs(Paths.get(dataDir, "sift_groundtruth.ivecs"));
-        System.out.printf("done (%d × %d ground truth)%n", gt.length, gt[0].length);
-
-        // ── Train SpectorIndex ────────────────────────────────────────────────
-        System.out.printf("%nBuilding SpectorIndex (nCentroids=%d)...%n", N_CENTROIDS);
-
-        // Sample for K-Means training
-        Random rng = new Random(42L);
-        float[][] trainSample = new float[TRAIN_SIZE][];
-        int[] perm = new int[base.length];
-        for (int i = 0; i < perm.length; i++) perm[i] = i;
-        for (int i = 0; i < TRAIN_SIZE; i++) {
-            int j = i + rng.nextInt(perm.length - i);
-            int tmp = perm[i]; perm[i] = perm[j]; perm[j] = tmp;
-            trainSample[i] = base[perm[i]];
-        }
-
-        SpectorIndex index = SpectorIndex.builder()
-                .dimensions(DIMS)
-                .nCentroids(N_CENTROIDS)
-                .nProbe(16)              // will be overridden per run
-                .shardThreshold(20_000)
-                .oversamplingFactor(3)
-                .similarityFunction(SimilarityFunction.EUCLIDEAN)  // SIFT uses L2
-                .hnswParams(new HnswParams(16, 128, 64))
-                .build();
-
-        long t0 = System.nanoTime();
-        index.train(trainSample);
-        System.out.printf("  K-Means training: %.1f sec%n", (System.nanoTime() - t0) / 1e9);
-
-        t0 = System.nanoTime();
-        for (int i = 0; i < base.length; i++) {
-            index.add("sift-" + i, i, base[i]);
-            if (i > 0 && i % 100_000 == 0) {
-                System.out.printf("  Indexed %d / %d (%.0f vec/sec)%n",
-                        i, base.length, i / ((System.nanoTime() - t0) / 1e9));
-            }
-        }
-        double ingestSec = (System.nanoTime() - t0) / 1e9;
-        System.out.printf("  Ingest: %.1f sec → %.0f vec/sec%n",
-                ingestSec, base.length / ingestSec);
-
-        // ── Also build exact HNSW for ground-truth comparison ─────────────────
-        // Note: for 1M vectors, exact HNSW requires ~4GB RAM — skip if unavailable
-        // and use the provided ground-truth file instead.
-
-        // ── Recall@10 vs QPS sweep over nProbe values ────────────────────────
-        System.out.println("\n─────────────────────────────────────────────────────────");
-        System.out.printf("%-10s %-15s %-15s %-15s%n", "nProbe", "Recall@10", "QPS", "Latency(ms)");
-        System.out.println("─────────────────────────────────────────────────────────");
-
-        int[] nProbeValues = {1, 2, 4, 8, 16, 32};
-        for (int nProbe : nProbeValues) {
-            // Rebuild with this nProbe (config is immutable after build, so reconstruct)
-            SpectorIndex probeIndex = SpectorIndex.builder()
-                    .dimensions(DIMS)
-                    .nCentroids(N_CENTROIDS)
-                    .nProbe(nProbe)
-                    .shardThreshold(20_000)
-                    .oversamplingFactor(3)
-                    .similarityFunction(SimilarityFunction.EUCLIDEAN)
-                    .hnswParams(new HnswParams(16, 128, 64))
-                    .build();
-            probeIndex.train(trainSample);
-            for (int i = 0; i < base.length; i++) {
-                probeIndex.add("sift-" + i, i, base[i]);
-            }
-
-            // Warmup
-            for (float[] q : queries) probeIndex.search(q, K);
-
-            // Measure recall + QPS
-            int totalHits = 0;
-            long searchStart = System.nanoTime();
-            for (int q = 0; q < queries.length; q++) {
-                ScoredResult[] results = probeIndex.search(queries[q], K);
-                Set<Integer> gtSet = new HashSet<>();
-                for (int idx : gt[q]) gtSet.add(idx);
-                for (ScoredResult r : results) {
-                    if (gtSet.contains(r.index())) totalHits++;
-                }
-            }
-            double elapsed = (System.nanoTime() - searchStart) / 1e9;
-            double recall   = (double) totalHits / ((double) queries.length * K);
-            double qps      = queries.length / elapsed;
-            double latencyMs = elapsed * 1000.0 / queries.length;
-
-            System.out.printf("%-10d %-15.4f %-15.0f %-15.3f%n",
-                    nProbe, recall, qps, latencyMs);
-
-            probeIndex.close();
-        }
-
-        System.out.println("─────────────────────────────────────────────────────────");
-        index.close();
-    }
-
-    // ── .fvecs / .ivecs file readers ─────────────────────────────────────────
-
-    /**
-     * Reads a .fvecs file (float vectors).
-     * Format: [int32 dim][float32 × dim] repeated N times.
-     */
-    static float[][] readFvecs(Path path) throws IOException {
-        try (FileChannel ch = FileChannel.open(path, StandardOpenOption.READ)) {
-            ByteBuffer buf = ch.map(FileChannel.MapMode.READ_ONLY, 0, ch.size())
-                    .order(ByteOrder.LITTLE_ENDIAN);
-            int dim = buf.getInt();
-            int recordSize = 4 + dim * 4;
-            int n = (int) (ch.size() / recordSize);
-            float[][] result = new float[n][dim];
-            buf.rewind();
-            for (int i = 0; i < n; i++) {
-                buf.getInt();  // skip dim field (same for all)
-                buf.asFloatBuffer().get(result[i]);
-                buf.position(buf.position() + dim * 4);
-            }
-            return result;
-        }
-    }
-
-    /**
-     * Reads a .ivecs file (int vectors).
-     * Format: [int32 dim][int32 × dim] repeated N times.
-     */
-    static int[][] readIvecs(Path path) throws IOException {
-        try (FileChannel ch = FileChannel.open(path, StandardOpenOption.READ)) {
-            ByteBuffer buf = ch.map(FileChannel.MapMode.READ_ONLY, 0, ch.size())
-                    .order(ByteOrder.LITTLE_ENDIAN);
-            int dim = buf.getInt();
-            int recordSize = 4 + dim * 4;
-            int n = (int) (ch.size() / recordSize);
-            int[][] result = new int[n][dim];
-            buf.rewind();
-            for (int i = 0; i < n; i++) {
-                buf.getInt();
-                buf.asIntBuffer().get(result[i]);
-                buf.position(buf.position() + dim * 4);
-            }
-            return result;
-        }
-    }
-}
diff --git a/spector-bench/src/main/java/com/spectrayan/spector/bench/SimdKernelBenchmark.java b/spector-bench/src/main/java/com/spectrayan/spector/bench/SimdKernelBenchmark.java
index ec1263b..bff7ad8 100644
--- a/spector-bench/src/main/java/com/spectrayan/spector/bench/SimdKernelBenchmark.java
+++ b/spector-bench/src/main/java/com/spectrayan/spector/bench/SimdKernelBenchmark.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.bench;
 
 import java.util.Random;
@@ -31,7 +16,9 @@
 import org.openjdk.jmh.annotations.Warmup;
 import org.openjdk.jmh.infra.Blackhole;
 
-import com.spectrayan.spector.core.similarity.SimilarityFunction;
+import com.spectrayan.spector.core.CosineSimilarity;
+import com.spectrayan.spector.core.DotProduct;
+import com.spectrayan.spector.core.EuclideanDistance;
 
 /**
  * JMH benchmarks for SIMD similarity kernels.
@@ -70,16 +57,21 @@ public void setup() {
 
     @Benchmark
     public void dotProduct(Blackhole bh) {
-        bh.consume(SimilarityFunction.DOT_PRODUCT.compute(vectorA, vectorB));
+        bh.consume(DotProduct.compute(vectorA, vectorB));
     }
 
     @Benchmark
     public void cosineSimilarity(Blackhole bh) {
-        bh.consume(SimilarityFunction.COSINE.compute(vectorA, vectorB));
+        bh.consume(CosineSimilarity.compute(vectorA, vectorB));
     }
 
     @Benchmark
     public void euclideanDistanceSquared(Blackhole bh) {
-        bh.consume(SimilarityFunction.EUCLIDEAN.compute(vectorA, vectorB));
+        bh.consume(EuclideanDistance.computeSquared(vectorA, vectorB));
+    }
+
+    @Benchmark
+    public void euclideanDistance(Blackhole bh) {
+        bh.consume(EuclideanDistance.compute(vectorA, vectorB));
     }
 }
diff --git a/spector-bench/src/main/java/com/spectrayan/spector/bench/SpectorIndexBenchmark.java b/spector-bench/src/main/java/com/spectrayan/spector/bench/SpectorIndexBenchmark.java
deleted file mode 100644
index 01fb92d..0000000
--- a/spector-bench/src/main/java/com/spectrayan/spector/bench/SpectorIndexBenchmark.java
+++ /dev/null
@@ -1,146 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.bench;
-
-import com.spectrayan.spector.core.similarity.SimilarityFunction;
-import com.spectrayan.spector.config.HnswParams;
-import com.spectrayan.spector.index.ScoredResult;
-import com.spectrayan.spector.index.spectrum.SpectorIndex;
-
-import org.openjdk.jmh.annotations.*;
-import org.openjdk.jmh.infra.Blackhole;
-
-import java.util.Random;
-import java.util.concurrent.TimeUnit;
-
-/**
- * JMH benchmarks for the complete {@link SpectorIndex} search path.
- *
- * <p>Measures end-to-end search latency and throughput at various {@code nProbe} values,
- * dataset sizes, and dimensionalities. This is the primary benchmark for evaluating
- * the IVF + adaptive-shard + SVASQ pipeline against real workloads.</p>
- *
- * <h3>Index configuration</h3>
- * <ul>
- *   <li>Training: K-Means on a 10K vector sample</li>
- *   <li>Shard mode: depends on {@code shardSize} — flat or HNSW</li>
- *   <li>SVASQ: per-shard pre-calibration on all residuals at promotion</li>
- * </ul>
- *
- * <p>Run via:</p>
- * <pre>
- *   java -jar spector-bench/target/benchmarks.jar SpectorIndexBenchmark
- * </pre>
- */
-@BenchmarkMode({Mode.Throughput, Mode.AverageTime})
-@OutputTimeUnit(TimeUnit.MILLISECONDS)
-@State(Scope.Benchmark)
-@Warmup(iterations = 3, time = 3)
-@Measurement(iterations = 5, time = 5)
-@Fork(value = 1, jvmArgsAppend = {
-        "--add-modules", "jdk.incubator.vector",
-        "--enable-native-access=ALL-UNNAMED",
-        "-Xmx4g", "-Xms2g",
-        "-XX:+UseZGC"
-})
-public class SpectorIndexBenchmark {
-
-    @Param({"4", "8", "16", "32"})
-    int nProbe;
-
-    @Param({"128", "384"})
-    int dims;
-
-    /**
-     * Total vectors indexed. Set high enough to ensure at least one shard promotes to HNSW.
-     * With 32 centroids and 50K vectors, avg shard = 1562 (flat); at 200K avg shard = 6250 (flat).
-     * Use 500K with 32 centroids to push shards to ~15K (approaching threshold).
-     */
-    @Param({"50000", "200000"})
-    int totalVectors;
-
-    private SpectorIndex index;
-    private float[] queryVector;
-
-    @Setup(Level.Trial)
-    public void setup() {
-        Random rng = new Random(42L);
-        int nCentroids = 32;
-
-        index = SpectorIndex.builder()
-                .dimensions(dims)
-                .nCentroids(nCentroids)
-                .nProbe(nProbe)
-                .shardThreshold(20_000)
-                .oversamplingFactor(3)
-                .similarityFunction(SimilarityFunction.COSINE)
-                .hnswParams(new HnswParams(16, 128, 64))
-                .build();
-
-        // Train on a sample
-        int trainSize = Math.min(10_000, totalVectors);
-        float[][] trainVectors = new float[trainSize][dims];
-        for (int i = 0; i < trainSize; i++) trainVectors[i] = gaussianUnit(rng, dims);
-        index.train(trainVectors);
-
-        // Index all vectors
-        for (int i = 0; i < totalVectors; i++) {
-            index.add("doc-" + i, i, gaussianUnit(rng, dims));
-        }
-
-        // Fixed query vector
-        queryVector = gaussianUnit(new Random(999L), dims);
-    }
-
-    @TearDown(Level.Trial)
-    public void tearDown() {
-        index.close();
-    }
-
-    // ── Search benchmarks ─────────────────────────────────────────────────────
-
-    /** Search for top-10 — typical recall@10 workload. */
-    @Benchmark
-    public void search_top10(Blackhole bh) {
-        bh.consume(index.search(queryVector, 10));
-    }
-
-    /** Search for top-50 — used for re-ranking pipelines. */
-    @Benchmark
-    public void search_top50(Blackhole bh) {
-        bh.consume(index.search(queryVector, 50));
-    }
-
-    /** Search for top-100 — retrieval-augmented generation (RAG) use case. */
-    @Benchmark
-    public void search_top100(Blackhole bh) {
-        bh.consume(index.search(queryVector, 100));
-    }
-
-    // ── Helpers ──────────────────────────────────────────────────────────────
-
-    private static float[] gaussianUnit(Random rng, int dims) {
-        float[] v = new float[dims];
-        double norm = 0;
-        for (int i = 0; i < dims; i++) {
-            v[i] = (float) rng.nextGaussian();
-            norm += (double) v[i] * v[i];
-        }
-        float scale = (float) (1.0 / Math.sqrt(norm));
-        for (int i = 0; i < dims; i++) v[i] *= scale;
-        return v;
-    }
-}
diff --git a/spector-bench/src/main/java/com/spectrayan/spector/bench/SpectorIndexLargeScaleBench.java b/spector-bench/src/main/java/com/spectrayan/spector/bench/SpectorIndexLargeScaleBench.java
deleted file mode 100644
index dc72cb5..0000000
--- a/spector-bench/src/main/java/com/spectrayan/spector/bench/SpectorIndexLargeScaleBench.java
+++ /dev/null
@@ -1,216 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.bench;
-
-import com.spectrayan.spector.core.similarity.SimilarityFunction;
-import com.spectrayan.spector.config.HnswParams;
-import com.spectrayan.spector.index.ScoredResult;
-import com.spectrayan.spector.index.spectrum.SpectorIndex;
-
-import java.util.Arrays;
-import java.util.Random;
-
-/**
- * Large-scale benchmark for {@link SpectorIndex} (IVF-HNSW-SVASQ) at 500K–1M vectors.
- *
- * <p>Tests the hypothesis that SpectorIndex overtakes plain HNSW at large scale
- * by measuring ingestion speed, search latency, throughput, and recall@10.</p>
- *
- * <p>Run: {@code java --add-modules jdk.incubator.vector -Xmx12g -cp ... SpectorIndexLargeScaleBench}</p>
- */
-public class SpectorIndexLargeScaleBench {
-
-    private static final int WARMUP = 100;
-    private static final int MEASURE = 500;
-    private static final int N_QUERIES = 50;
-
-    public static void main(String[] args) {
-        System.out.println("╔══════════════════════════════════════════════════════════╗");
-        System.out.println("║   SPECTOR INDEX — LARGE SCALE BENCHMARK (500K–1M)       ║");
-        System.out.println("╚══════════════════════════════════════════════════════════╝");
-        System.out.printf("  CPUs: %d  |  Max Heap: %d MB%n",
-                Runtime.getRuntime().availableProcessors(),
-                Runtime.getRuntime().maxMemory() / (1024 * 1024));
-        System.out.println();
-
-        // 500K with 128 centroids
-        runForSize(500_000, 128, 128, new int[]{8, 16, 32, 64});
-
-        // 1M with 256 centroids
-        runForSize(1_000_000, 128, 256, new int[]{8, 16, 32, 64, 128});
-
-        System.out.println("═══════════════════════════════════════════════════════════");
-    }
-
-    private static void runForSize(int datasetSize, int dims, int nCentroids, int[] nProbes) {
-        System.out.printf("▶ Dataset: %,d vectors, %d dims, %d centroids%n", datasetSize, dims, nCentroids);
-        long memBefore = usedMemoryMB();
-
-        Random rng = new Random(42L);
-
-        // Generate all vectors upfront
-        System.out.printf("  Generating %,d vectors...%n", datasetSize);
-        float[][] allVectors = new float[datasetSize][];
-        for (int i = 0; i < datasetSize; i++) {
-            allVectors[i] = gaussianUnit(rng, dims);
-        }
-        long memAfterVecs = usedMemoryMB();
-        System.out.printf("  Vector memory: +%d MB%n", memAfterVecs - memBefore);
-
-        // Train sample
-        int trainSize = Math.min(50_000, datasetSize);
-        float[][] trainVectors = new float[trainSize][];
-        System.arraycopy(allVectors, 0, trainVectors, 0, trainSize);
-
-        // Prepare queries
-        Random qrng = new Random(999L);
-        float[][] queries = new float[N_QUERIES][dims];
-        for (int q = 0; q < N_QUERIES; q++) queries[q] = gaussianUnit(qrng, dims);
-
-        // Compute ground truth via brute-force
-        System.out.printf("  Computing ground truth (%d queries × %,d vectors)...%n", N_QUERIES, datasetSize);
-        long gtStart = System.nanoTime();
-        int[][] groundTruth = computeGroundTruth(allVectors, queries, 10);
-        long gtMs = (System.nanoTime() - gtStart) / 1_000_000;
-        System.out.printf("  Ground truth computed in %,dms%n", gtMs);
-
-        // Build and benchmark each nProbe
-        System.out.println();
-        System.out.printf("  %-8s  %-12s  %-12s  %-12s  %-10s  %-10s  %-12s%n",
-                "nProbe", "avg (ms)", "p50 (ms)", "p99 (ms)", "QPS", "recall@10", "ingest (ms)");
-        System.out.println("  " + "-".repeat(84));
-
-        for (int nProbe : nProbes) {
-            // Build index
-            SpectorIndex probeIndex = SpectorIndex.builder()
-                    .dimensions(dims)
-                    .nCentroids(nCentroids)
-                    .nProbe(nProbe)
-                    .shardThreshold(20_000)
-                    .oversamplingFactor(4)
-                    .similarityFunction(SimilarityFunction.COSINE)
-                    .hnswParams(new HnswParams(16, 128, 64))
-                    .build();
-
-            // Train
-            long t0 = System.nanoTime();
-            probeIndex.train(trainVectors);
-            long trainMs = (System.nanoTime() - t0) / 1_000_000;
-
-            // Ingest
-            t0 = System.nanoTime();
-            for (int i = 0; i < datasetSize; i++) {
-                probeIndex.add("doc-" + i, i, allVectors[i]);
-            }
-            long ingestMs = (System.nanoTime() - t0) / 1_000_000;
-
-            // Warmup
-            for (int w = 0; w < WARMUP; w++) {
-                probeIndex.search(queries[w % N_QUERIES], 10);
-            }
-
-            // Measure
-            long[] nanos = new long[MEASURE];
-            ScoredResult[][] results = new ScoredResult[N_QUERIES][];
-            for (int m = 0; m < MEASURE; m++) {
-                int q = m % N_QUERIES;
-                long start = System.nanoTime();
-                results[q] = probeIndex.search(queries[q], 10);
-                nanos[m] = System.nanoTime() - start;
-            }
-
-            // Compute recall
-            double recall = computeRecall(results, groundTruth, N_QUERIES);
-
-            // Stats
-            Arrays.sort(nanos);
-            double avg = Arrays.stream(nanos).average().orElse(0) / 1e6;
-            double p50 = nanos[MEASURE / 2] / 1e6;
-            double p99 = nanos[(int) (MEASURE * 0.99)] / 1e6;
-            double qps = 1e9 / (Arrays.stream(nanos).average().orElse(1));
-
-            System.out.printf("  %-8d  %-12.3f  %-12.3f  %-12.3f  %-10.0f  %-10.4f  %-12d%n",
-                    nProbe, avg, p50, p99, qps, recall, ingestMs);
-
-            probeIndex.close();
-        }
-
-        long memAfterAll = usedMemoryMB();
-        System.out.printf("%n  Total memory used: +%d MB (vectors: +%d MB)%n", memAfterAll - memBefore, memAfterVecs - memBefore);
-        System.out.println();
-    }
-
-    private static int[][] computeGroundTruth(float[][] data, float[][] queries, int k) {
-        int[][] truth = new int[queries.length][k];
-        for (int q = 0; q < queries.length; q++) {
-            // Use partial sort via min-heap for efficiency at large scale
-            float[] sims = new float[data.length];
-            for (int i = 0; i < data.length; i++) {
-                sims[i] = cosine(queries[q], data[i]);
-            }
-            // Find top-k via partial sort
-            Integer[] indices = new Integer[data.length];
-            for (int i = 0; i < data.length; i++) indices[i] = i;
-            // Partial sort: only need top-k
-            Arrays.sort(indices, (a, b) -> Float.compare(sims[b], sims[a]));
-            for (int i = 0; i < k; i++) truth[q][i] = indices[i];
-        }
-        return truth;
-    }
-
-    private static double computeRecall(ScoredResult[][] results,
-                                         int[][] groundTruth, int nQueries) {
-        int hits = 0;
-        int total = 0;
-        for (int q = 0; q < nQueries; q++) {
-            if (results[q] == null) continue;
-            var truthSet = new java.util.HashSet<Integer>();
-            for (int idx : groundTruth[q]) truthSet.add(idx);
-            for (ScoredResult r : results[q]) {
-                if (truthSet.contains(r.index())) hits++;
-            }
-            total += groundTruth[q].length;
-        }
-        return total > 0 ? (double) hits / total : 0;
-    }
-
-    private static float cosine(float[] a, float[] b) {
-        float dot = 0, normA = 0, normB = 0;
-        for (int i = 0; i < a.length; i++) {
-            dot += a[i] * b[i];
-            normA += a[i] * a[i];
-            normB += b[i] * b[i];
-        }
-        return (float) (dot / (Math.sqrt(normA) * Math.sqrt(normB)));
-    }
-
-    private static float[] gaussianUnit(Random rng, int dims) {
-        float[] v = new float[dims];
-        double norm = 0;
-        for (int i = 0; i < dims; i++) {
-            v[i] = (float) rng.nextGaussian();
-            norm += (double) v[i] * v[i];
-        }
-        float scale = (float) (1.0 / Math.sqrt(norm));
-        for (int i = 0; i < dims; i++) v[i] *= scale;
-        return v;
-    }
-
-    private static long usedMemoryMB() {
-        Runtime.getRuntime().gc();
-        return (Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory()) / (1024 * 1024);
-    }
-}
diff --git a/spector-bench/src/main/java/com/spectrayan/spector/bench/SpectorIndexPromotionBench.java b/spector-bench/src/main/java/com/spectrayan/spector/bench/SpectorIndexPromotionBench.java
deleted file mode 100644
index d2a38e9..0000000
--- a/spector-bench/src/main/java/com/spectrayan/spector/bench/SpectorIndexPromotionBench.java
+++ /dev/null
@@ -1,229 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.bench;
-
-import com.spectrayan.spector.core.similarity.SimilarityFunction;
-import com.spectrayan.spector.config.HnswParams;
-import com.spectrayan.spector.index.ScoredResult;
-import com.spectrayan.spector.index.spectrum.SpectorIndex;
-
-import java.util.Arrays;
-import java.util.Random;
-
-/**
- * Benchmark to evaluate SpectorIndex performance before and after HNSW shard promotion.
- *
- * <p>Compares Flat-mode shards (exhaustive SIMD scans over float32 residuals)
- * against Promoted-HNSW shards (SVASQ-quantized local HNSW search) at 100K scale.</p>
- *
- * <p>Run: {@code java --add-modules jdk.incubator.vector -Xmx12g -cp ... SpectorIndexPromotionBench}</p>
- */
-public class SpectorIndexPromotionBench {
-
-    private static final int WARMUP = 100;
-    private static final int MEASURE = 500;
-    private static final int DATASET_SIZE = 100_000;
-    private static final int DIMENSIONS = 128;
-    private static final int N_CENTROIDS = 32;
-    private static final int N_QUERIES = 100;
-
-    public static void main(String[] args) {
-        System.out.println("╔══════════════════════════════════════════════════════════╗");
-        System.out.println("║    SPECTOR INDEX — SHARD PROMOTION BENCHMARK (100K)      ║");
-        System.out.println("╚══════════════════════════════════════════════════════════╝");
-        System.out.printf("  CPUs: %d  |  Max Heap: %d MB%n",
-                Runtime.getRuntime().availableProcessors(),
-                Runtime.getRuntime().maxMemory() / (1024 * 1024));
-        System.out.println();
-
-        // 1. Generate dataset
-        System.out.printf("Generating %,d random %d-dim vectors...%n", DATASET_SIZE, DIMENSIONS);
-        Random rng = new Random(42L);
-        float[][] dataset = new float[DATASET_SIZE][DIMENSIONS];
-        for (int i = 0; i < DATASET_SIZE; i++) {
-            dataset[i] = gaussianUnit(rng, DIMENSIONS);
-        }
-
-        // 2. Prepare queries and ground truth (exact L2 top-10)
-        System.out.printf("Generating %d query vectors and computing ground truth...%n", N_QUERIES);
-        Random qrng = new Random(999L);
-        float[][] queries = new float[N_QUERIES][DIMENSIONS];
-        for (int q = 0; q < N_QUERIES; q++) {
-            queries[q] = gaussianUnit(qrng, DIMENSIONS);
-        }
-        int[][] groundTruth = computeGroundTruth(dataset, queries, 10);
-
-        System.out.println("\n═══════════════════════════════════════════════════════════");
-        System.out.println("1. BENCHMARKING: FLAT SHARD MODE (No Promotion, shardThreshold=100K)");
-        System.out.println("═══════════════════════════════════════════════════════════");
-        runBenchmark(dataset, queries, groundTruth, 100_000);
-
-        System.out.println("\n═══════════════════════════════════════════════════════════");
-        System.out.println("2. BENCHMARKING: PROMOTED HNSW SHARD MODE (shardThreshold=1,000)");
-        System.out.println("═══════════════════════════════════════════════════════════");
-        runBenchmark(dataset, queries, groundTruth, 1_000);
-
-        System.out.println("═══════════════════════════════════════════════════════════");
-    }
-
-    private static void runBenchmark(float[][] dataset, float[][] queries, int[][] groundTruth, int shardThreshold) {
-        long memBefore = usedMemoryMB();
-
-        // 1. Build index configuration
-        SpectorIndex index = SpectorIndex.builder()
-                .dimensions(DIMENSIONS)
-                .nCentroids(N_CENTROIDS)
-                .nProbe(8) // default
-                .shardThreshold(shardThreshold)
-                .oversamplingFactor(3)
-                .similarityFunction(SimilarityFunction.COSINE)
-                .hnswParams(new HnswParams(16, 128, 64))
-                .build();
-
-        // 2. Train (using 10K sample)
-        int trainSize = 10_000;
-        float[][] trainVecs = Arrays.copyOf(dataset, trainSize);
-        long t0 = System.nanoTime();
-        index.train(trainVecs);
-        long trainMs = (System.nanoTime() - t0) / 1_000_000;
-
-        // 3. Ingest
-        t0 = System.nanoTime();
-        for (int i = 0; i < DATASET_SIZE; i++) {
-            index.add("doc-" + i, i, dataset[i]);
-        }
-        long ingestMs = (System.nanoTime() - t0) / 1_000_000;
-        long memAfterIngest = usedMemoryMB();
-        long memAdded = memAfterIngest - memBefore;
-
-        System.out.printf("  Ingestion: %dms (%.0f docs/s) | Memory added: %d MB%n",
-                ingestMs, DATASET_SIZE / (ingestMs / 1000.0), memAdded);
-        System.out.println();
-
-        // 4. Test different nProbe configurations
-        int[] nProbes = {4, 8, 16, 32};
-        System.out.printf("  %-8s  %-12s  %-12s  %-12s  %-10s  %-10s%n",
-                "nProbe", "avg (ms)", "p50 (ms)", "p99 (ms)", "QPS", "recall@10");
-        System.out.println("  " + "-".repeat(72));
-
-        for (int nProbe : nProbes) {
-            // Reconfigure nProbe
-            SpectorIndex probeIndex = SpectorIndex.builder()
-                    .dimensions(DIMENSIONS)
-                    .nCentroids(N_CENTROIDS)
-                    .nProbe(nProbe)
-                    .shardThreshold(shardThreshold)
-                    .oversamplingFactor(3)
-                    .similarityFunction(SimilarityFunction.COSINE)
-                    .hnswParams(new HnswParams(16, 128, 64))
-                    .build();
-
-            probeIndex.train(trainVecs);
-            for (int i = 0; i < DATASET_SIZE; i++) {
-                probeIndex.add("doc-" + i, i, dataset[i]);
-            }
-
-            // Warmup
-            for (int w = 0; w < WARMUP; w++) {
-                probeIndex.search(queries[w % N_QUERIES], 10);
-            }
-
-            // Measure
-            long[] nanos = new long[MEASURE];
-            ScoredResult[][] results = new ScoredResult[N_QUERIES][];
-            for (int m = 0; m < MEASURE; m++) {
-                int q = m % N_QUERIES;
-                long start = System.nanoTime();
-                results[q] = probeIndex.search(queries[q], 10);
-                nanos[m] = System.nanoTime() - start;
-            }
-
-            // Compute stats
-            double recall = computeRecall(results, groundTruth, N_QUERIES);
-            Arrays.sort(nanos);
-            double avg = Arrays.stream(nanos).average().orElse(0) / 1e6;
-            double p50 = nanos[MEASURE / 2] / 1e6;
-            double p99 = nanos[(int) (MEASURE * 0.99)] / 1e6;
-            double qps = 1e9 / (Arrays.stream(nanos).average().orElse(1));
-
-            System.out.printf("  %-8d  %-12.3f  %-12.3f  %-12.3f  %-10.0f  %-10.4f%n",
-                    nProbe, avg, p50, p99, qps, recall);
-
-            probeIndex.close();
-        }
-
-        index.close();
-        System.out.println();
-    }
-
-    private static int[][] computeGroundTruth(float[][] data, float[][] queries, int k) {
-        int[][] truth = new int[queries.length][k];
-        for (int q = 0; q < queries.length; q++) {
-            float[] dists = new float[data.length];
-            for (int i = 0; i < data.length; i++) {
-                dists[i] = l2Squared(queries[q], data[i]);
-            }
-            Integer[] indices = new Integer[data.length];
-            for (int i = 0; i < data.length; i++) indices[i] = i;
-            Arrays.sort(indices, (a, b) -> Float.compare(dists[a], dists[b]));
-            for (int i = 0; i < k; i++) truth[q][i] = indices[i];
-        }
-        return truth;
-    }
-
-    private static double computeRecall(ScoredResult[][] results, int[][] groundTruth, int nQueries) {
-        int hits = 0;
-        int total = 0;
-        for (int q = 0; q < nQueries; q++) {
-            if (results[q] == null) continue;
-            var truthSet = new java.util.HashSet<Integer>();
-            for (int idx : groundTruth[q]) truthSet.add(idx);
-            for (ScoredResult r : results[q]) {
-                if (truthSet.contains(r.index())) hits++;
-            }
-            total += groundTruth[q].length;
-        }
-        return total > 0 ? (double) hits / total : 0;
-    }
-
-    private static float l2Squared(float[] a, float[] b) {
-        float sum = 0;
-        for (int i = 0; i < a.length; i++) {
-            float d = a[i] - b[i];
-            sum += d * d;
-        }
-        return sum;
-    }
-
-    private static float[] gaussianUnit(Random rng, int dims) {
-        float[] v = new float[dims];
-        double norm = 0;
-        for (int i = 0; i < dims; i++) {
-            v[i] = (float) rng.nextGaussian();
-            norm += (double) v[i] * v[i];
-        }
-        float scale = (float) (1.0 / Math.sqrt(norm));
-        for (int i = 0; i < dims; i++) v[i] *= scale;
-        return v;
-    }
-
-    private static long usedMemoryMB() {
-        System.gc();
-        try { Thread.sleep(100); } catch (Exception ignored) {}
-        System.gc();
-        return (Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory()) / (1024 * 1024);
-    }
-}
diff --git a/spector-bench/src/main/java/com/spectrayan/spector/bench/SpectorIndexQuickBench.java b/spector-bench/src/main/java/com/spectrayan/spector/bench/SpectorIndexQuickBench.java
deleted file mode 100644
index a009c3f..0000000
--- a/spector-bench/src/main/java/com/spectrayan/spector/bench/SpectorIndexQuickBench.java
+++ /dev/null
@@ -1,214 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.bench;
-
-import com.spectrayan.spector.core.similarity.SimilarityFunction;
-import com.spectrayan.spector.config.HnswParams;
-import com.spectrayan.spector.index.ScoredResult;
-import com.spectrayan.spector.index.spectrum.SpectorIndex;
-
-import java.util.Arrays;
-import java.util.Random;
-
-/**
- * Quick direct-measurement benchmark for {@link SpectorIndex} (IVF-HNSW-SVASQ).
- *
- * <p>Measures search latency, throughput, and recall at various nProbe and dataset
- * sizes without requiring JMH annotation processing. Outputs a console table
- * for direct comparison with the documentation.</p>
- *
- * <p>Run: {@code java --add-modules jdk.incubator.vector -cp ... SpectorIndexQuickBench}</p>
- */
-public class SpectorIndexQuickBench {
-
-    private static final int WARMUP = 100;
-    private static final int MEASURE = 500;
-
-    public static void main(String[] args) {
-        System.out.println("╔══════════════════════════════════════════════════════════╗");
-        System.out.println("║     SPECTOR INDEX (IVF-HNSW-SVASQ) QUICK BENCHMARK       ║");
-        System.out.println("╚══════════════════════════════════════════════════════════╝");
-        System.out.println();
-
-        int[] sizes = {10_000, 50_000, 100_000};
-        int[] nProbes = {4, 8, 16, 32};
-        int dims = 128;
-
-        for (int size : sizes) {
-            runForSize(size, dims, nProbes);
-        }
-
-        System.out.println("═══════════════════════════════════════════════════════════");
-    }
-
-    private static void runForSize(int datasetSize, int dims, int[] nProbes) {
-        System.out.printf("▶ Dataset: %,d vectors, %d dims, 32 centroids%n", datasetSize, dims);
-
-        Random rng = new Random(42L);
-        int nCentroids = 32;
-
-        // Build index with default nProbe (will override per-query later)
-        SpectorIndex index = SpectorIndex.builder()
-                .dimensions(dims)
-                .nCentroids(nCentroids)
-                .nProbe(8)
-                .shardThreshold(20_000)
-                .oversamplingFactor(3)
-                .similarityFunction(SimilarityFunction.COSINE)
-                .hnswParams(new HnswParams(16, 128, 64))
-                .build();
-
-        // Train
-        int trainSize = Math.min(10_000, datasetSize);
-        float[][] trainVectors = new float[trainSize][dims];
-        for (int i = 0; i < trainSize; i++) trainVectors[i] = gaussianUnit(rng, dims);
-
-        long t0 = System.nanoTime();
-        index.train(trainVectors);
-        long trainMs = (System.nanoTime() - t0) / 1_000_000;
-        System.out.printf("  Train: %dms (%d vectors)%n", trainMs, trainSize);
-
-        // Ingest
-        float[][] allVectors = new float[datasetSize][dims];
-        t0 = System.nanoTime();
-        for (int i = 0; i < datasetSize; i++) {
-            allVectors[i] = gaussianUnit(rng, dims);
-            index.add("doc-" + i, i, allVectors[i]);
-        }
-        long ingestMs = (System.nanoTime() - t0) / 1_000_000;
-        System.out.printf("  Ingest: %dms (%.0f docs/s)%n", ingestMs,
-                datasetSize / (ingestMs / 1000.0));
-
-        // Prepare queries + ground truth (brute-force top-10)
-        int nQueries = 100;
-        float[][] queries = new float[nQueries][dims];
-        Random qrng = new Random(999L);
-        for (int q = 0; q < nQueries; q++) queries[q] = gaussianUnit(qrng, dims);
-
-        // Compute exact top-10 via brute force L2 for recall measurement
-        // (SpectorIndex uses L2 internally for IVF residual search)
-        int[][] groundTruth = computeGroundTruth(allVectors, queries, 10);
-
-        System.out.println();
-        System.out.printf("  %-8s  %-12s  %-12s  %-12s  %-10s  %-10s%n",
-                "nProbe", "avg (ms)", "p50 (ms)", "p99 (ms)", "QPS", "recall@10");
-        System.out.println("  " + "-".repeat(72));
-
-        for (int nProbe : nProbes) {
-            // Rebuild with this nProbe
-            SpectorIndex probeIndex = SpectorIndex.builder()
-                    .dimensions(dims)
-                    .nCentroids(nCentroids)
-                    .nProbe(nProbe)
-                    .shardThreshold(20_000)
-                    .oversamplingFactor(3)
-                    .similarityFunction(SimilarityFunction.COSINE)
-                    .hnswParams(new HnswParams(16, 128, 64))
-                    .build();
-
-            probeIndex.train(trainVectors);
-            for (int i = 0; i < datasetSize; i++) {
-                probeIndex.add("doc-" + i, i, allVectors[i]);
-            }
-
-            // Warmup
-            for (int w = 0; w < WARMUP; w++) {
-                probeIndex.search(queries[w % nQueries], 10);
-            }
-
-            // Measure
-            long[] nanos = new long[MEASURE];
-            ScoredResult[][] results = new ScoredResult[nQueries][];
-            for (int m = 0; m < MEASURE; m++) {
-                int q = m % nQueries;
-                long start = System.nanoTime();
-                results[q] = probeIndex.search(queries[q], 10);
-                nanos[m] = System.nanoTime() - start;
-            }
-
-            // Compute recall
-            double recall = computeRecall(results, groundTruth, nQueries);
-
-            // Stats
-            Arrays.sort(nanos);
-            double avg = Arrays.stream(nanos).average().orElse(0) / 1e6;
-            double p50 = nanos[MEASURE / 2] / 1e6;
-            double p99 = nanos[(int) (MEASURE * 0.99)] / 1e6;
-            double qps = 1e9 / (Arrays.stream(nanos).average().orElse(1));
-
-            System.out.printf("  %-8d  %-12.3f  %-12.3f  %-12.3f  %-10.0f  %-10.4f%n",
-                    nProbe, avg, p50, p99, qps, recall);
-
-            probeIndex.close();
-        }
-
-        index.close();
-        System.out.println();
-    }
-
-    private static int[][] computeGroundTruth(float[][] data, float[][] queries, int k) {
-        int[][] truth = new int[queries.length][k];
-        for (int q = 0; q < queries.length; q++) {
-            float[] dists = new float[data.length];
-            for (int i = 0; i < data.length; i++) {
-                dists[i] = l2Squared(queries[q], data[i]);
-            }
-            // Find top-k indices by L2 distance (lowest = closest)
-            Integer[] indices = new Integer[data.length];
-            for (int i = 0; i < data.length; i++) indices[i] = i;
-            Arrays.sort(indices, (a, b) -> Float.compare(dists[a], dists[b]));
-            for (int i = 0; i < k; i++) truth[q][i] = indices[i];
-        }
-        return truth;
-    }
-
-    private static double computeRecall(ScoredResult[][] results,
-                                         int[][] groundTruth, int nQueries) {
-        int hits = 0;
-        int total = 0;
-        for (int q = 0; q < nQueries; q++) {
-            if (results[q] == null) continue;
-            var truthSet = new java.util.HashSet<Integer>();
-            for (int idx : groundTruth[q]) truthSet.add(idx);
-            for (ScoredResult r : results[q]) {
-                if (truthSet.contains(r.index())) hits++;
-            }
-            total += groundTruth[q].length;
-        }
-        return total > 0 ? (double) hits / total : 0;
-    }
-
-    private static float l2Squared(float[] a, float[] b) {
-        float sum = 0;
-        for (int i = 0; i < a.length; i++) {
-            float d = a[i] - b[i];
-            sum += d * d;
-        }
-        return sum;
-    }
-
-    private static float[] gaussianUnit(Random rng, int dims) {
-        float[] v = new float[dims];
-        double norm = 0;
-        for (int i = 0; i < dims; i++) {
-            v[i] = (float) rng.nextGaussian();
-            norm += (double) v[i] * v[i];
-        }
-        float scale = (float) (1.0 / Math.sqrt(norm));
-        for (int i = 0; i < dims; i++) v[i] *= scale;
-        return v;
-    }
-}
diff --git a/spector-bench/src/main/java/com/spectrayan/spector/bench/SpectorIngestBenchmark.java b/spector-bench/src/main/java/com/spectrayan/spector/bench/SpectorIngestBenchmark.java
deleted file mode 100644
index 281cbfe..0000000
--- a/spector-bench/src/main/java/com/spectrayan/spector/bench/SpectorIngestBenchmark.java
+++ /dev/null
@@ -1,180 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.bench;
-
-import com.spectrayan.spector.core.similarity.SimilarityFunction;
-import com.spectrayan.spector.config.HnswParams;
-import com.spectrayan.spector.index.spectrum.SpectorIndex;
-
-import org.openjdk.jmh.annotations.*;
-import org.openjdk.jmh.infra.Blackhole;
-
-import java.util.Random;
-import java.util.concurrent.TimeUnit;
-
-/**
- * JMH benchmarks for {@link SpectorIndex} ingest throughput.
- *
- * <p>Measures:</p>
- * <ul>
- *   <li><b>Training throughput</b> — K-Means iterations per second</li>
- *   <li><b>Add throughput</b> — vectors per millisecond during flat-scan accumulation</li>
- *   <li><b>Promotion cost</b> — shard promotion (SVASQ calibration + HNSW bulk-insert) latency</li>
- *   <li><b>Post-promotion add</b> — add() into live HNSW after shard has promoted</li>
- * </ul>
- *
- * <p>These benchmarks answer: "how long does it take to build a SpectorIndex from scratch?"
- * and "does per-shard SVASQ calibration add meaningful overhead at promotion time?"</p>
- *
- * <p>Run via:</p>
- * <pre>
- *   java -jar spector-bench/target/benchmarks.jar SpectorIngestBenchmark
- * </pre>
- */
-@BenchmarkMode({Mode.AverageTime})
-@OutputTimeUnit(TimeUnit.MILLISECONDS)
-@State(Scope.Benchmark)
-@Warmup(iterations = 2, time = 2)
-@Measurement(iterations = 5, time = 3)
-@Fork(value = 1, jvmArgsAppend = {
-        "--add-modules", "jdk.incubator.vector",
-        "--enable-native-access=ALL-UNNAMED",
-        "-Xmx4g", "-Xms2g",
-        "-XX:+UseZGC"
-})
-public class SpectorIngestBenchmark {
-
-    @Param({"128", "384"})
-    int dims;
-
-    /** Vectors to index. Controls whether shards promote (> shardThreshold/nCentroids). */
-    @Param({"10000", "100000"})
-    int totalVectors;
-
-    private float[][] trainVectors;
-    private float[][] indexVectors;
-    private SpectorIndex trainedIndex;  // pre-trained, used for add() benchmarks
-
-    @Setup(Level.Trial)
-    public void setup() {
-        Random rng = new Random(42L);
-        int trainSize = Math.min(5_000, totalVectors);
-
-        trainVectors = new float[trainSize][dims];
-        for (int i = 0; i < trainSize; i++) trainVectors[i] = gaussianUnit(rng, dims);
-
-        indexVectors = new float[totalVectors][dims];
-        for (int i = 0; i < totalVectors; i++) indexVectors[i] = gaussianUnit(rng, dims);
-
-        // Build a pre-trained index for the add() benchmarks
-        trainedIndex = SpectorIndex.builder()
-                .dimensions(dims)
-                .nCentroids(32)
-                .nProbe(16)
-                .shardThreshold(20_000)
-                .oversamplingFactor(3)
-                .similarityFunction(SimilarityFunction.COSINE)
-                .hnswParams(new HnswParams(16, 128, 64))
-                .build();
-        trainedIndex.train(trainVectors);
-    }
-
-    @TearDown(Level.Trial)
-    public void tearDown() {
-        if (trainedIndex != null) trainedIndex.close();
-    }
-
-    /**
-     * Full train + index cycle.
-     * Measures total time to build an index from scratch: K-Means + all add() calls.
-     */
-    @Benchmark
-    public void fullBuildCycle(Blackhole bh) {
-        SpectorIndex idx = SpectorIndex.builder()
-                .dimensions(dims)
-                .nCentroids(32)
-                .nProbe(16)
-                .shardThreshold(20_000)
-                .oversamplingFactor(3)
-                .similarityFunction(SimilarityFunction.COSINE)
-                .hnswParams(HnswParams.DEFAULT)
-                .build();
-        idx.train(trainVectors);
-        for (int i = 0; i < totalVectors; i++) {
-            idx.add("doc-" + i, i, indexVectors[i]);
-        }
-        bh.consume(idx);
-        idx.close();
-    }
-
-    /**
-     * Training only (K-Means++ on trainVectors).
-     * Isolates centroid learning cost from add() cost.
-     */
-    @Benchmark
-    public void trainOnly(Blackhole bh) {
-        SpectorIndex idx = SpectorIndex.builder()
-                .dimensions(dims)
-                .nCentroids(32)
-                .nProbe(16)
-                .shardThreshold(Integer.MAX_VALUE)  // never promote
-                .similarityFunction(SimilarityFunction.COSINE)
-                .hnswParams(HnswParams.DEFAULT)
-                .build();
-        idx.train(trainVectors);
-        bh.consume(idx);
-        idx.close();
-    }
-
-    /**
-     * Add-only throughput (training pre-done).
-     * Measures flat-mode accumulation speed — should be near-zero overhead
-     * since it's just an ArrayList.add().
-     */
-    @Benchmark
-    public void addOnly_flatMode(Blackhole bh) {
-        // Fresh index per iteration — @Level.Invocation would be ideal but has too much overhead
-        // Use a NEW trained index with a very high threshold (never promote)
-        SpectorIndex idx = SpectorIndex.builder()
-                .dimensions(dims)
-                .nCentroids(32)
-                .nProbe(16)
-                .shardThreshold(Integer.MAX_VALUE)
-                .similarityFunction(SimilarityFunction.COSINE)
-                .hnswParams(HnswParams.DEFAULT)
-                .build();
-        idx.train(trainVectors);
-        for (int i = 0; i < totalVectors; i++) {
-            idx.add("doc-" + i, i, indexVectors[i]);
-        }
-        bh.consume(idx);
-        idx.close();
-    }
-
-    // ── Helpers ──────────────────────────────────────────────────────────────
-
-    private static float[] gaussianUnit(Random rng, int dims) {
-        float[] v = new float[dims];
-        double norm = 0;
-        for (int i = 0; i < dims; i++) {
-            v[i] = (float) rng.nextGaussian();
-            norm += (double) v[i] * v[i];
-        }
-        float scale = (float) (1.0 / Math.sqrt(norm));
-        for (int i = 0; i < dims; i++) v[i] *= scale;
-        return v;
-    }
-}
diff --git a/spector-bench/src/main/java/com/spectrayan/spector/bench/SpectorRecallDiag.java b/spector-bench/src/main/java/com/spectrayan/spector/bench/SpectorRecallDiag.java
deleted file mode 100644
index 58778ce..0000000
--- a/spector-bench/src/main/java/com/spectrayan/spector/bench/SpectorRecallDiag.java
+++ /dev/null
@@ -1,144 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.bench;
-
-import com.spectrayan.spector.core.similarity.SimilarityFunction;
-import com.spectrayan.spector.config.HnswParams;
-import com.spectrayan.spector.index.ScoredResult;
-import com.spectrayan.spector.index.spectrum.SpectorIndex;
-
-import java.util.*;
-
-/**
- * Diagnostic: verifies recall@10 at nProbe=ALL (should be 1.0).
- */
-public class SpectorRecallDiag {
-
-    public static void main(String[] args) {
-        int dims = 128;
-        int N = 1000;  // small dataset for fast debugging
-        int nCentroids = 8;
-        int k = 10;
-        Random rng = new Random(42L);
-
-        // Generate vectors
-        float[][] vectors = new float[N][];
-        for (int i = 0; i < N; i++) vectors[i] = gaussianUnit(rng, dims);
-
-        // Build index with nProbe=ALL
-        SpectorIndex index = SpectorIndex.builder()
-                .dimensions(dims)
-                .nCentroids(nCentroids)
-                .nProbe(nCentroids)  // ALL centroids
-                .shardThreshold(20_000)
-                .oversamplingFactor(3)
-                .similarityFunction(SimilarityFunction.COSINE)
-                .hnswParams(new HnswParams(16, 128, 64))
-                .build();
-
-        float[][] train = Arrays.copyOf(vectors, Math.min(N, 500));
-        index.train(train);
-
-        for (int i = 0; i < N; i++) {
-            index.add("doc-" + i, i, vectors[i]);
-        }
-
-        // Queries
-        int nQ = 20;
-        Random qrng = new Random(999L);
-        float[][] queries = new float[nQ][];
-        for (int q = 0; q < nQ; q++) queries[q] = gaussianUnit(qrng, dims);
-
-        // Brute-force ground truth (L2²)
-        int totalHits = 0;
-        int totalExpected = 0;
-
-        for (int q = 0; q < nQ; q++) {
-            // Ground truth: sort all vectors by L2² to query
-            float[] dists = new float[N];
-            for (int i = 0; i < N; i++) {
-                float sum = 0;
-                for (int d = 0; d < dims; d++) {
-                    float diff = queries[q][d] - vectors[i][d];
-                    sum += diff * diff;
-                }
-                dists[i] = sum;
-            }
-            Integer[] sorted = new Integer[N];
-            for (int i = 0; i < N; i++) sorted[i] = i;
-            Arrays.sort(sorted, (a, b) -> Float.compare(dists[a], dists[b]));
-
-            Set<Integer> truthSet = new HashSet<>();
-            for (int i = 0; i < k; i++) truthSet.add(sorted[i]);
-
-            // SpectorIndex result
-            ScoredResult[] results = index.search(queries[q], k);
-
-            Set<Integer> resultSet = new HashSet<>();
-            for (ScoredResult r : results) resultSet.add(r.index());
-
-            int hits = 0;
-            for (int idx : truthSet) {
-                if (resultSet.contains(idx)) hits++;
-            }
-            totalHits += hits;
-            totalExpected += k;
-
-            if (hits < k) {
-                System.out.printf("Query %d: recall=%d/%d%n", q, hits, k);
-                System.out.printf("  Truth:  %s%n", truthSet);
-                System.out.printf("  Got:    %s%n", resultSet);
-
-                // Find which truth IDs are missing and why
-                for (int truthIdx : truthSet) {
-                    if (!resultSet.contains(truthIdx)) {
-                        float truthDist = dists[truthIdx];
-                        // Check what SpectorIndex scored this vector
-                        System.out.printf("  MISS doc-%d: bruteL2²=%.8f, bruteL2=%.8f%n",
-                                truthIdx, truthDist, Math.sqrt(truthDist));
-                    }
-                }
-
-                // Print SpectorIndex's result scores
-                System.out.printf("  SpectorIndex top-%d scores: ", k);
-                for (ScoredResult r : results) {
-                    System.out.printf("doc-%d(%.6f) ", r.index(), r.score());
-                }
-                System.out.println();
-
-                // Print worst accepted vs best rejected
-                float worstAccepted = results[results.length - 1].score();
-                System.out.printf("  Worst accepted L2=%.8f%n", worstAccepted);
-            }
-        }
-
-        double recall = (double) totalHits / totalExpected;
-        System.out.printf("%nOverall recall@%d = %.4f (%d/%d)%n", k, recall, totalHits, totalExpected);
-        index.close();
-    }
-
-    private static float[] gaussianUnit(Random rng, int dims) {
-        float[] v = new float[dims];
-        double norm = 0;
-        for (int i = 0; i < dims; i++) {
-            v[i] = (float) rng.nextGaussian();
-            norm += (double) v[i] * v[i];
-        }
-        float scale = (float) (1.0 / Math.sqrt(norm));
-        for (int i = 0; i < dims; i++) v[i] *= scale;
-        return v;
-    }
-}
diff --git a/spector-bench/src/main/java/com/spectrayan/spector/bench/SpectorResidualDiag.java b/spector-bench/src/main/java/com/spectrayan/spector/bench/SpectorResidualDiag.java
deleted file mode 100644
index 5b5f464..0000000
--- a/spector-bench/src/main/java/com/spectrayan/spector/bench/SpectorResidualDiag.java
+++ /dev/null
@@ -1,129 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.bench;
-
-import com.spectrayan.spector.core.cluster.KMeans;
-import com.spectrayan.spector.core.similarity.SimilarityFunction;
-import com.spectrayan.spector.config.HnswParams;
-import com.spectrayan.spector.index.ScoredResult;
-import com.spectrayan.spector.index.spectrum.SpectorIndex;
-
-import java.util.*;
-
-/**
- * Minimal diagnostic: verifies residual L2 = original L2.
- */
-public class SpectorResidualDiag {
-
-    public static void main(String[] args) {
-        int dims = 128;
-        int N = 100;
-        int nCentroids = 4;
-        Random rng = new Random(42L);
-
-        // Generate vectors
-        float[][] vectors = new float[N][];
-        for (int i = 0; i < N; i++) vectors[i] = gaussianUnit(rng, dims);
-
-        // Train KMeans
-        float[][] centroids = KMeans.train(vectors, nCentroids, 25, 42L);
-
-        // For each vector, verify residual identity
-        float[] query = gaussianUnit(new Random(999L), dims);
-        int qCentroid = KMeans.nearestCentroid(query, centroids);
-        System.out.printf("Query nearest centroid: %d%n%n", qCentroid);
-
-        // Check a few vectors
-        for (int i = 0; i < 10; i++) {
-            int xCentroid = KMeans.nearestCentroid(vectors[i], centroids);
-
-            // Original L2
-            float origL2sq = 0;
-            for (int d = 0; d < dims; d++) {
-                float diff = query[d] - vectors[i][d];
-                origL2sq += diff * diff;
-            }
-            float origL2 = (float) Math.sqrt(origL2sq);
-
-            // Residual L2 (using x's centroid)
-            float[] resQ = new float[dims];
-            float[] resX = new float[dims];
-            float[] cx = centroids[xCentroid];
-            for (int d = 0; d < dims; d++) {
-                resQ[d] = query[d] - cx[d];
-                resX[d] = vectors[i][d] - cx[d];
-            }
-            float resL2sq = 0;
-            for (int d = 0; d < dims; d++) {
-                float diff = resQ[d] - resX[d];
-                resL2sq += diff * diff;
-            }
-            float resL2 = (float) Math.sqrt(resL2sq);
-
-            // SIMD L2
-            float simdL2 = SimilarityFunction.EUCLIDEAN.compute(resQ, resX);
-
-            System.out.printf("Vec %d (centroid %d): origL2=%.8f  resL2=%.8f  simdL2=%.8f  match=%b%n",
-                    i, xCentroid, origL2, resL2, simdL2,
-                    Math.abs(origL2 - resL2) < 0.0001);
-        }
-
-        // Now test actual SpectorIndex search
-        System.out.println("\n--- SpectorIndex Search ---");
-        SpectorIndex index = SpectorIndex.builder()
-                .dimensions(dims)
-                .nCentroids(nCentroids)
-                .nProbe(nCentroids) // ALL
-                .shardThreshold(20_000)
-                .oversamplingFactor(10) // high oversampling
-                .similarityFunction(SimilarityFunction.COSINE)
-                .hnswParams(new HnswParams(16, 128, 64))
-                .build();
-
-        index.train(vectors);
-        for (int i = 0; i < N; i++) {
-            index.add("doc-" + i, i, vectors[i]);
-        }
-
-        ScoredResult[] results = index.search(query, 10);
-        System.out.println("Top-10 from SpectorIndex:");
-        for (ScoredResult r : results) {
-            int idx = r.index();
-            float origL2 = 0;
-            for (int d = 0; d < dims; d++) {
-                float diff = query[d] - vectors[idx][d];
-                origL2 += diff * diff;
-            }
-            origL2 = (float) Math.sqrt(origL2);
-            System.out.printf("  doc-%d: spectorScore=%.8f  origL2=%.8f  ratio=%.4f%n",
-                    idx, r.score(), origL2, origL2 / r.score());
-        }
-
-        index.close();
-    }
-
-    private static float[] gaussianUnit(Random rng, int dims) {
-        float[] v = new float[dims];
-        double norm = 0;
-        for (int i = 0; i < dims; i++) {
-            v[i] = (float) rng.nextGaussian();
-            norm += (double) v[i] * v[i];
-        }
-        float scale = (float) (1.0 / Math.sqrt(norm));
-        for (int i = 0; i < dims; i++) v[i] *= scale;
-        return v;
-    }
-}
diff --git a/spector-bench/src/main/java/com/spectrayan/spector/bench/SpectorTinyDiag.java b/spector-bench/src/main/java/com/spectrayan/spector/bench/SpectorTinyDiag.java
deleted file mode 100644
index 5532c7e..0000000
--- a/spector-bench/src/main/java/com/spectrayan/spector/bench/SpectorTinyDiag.java
+++ /dev/null
@@ -1,109 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.bench;
-
-import com.spectrayan.spector.core.cluster.KMeans;
-import com.spectrayan.spector.core.similarity.SimilarityFunction;
-import com.spectrayan.spector.config.HnswParams;
-import com.spectrayan.spector.index.ScoredResult;
-import com.spectrayan.spector.index.spectrum.SpectorIndex;
-
-import java.util.*;
-
-/**
- * Targeted diagnostic: 4 vectors, 2 dimensions, completely traceable.
- */
-public class SpectorTinyDiag {
-
-    public static void main(String[] args) {
-        int dims = 4;  // tiny for manual verification
-        int N = 8;
-        int nCentroids = 2;
-
-        // Manually defined vectors for full traceability
-        float[][] vectors = {
-            {1.0f, 0.0f, 0.0f, 0.0f},  // doc-0
-            {0.9f, 0.1f, 0.0f, 0.0f},  // doc-1
-            {0.0f, 1.0f, 0.0f, 0.0f},  // doc-2
-            {0.0f, 0.9f, 0.1f, 0.0f},  // doc-3
-            {0.5f, 0.5f, 0.0f, 0.0f},  // doc-4
-            {-1.0f, 0.0f, 0.0f, 0.0f}, // doc-5
-            {0.0f, 0.0f, 1.0f, 0.0f},  // doc-6
-            {0.0f, 0.0f, 0.0f, 1.0f},  // doc-7
-        };
-
-        float[] query = {0.8f, 0.2f, 0.0f, 0.0f};
-
-        // Print brute-force L2 from query to each vector
-        System.out.println("=== Brute-Force L2 Distances ===");
-        for (int i = 0; i < N; i++) {
-            float l2sq = 0;
-            for (int d = 0; d < dims; d++) {
-                float diff = query[d] - vectors[i][d];
-                l2sq += diff * diff;
-            }
-            float l2 = (float) Math.sqrt(l2sq);
-            System.out.printf("  doc-%d: L2=%.6f  L2²=%.6f  vec=%s%n",
-                    i, l2, l2sq, Arrays.toString(vectors[i]));
-        }
-
-        // Build SpectorIndex
-        System.out.println("\n=== SpectorIndex ===");
-        SpectorIndex index = SpectorIndex.builder()
-                .dimensions(dims)
-                .nCentroids(nCentroids)
-                .nProbe(nCentroids) // ALL
-                .shardThreshold(20_000)
-                .oversamplingFactor(10)
-                .similarityFunction(SimilarityFunction.COSINE) // user chose cosine
-                .hnswParams(new HnswParams(16, 128, 64))
-                .build();
-
-        index.train(vectors);
-
-        // Show centroid assignments
-        float[][] centroids = KMeans.train(vectors, nCentroids, 25, 42L);
-        System.out.println("Centroids from separate KMeans:");
-        for (int c = 0; c < nCentroids; c++) {
-            System.out.printf("  c%d = %s%n", c, Arrays.toString(centroids[c]));
-        }
-
-        // Show shard sizes from index
-        for (int i = 0; i < N; i++) {
-            index.add("doc-" + i, i, vectors[i]);
-        }
-        int[] shardSizes = index.shardSizes();
-        System.out.println("Shard sizes: " + Arrays.toString(shardSizes));
-
-        // Search
-        System.out.println("\nSearch results:");
-        ScoredResult[] results = index.search(query, N);
-        for (ScoredResult r : results) {
-            int idx = r.index();
-            float origL2sq = 0;
-            for (int d = 0; d < dims; d++) {
-                float diff = query[d] - vectors[idx][d];
-                origL2sq += diff * diff;
-            }
-            float origL2 = (float) Math.sqrt(origL2sq);
-            System.out.printf("  doc-%d: spectorL2=%.6f  origL2=%.6f  match=%b  vec=%s%n",
-                    idx, r.score(), origL2, Math.abs(r.score() - origL2) < 0.001,
-                    Arrays.toString(vectors[idx]));
-        }
-
-        index.close();
-    }
-}
diff --git a/spector-bench/src/main/java/com/spectrayan/spector/bench/Svasq4RecallBench.java b/spector-bench/src/main/java/com/spectrayan/spector/bench/Svasq4RecallBench.java
deleted file mode 100644
index 3ecb893..0000000
--- a/spector-bench/src/main/java/com/spectrayan/spector/bench/Svasq4RecallBench.java
+++ /dev/null
@@ -1,451 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.bench;
-
-import com.spectrayan.spector.core.quantization.QuantizationType;
-import com.spectrayan.spector.core.similarity.SimilarityFunction;
-import com.spectrayan.spector.config.HnswParams;
-import com.spectrayan.spector.index.QuantizedHnswIndex;
-import com.spectrayan.spector.index.ScoredResult;
-
-import java.io.*;
-import java.net.URI;
-import java.net.http.HttpClient;
-import java.net.http.HttpRequest;
-import java.net.http.HttpResponse;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.time.Duration;
-import java.util.*;
-import java.util.concurrent.*;
-
-/**
- * SVASQ-8 vs SVASQ-4 recall and latency benchmark using real Ollama embeddings.
- *
- * <p>Generates diverse sentences, embeds them via Ollama (qwen3-embedding, 4096-dim),
- * builds SVASQ-8 and SVASQ-4 HNSW indices, and measures:
- * <ul>
- *   <li><b>Recall@10</b> against exact brute-force ground truth</li>
- *   <li><b>Query latency</b> (avg, p50, p99, QPS)</li>
- *   <li><b>Memory usage</b> (bytes per vector for each quantization mode)</li>
- * </ul>
- *
- * <p>Run:
- * <pre>
- *   mvn compile -pl spector-bench -q
- *   java --add-modules jdk.incubator.vector -Xmx8g \
- *        -cp spector-bench/target/classes:$(mvn -pl spector-bench dependency:build-classpath -q -DincludeScope=runtime -Dmdep.outputFile=/dev/stdout) \
- *        com.spectrayan.spector.bench.Svasq4RecallBench [size]
- * </pre>
- */
-public class Svasq4RecallBench {
-
-    // ── Configuration ───────────────────────────────────────────────────────
-    private static int    DATASET_SIZE      = 5_000;
-    private static final int    BATCH_SIZE          = 25;
-    private static final int    CONCURRENT_BATCHES  = 2;
-    private static final String MODEL               = "qwen3-embedding";
-    private static final String OLLAMA_URL          = "http://localhost:11434/api/embed";
-    private static final int    N_QUERIES           = 50;
-    private static final int    WARMUP              = 50;
-    private static final int    MEASURE             = 200;
-    private static final int    K                   = 10;
-
-    // ── Sentence templates ──────────────────────────────────────────────────
-    private static final String[][] TOPICS = {
-        {"The study of %s reveals fundamental principles about %s in the natural world",
-         "quantum mechanics", "particle physics", "thermodynamics", "electromagnetism",
-         "molecular biology", "organic chemistry", "astrophysics", "genetics",
-         "neuroscience", "biochemistry", "ecology", "paleontology"},
-        {"Recent advances in %s have transformed how we approach %s in modern computing",
-         "machine learning", "cloud computing", "cybersecurity", "blockchain",
-         "quantum computing", "edge computing", "natural language processing", "robotics",
-         "computer vision", "distributed systems", "microservices", "DevOps"},
-        {"The %s period was marked by significant developments in %s across civilizations",
-         "Renaissance", "Medieval", "Victorian", "Industrial Revolution",
-         "Ancient Greek", "Roman Empire", "Ming Dynasty", "Ottoman",
-         "Enlightenment", "Bronze Age", "Colonial", "Postwar"},
-        {"Clinical research on %s has led to breakthroughs in treating %s conditions",
-         "immunotherapy", "gene therapy", "stem cells", "CRISPR editing",
-         "mRNA vaccines", "monoclonal antibodies", "precision medicine", "regenerative medicine",
-         "pharmacogenomics", "biomarkers", "clinical trials", "drug delivery"},
-        {"The influence of %s on contemporary %s continues to shape creative expression",
-         "impressionism", "surrealism", "minimalism", "abstract expressionism",
-         "baroque music", "jazz improvisation", "digital art", "street photography",
-         "postmodern literature", "experimental film", "modern dance", "installation art"},
-        {"Global %s patterns indicate shifting trends in %s across major economies",
-         "trade", "investment", "inflation", "employment",
-         "monetary policy", "fiscal spending", "supply chain", "commodity pricing",
-         "currency exchange", "interest rate", "GDP growth", "market volatility"},
-    };
-
-    // ═══════════════════════════════════════════════════════════════════════
-    //  Main
-    // ═══════════════════════════════════════════════════════════════════════
-
-    public static void main(String[] args) throws Exception {
-        if (args.length > 0) {
-            try { DATASET_SIZE = Integer.parseInt(args[0]); }
-            catch (NumberFormatException e) { /* keep default */ }
-        }
-
-        System.out.println("╔══════════════════════════════════════════════════════════════╗");
-        System.out.printf( "║  SVASQ-8 vs SVASQ-4 Recall Benchmark  (%,d vectors, %s)  ║%n",
-                DATASET_SIZE, MODEL);
-        System.out.println("╚══════════════════════════════════════════════════════════════╝");
-        System.out.println();
-
-        // ── Step 1: Obtain embeddings (cached) ──────────────────────────────
-        Path cacheDir = Path.of("embedding-cache");
-        Files.createDirectories(cacheDir);
-        Path cacheFile = cacheDir.resolve(MODEL + "-" + DATASET_SIZE + ".bin");
-
-        float[][] embeddings;
-        int dims;
-
-        if (Files.exists(cacheFile)) {
-            System.out.printf("📦 Loading cached embeddings from %s%n", cacheFile);
-            embeddings = loadEmbeddings(cacheFile);
-            dims = embeddings[0].length;
-            System.out.printf("   Loaded %,d vectors × %d dims%n", embeddings.length, dims);
-        } else {
-            System.out.printf("🔄 Generating %,d sentences and embedding via Ollama (%s)...%n",
-                    DATASET_SIZE, MODEL);
-            String[] sentences = generateSentences(DATASET_SIZE);
-            embeddings = embedAll(sentences);
-            dims = embeddings[0].length;
-            saveEmbeddings(cacheFile, embeddings);
-            System.out.printf("   Embedded and cached %,d vectors × %d dims to %s%n",
-                    embeddings.length, dims, cacheFile);
-        }
-
-        // Embed queries
-        System.out.printf("🔍 Embedding %d query sentences...%n", N_QUERIES);
-        String[] querySentences = generateQuerySentences(N_QUERIES);
-        float[][] queries = embedAll(querySentences);
-        System.out.printf("   Query dims: %d%n%n", queries[0].length);
-
-        // Normalize for cosine
-        for (float[] v : embeddings) normalize(v);
-        for (float[] q : queries) normalize(q);
-
-        // ── Step 2: Compute brute-force ground truth ────────────────────────
-        System.out.println("📊 Computing brute-force ground truth (exact L2 on normalized)...");
-        long gtStart = System.nanoTime();
-        int[][] groundTruth = computeGroundTruth(embeddings, queries, K);
-        System.out.printf("   Done in %dms%n%n", (System.nanoTime() - gtStart) / 1_000_000);
-
-        // ── Step 3: Benchmark each configuration ────────────────────────────
-        record Config(String label, QuantizationType qt, int oversampling) {}
-
-        Config[] configs = {
-            // No rescore
-            new Config("SVASQ-8 (no rescore)",       QuantizationType.SVASQ,   1),
-            new Config("SVASQ-4 (no rescore)",       QuantizationType.SVASQ_4, 1),
-            // 2× oversampling rescore
-            new Config("SVASQ-8 (2× rescore)",       QuantizationType.SVASQ,   2),
-            new Config("SVASQ-4 (2× rescore)",       QuantizationType.SVASQ_4, 2),
-            // 3× oversampling rescore (recommended)
-            new Config("SVASQ-8 (3× rescore)",       QuantizationType.SVASQ,   3),
-            new Config("SVASQ-4 (3× rescore)",       QuantizationType.SVASQ_4, 3),
-            // 5× oversampling rescore
-            new Config("SVASQ-8 (5× rescore)",       QuantizationType.SVASQ,   5),
-            new Config("SVASQ-4 (5× rescore)",       QuantizationType.SVASQ_4, 5),
-        };
-
-        // Header
-        System.out.println("═══════════════════════════════════════════════════════════════════════════════════════");
-        System.out.printf("%-28s  %8s  %8s  %8s  %8s  %10s  %8s  %10s%n",
-                "Configuration", "recall@" + K, "avg(ms)", "p50(ms)", "p99(ms)", "QPS", "bpv", "total(MB)");
-        System.out.println("═══════════════════════════════════════════════════════════════════════════════════════");
-
-        for (Config cfg : configs) {
-            benchmarkConfig(cfg.label, cfg.qt, cfg.oversampling,
-                    dims, embeddings, queries, groundTruth);
-        }
-
-        System.out.println("═══════════════════════════════════════════════════════════════════════════════════════");
-        System.out.printf("%n✅ Benchmark complete. %,d vectors × %d dims, %d queries, model=%s%n",
-                DATASET_SIZE, dims, N_QUERIES, MODEL);
-    }
-
-    // ═══════════════════════════════════════════════════════════════════════
-    //  Benchmark runner
-    // ═══════════════════════════════════════════════════════════════════════
-
-    private static void benchmarkConfig(String label, QuantizationType qt, int oversampling,
-                                         int dims, float[][] embeddings,
-                                         float[][] queries, int[][] groundTruth) {
-        int n = embeddings.length;
-        HnswParams hnswParams = new HnswParams(16, 128, 64);
-
-        // Build index
-        QuantizedHnswIndex index;
-        if (qt == QuantizationType.SVASQ) {
-            index = QuantizedHnswIndex.svasq(dims, n, SimilarityFunction.COSINE, hnswParams, oversampling);
-        } else {
-            index = QuantizedHnswIndex.svasq4(dims, n, SimilarityFunction.COSINE, hnswParams, oversampling);
-        }
-
-        // Ingest
-        for (int i = 0; i < n; i++) {
-            index.add("doc-" + i, i, embeddings[i]);
-        }
-
-        int bpv = index.strategy() != null ? index.strategy().bytesPerVector() : -1;
-
-        // Warmup
-        for (int w = 0; w < WARMUP; w++) {
-            index.search(queries[w % N_QUERIES], K);
-        }
-
-        // Measure
-        long[] nanos = new long[MEASURE];
-        ScoredResult[][] results = new ScoredResult[N_QUERIES][];
-        for (int m = 0; m < MEASURE; m++) {
-            int q = m % N_QUERIES;
-            long start = System.nanoTime();
-            results[q] = index.search(queries[q], K);
-            nanos[m] = System.nanoTime() - start;
-        }
-
-        // Recall
-        double recall = computeRecall(results, groundTruth, N_QUERIES);
-
-        // Latency stats
-        Arrays.sort(nanos);
-        double avg = Arrays.stream(nanos).average().orElse(0) / 1e6;
-        double p50 = nanos[MEASURE / 2] / 1e6;
-        double p99 = nanos[(int) (MEASURE * 0.99)] / 1e6;
-        double qps = 1e9 / (Arrays.stream(nanos).average().orElse(1));
-
-        double totalMB = bpv > 0 ? ((double) n * bpv) / (1024 * 1024) : -1;
-
-        System.out.printf("%-28s  %8.4f  %8.3f  %8.3f  %8.3f  %10.0f  %8d  %10.2f%n",
-                label, recall, avg, p50, p99, qps, bpv, totalMB);
-
-        index.close();
-    }
-
-    // ═══════════════════════════════════════════════════════════════════════
-    //  Sentence generation
-    // ═══════════════════════════════════════════════════════════════════════
-
-    private static String[] generateSentences(int count) {
-        Random rng = new Random(42L);
-        String[] sentences = new String[count];
-        for (int i = 0; i < count; i++) {
-            String[] topic = TOPICS[rng.nextInt(TOPICS.length)];
-            String template = topic[0];
-            String arg1 = topic[1 + rng.nextInt(topic.length - 1)];
-            String arg2 = topic[1 + rng.nextInt(topic.length - 1)];
-            sentences[i] = String.format(template, arg1, arg2) + " (variant " + i + ")";
-        }
-        return sentences;
-    }
-
-    private static String[] generateQuerySentences(int count) {
-        Random rng = new Random(999L);
-        String[] sentences = new String[count];
-        for (int i = 0; i < count; i++) {
-            String[] topic = TOPICS[rng.nextInt(TOPICS.length)];
-            String template = topic[0];
-            String arg1 = topic[1 + rng.nextInt(topic.length - 1)];
-            String arg2 = topic[1 + rng.nextInt(topic.length - 1)];
-            sentences[i] = String.format(template, arg1, arg2);
-        }
-        return sentences;
-    }
-
-    // ═══════════════════════════════════════════════════════════════════════
-    //  Ollama embedding
-    // ═══════════════════════════════════════════════════════════════════════
-
-    private static float[][] embedAll(String[] sentences) throws Exception {
-        int total = sentences.length;
-        float[][] allEmbeddings = new float[total][];
-        int dims = -1;
-
-        ExecutorService pool = Executors.newFixedThreadPool(CONCURRENT_BATCHES);
-        HttpClient client = HttpClient.newBuilder()
-                .connectTimeout(Duration.ofSeconds(60))
-                .build();
-
-        List<Future<float[][]>> futures = new ArrayList<>();
-        int batchCount = 0;
-
-        for (int start = 0; start < total; start += BATCH_SIZE) {
-            final int batchStart = start;
-            final int batchEnd = Math.min(start + BATCH_SIZE, total);
-            final int batchNum = ++batchCount;
-            final int totalBatches = (total + BATCH_SIZE - 1) / BATCH_SIZE;
-
-            futures.add(pool.submit(() -> {
-                String[] batch = Arrays.copyOfRange(sentences, batchStart, batchEnd);
-                float[][] result = embedBatch(client, batch);
-                System.out.printf("  Batch %d/%d embedded (%d vectors)%n", batchNum, totalBatches, result.length);
-                return result;
-            }));
-        }
-
-        int idx = 0;
-        for (int start = 0; start < total; start += BATCH_SIZE) {
-            int batchEnd = Math.min(start + BATCH_SIZE, total);
-            float[][] batchResult = futures.get(idx++).get();
-            if (dims < 0) dims = batchResult[0].length;
-            System.arraycopy(batchResult, 0, allEmbeddings, start, batchEnd - start);
-        }
-
-        pool.shutdown();
-        return allEmbeddings;
-    }
-
-    private static float[][] embedBatch(HttpClient client, String[] texts) throws Exception {
-        StringBuilder json = new StringBuilder();
-        json.append("{\"model\":\"").append(MODEL).append("\",\"input\":[");
-        for (int i = 0; i < texts.length; i++) {
-            if (i > 0) json.append(",");
-            json.append("\"").append(escapeJson(texts[i])).append("\"");
-        }
-        json.append("]}");
-
-        HttpRequest request = HttpRequest.newBuilder()
-                .uri(URI.create(OLLAMA_URL))
-                .header("Content-Type", "application/json")
-                .timeout(Duration.ofSeconds(300))
-                .POST(HttpRequest.BodyPublishers.ofString(json.toString()))
-                .build();
-
-        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
-        if (response.statusCode() != 200) {
-            throw new RuntimeException("Ollama error " + response.statusCode() + ": " + response.body());
-        }
-        return parseEmbeddings(response.body());
-    }
-
-    private static float[][] parseEmbeddings(String json) {
-        int embStart = json.indexOf("\"embeddings\"");
-        if (embStart < 0) throw new RuntimeException("No embeddings in response");
-
-        int arrayStart = json.indexOf("[[", embStart);
-        int arrayEnd = json.lastIndexOf("]]");
-        if (arrayStart < 0 || arrayEnd < 0) throw new RuntimeException("Cannot parse embeddings");
-
-        String inner = json.substring(arrayStart + 1, arrayEnd + 1);
-        List<float[]> vectors = new ArrayList<>();
-
-        int pos = 0;
-        while (pos < inner.length()) {
-            int vecStart = inner.indexOf('[', pos);
-            if (vecStart < 0) break;
-            int vecEnd = inner.indexOf(']', vecStart);
-            if (vecEnd < 0) break;
-
-            String vecStr = inner.substring(vecStart + 1, vecEnd);
-            String[] parts = vecStr.split(",");
-            float[] vec = new float[parts.length];
-            for (int i = 0; i < parts.length; i++) {
-                vec[i] = Float.parseFloat(parts[i].trim());
-            }
-            vectors.add(vec);
-            pos = vecEnd + 1;
-        }
-        return vectors.toArray(new float[0][]);
-    }
-
-    private static String escapeJson(String s) {
-        return s.replace("\\", "\\\\")
-                .replace("\"", "\\\"")
-                .replace("\n", "\\n")
-                .replace("\r", "\\r")
-                .replace("\t", "\\t");
-    }
-
-    // ═══════════════════════════════════════════════════════════════════════
-    //  Embedding cache (binary)
-    // ═══════════════════════════════════════════════════════════════════════
-
-    private static void saveEmbeddings(Path path, float[][] embeddings) throws IOException {
-        int n = embeddings.length;
-        int dims = embeddings[0].length;
-        try (DataOutputStream out = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(path.toFile())))) {
-            out.writeInt(n);
-            out.writeInt(dims);
-            for (float[] vec : embeddings) {
-                for (float v : vec) out.writeFloat(v);
-            }
-        }
-    }
-
-    private static float[][] loadEmbeddings(Path path) throws IOException {
-        try (DataInputStream in = new DataInputStream(new BufferedInputStream(new FileInputStream(path.toFile())))) {
-            int n = in.readInt();
-            int dims = in.readInt();
-            float[][] embeddings = new float[n][dims];
-            for (int i = 0; i < n; i++) {
-                for (int d = 0; d < dims; d++) {
-                    embeddings[i][d] = in.readFloat();
-                }
-            }
-            return embeddings;
-        }
-    }
-
-    // ═══════════════════════════════════════════════════════════════════════
-    //  Math utilities
-    // ═══════════════════════════════════════════════════════════════════════
-
-    private static void normalize(float[] v) {
-        double norm = 0;
-        for (float f : v) norm += (double) f * f;
-        float scale = (float) (1.0 / Math.sqrt(norm));
-        for (int i = 0; i < v.length; i++) v[i] *= scale;
-    }
-
-    private static int[][] computeGroundTruth(float[][] data, float[][] queries, int k) {
-        int[][] truth = new int[queries.length][k];
-        for (int q = 0; q < queries.length; q++) {
-            float[] dists = new float[data.length];
-            for (int i = 0; i < data.length; i++) {
-                float sum = 0;
-                for (int d = 0; d < data[i].length; d++) {
-                    float diff = queries[q][d] - data[i][d];
-                    sum += diff * diff;
-                }
-                dists[i] = sum;
-            }
-            Integer[] indices = new Integer[data.length];
-            for (int i = 0; i < data.length; i++) indices[i] = i;
-            Arrays.sort(indices, (a, b) -> Float.compare(dists[a], dists[b]));
-            for (int i = 0; i < k; i++) truth[q][i] = indices[i];
-        }
-        return truth;
-    }
-
-    private static double computeRecall(ScoredResult[][] results, int[][] groundTruth, int nQueries) {
-        int hits = 0, total = 0;
-        for (int q = 0; q < nQueries; q++) {
-            if (results[q] == null) continue;
-            var truthSet = new HashSet<Integer>();
-            for (int idx : groundTruth[q]) truthSet.add(idx);
-            for (ScoredResult r : results[q]) {
-                if (truthSet.contains(r.index())) hits++;
-            }
-            total += groundTruth[q].length;
-        }
-        return total > 0 ? (double) hits / total : 0;
-    }
-}
diff --git a/spector-bench/src/main/java/com/spectrayan/spector/bench/SvasqDistanceBenchmark.java b/spector-bench/src/main/java/com/spectrayan/spector/bench/SvasqDistanceBenchmark.java
deleted file mode 100644
index 19f8b49..0000000
--- a/spector-bench/src/main/java/com/spectrayan/spector/bench/SvasqDistanceBenchmark.java
+++ /dev/null
@@ -1,195 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.bench;
-
-import com.spectrayan.spector.core.quantization.strategy.DistanceContext;
-import com.spectrayan.spector.core.quantization.strategy.SvasqStrategy;
-import com.spectrayan.spector.core.quantization.svasq.SvasqCalibrator;
-import com.spectrayan.spector.core.quantization.svasq.SvasqEncoder;
-import com.spectrayan.spector.core.quantization.svasq.SvasqParams;
-import com.spectrayan.spector.core.similarity.SimilarityFunction;
-
-import org.openjdk.jmh.annotations.*;
-import org.openjdk.jmh.infra.Blackhole;
-
-import java.lang.foreign.Arena;
-import java.lang.foreign.MemorySegment;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Random;
-import java.util.concurrent.TimeUnit;
-
-/**
- * JMH benchmarks for the SVASQ distance kernel — the single hottest path in the system.
- *
- * <p>Compares:</p>
- * <ul>
- *   <li><b>SVASQ distance</b> — prepareQueryContext() once, then distance() per candidate
- *       via the Panama SIMD kernel ({@link com.spectrayan.spector.core.quantization.svasq.SvasqSimdKernel})</li>
- *   <li><b>Exact float32 baseline</b> — {@link SimilarityFunction#compute} for reference</li>
- *   <li><b>Scan-1000</b> — simulates scanning 1000 candidates (a realistic shard size)</li>
- * </ul>
- *
- * <p>The key metric is <b>distance calls per millisecond</b>. For the SVASQ path to beat
- * float32, the SIMD kernel must overcome the FWHT rotation overhead on the query side.
- * The {@code prepareQueryContext} cost is amortized over all candidates in a shard.</p>
- *
- * <p>Run via:</p>
- * <pre>
- *   java -jar spector-bench/target/benchmarks.jar SvasqDistanceBenchmark
- * </pre>
- */
-@BenchmarkMode({Mode.Throughput, Mode.AverageTime})
-@OutputTimeUnit(TimeUnit.MICROSECONDS)
-@State(Scope.Benchmark)
-@Warmup(iterations = 3, time = 2)
-@Measurement(iterations = 5, time = 3)
-@Fork(value = 1, jvmArgsAppend = {
-        "--add-modules", "jdk.incubator.vector",
-        "--enable-native-access=ALL-UNNAMED",
-        "-Xmx2g"
-})
-public class SvasqDistanceBenchmark {
-
-    @Param({"128", "768"})
-    int dims;
-
-    /** Number of candidates in the scan benchmark (realistic shard size). */
-    @Param({"1000", "10000"})
-    int candidateCount;
-
-    private SvasqStrategy svasqStrategy;
-    private float[] queryVector;
-    private float[][] exactVectors;
-    private MemorySegment encodedSegment;
-    private Arena arena;
-    private int bpv;
-    private SimilarityFunction fn = SimilarityFunction.COSINE;
-
-    @Setup(Level.Trial)
-    public void setup() {
-        Random rng = new Random(42L);
-
-        // Build a calibrated SvasqStrategy
-        List<float[]> sample = new ArrayList<>(2000);
-        for (int i = 0; i < 2000; i++) sample.add(gaussianUnit(rng, dims));
-        SvasqParams params = SvasqCalibrator.calibrate(sample, dims);
-        SvasqEncoder encoder = new SvasqEncoder(params);
-        svasqStrategy = new SvasqStrategy(params, fn);
-        bpv = svasqStrategy.bytesPerVector();
-
-        // Query vector
-        queryVector = gaussianUnit(rng, dims);
-
-        // Exact float vectors for the baseline
-        exactVectors = new float[candidateCount][dims];
-        for (int i = 0; i < candidateCount; i++) exactVectors[i] = gaussianUnit(rng, dims);
-
-        // Encode all candidates into off-heap segment
-        arena = Arena.ofShared();
-        encodedSegment = arena.allocate((long) candidateCount * bpv, 8L);
-        for (int i = 0; i < candidateCount; i++) {
-            encoder.encode(exactVectors[i], encodedSegment, (long) i * bpv);
-        }
-    }
-
-    @TearDown(Level.Trial)
-    public void tearDown() {
-        arena.close();
-    }
-
-    // ── Single distance call benchmarks ──────────────────────────────────────
-
-    /**
-     * Single SVASQ distance call: prepareQueryContext (FWHT) + one distance() invocation.
-     * Represents the fixed per-query overhead.
-     */
-    @Benchmark
-    public float svasqDistance_single(Blackhole bh) {
-        DistanceContext ctx = svasqStrategy.prepareQueryContext(queryVector);
-        return svasqStrategy.distance(encodedSegment, 0L, ctx);
-    }
-
-    /**
-     * Single exact float32 distance — the baseline this replaces.
-     */
-    @Benchmark
-    public float exactDistance_single(Blackhole bh) {
-        return fn.compute(queryVector, exactVectors[0]);
-    }
-
-    // ── Scan-over-N benchmarks (the realistic case) ───────────────────────────
-
-    /**
-     * SVASQ scan over {@code candidateCount} candidates.
-     * prepareQueryContext called ONCE, then distance() called per candidate.
-     * This is the correct way to use SVASQ — amortize the FWHT rotation cost.
-     */
-    @Benchmark
-    public void svasqScan_amortized(Blackhole bh) {
-        DistanceContext ctx = svasqStrategy.prepareQueryContext(queryVector);
-        float best = Float.MAX_VALUE;
-        for (int i = 0; i < candidateCount; i++) {
-            float d = svasqStrategy.distance(encodedSegment, (long) i * bpv, ctx);
-            if (d < best) best = d;
-        }
-        bh.consume(best);
-    }
-
-    /**
-     * Exact float32 scan over {@code candidateCount} candidates.
-     * The baseline: what SVASQ must beat on total throughput.
-     */
-    @Benchmark
-    public void exactScan_baseline(Blackhole bh) {
-        float best = Float.MAX_VALUE;
-        for (int i = 0; i < candidateCount; i++) {
-            float d = fn.compute(queryVector, exactVectors[i]);
-            if (d < best) best = d;
-        }
-        bh.consume(best);
-    }
-
-    /**
-     * SVASQ scan but with prepareQueryContext called per-candidate (intentionally wrong).
-     * Demonstrates the cost of NOT amortizing the FWHT rotation.
-     * Expected to be ~D×log(D) slower than {@link #svasqScan_amortized}.
-     */
-    @Benchmark
-    public void svasqScan_noAmortization(Blackhole bh) {
-        float best = Float.MAX_VALUE;
-        for (int i = 0; i < candidateCount; i++) {
-            DistanceContext ctx = svasqStrategy.prepareQueryContext(queryVector);
-            float d = svasqStrategy.distance(encodedSegment, (long) i * bpv, ctx);
-            if (d < best) best = d;
-        }
-        bh.consume(best);
-    }
-
-    // ── Helpers ──────────────────────────────────────────────────────────────
-
-    private static float[] gaussianUnit(Random rng, int dims) {
-        float[] v = new float[dims];
-        double norm = 0;
-        for (int i = 0; i < dims; i++) {
-            v[i] = (float) rng.nextGaussian();
-            norm += (double) v[i] * v[i];
-        }
-        float scale = (float) (1.0 / Math.sqrt(norm));
-        for (int i = 0; i < dims; i++) v[i] *= scale;
-        return v;
-    }
-}
diff --git a/spector-bench/src/main/java/com/spectrayan/spector/bench/SvasqEncodeBenchmark.java b/spector-bench/src/main/java/com/spectrayan/spector/bench/SvasqEncodeBenchmark.java
deleted file mode 100644
index 786942a..0000000
--- a/spector-bench/src/main/java/com/spectrayan/spector/bench/SvasqEncodeBenchmark.java
+++ /dev/null
@@ -1,143 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.bench;
-
-import com.spectrayan.spector.core.quantization.strategy.SvasqStrategy;
-import com.spectrayan.spector.core.quantization.svasq.SvasqCalibrator;
-import com.spectrayan.spector.core.quantization.svasq.SvasqEncoder;
-import com.spectrayan.spector.core.quantization.svasq.SvasqParams;
-import com.spectrayan.spector.core.similarity.SimilarityFunction;
-
-import org.openjdk.jmh.annotations.*;
-import org.openjdk.jmh.infra.Blackhole;
-
-import java.lang.foreign.Arena;
-import java.lang.foreign.MemorySegment;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Random;
-import java.util.concurrent.TimeUnit;
-
-/**
- * JMH benchmarks for SVASQ encode throughput.
- *
- * <p>Measures the full encode pipeline: FWHT rotation → per-dimension INT8 quantization →
- * off-heap {@link MemorySegment} write. This is the hot path on every {@code add()} call
- * after promotion to HNSW mode.</p>
- *
- * <p>Run via:</p>
- * <pre>
- *   java -jar spector-bench/target/benchmarks.jar SvasqEncodeBenchmark
- * </pre>
- */
-@BenchmarkMode({Mode.Throughput, Mode.AverageTime})
-@OutputTimeUnit(TimeUnit.MICROSECONDS)
-@State(Scope.Benchmark)
-@Warmup(iterations = 3, time = 2)
-@Measurement(iterations = 5, time = 3)
-@Fork(value = 1, jvmArgsAppend = {
-        "--add-modules", "jdk.incubator.vector",
-        "--enable-native-access=ALL-UNNAMED",
-        "-Xmx2g"
-})
-public class SvasqEncodeBenchmark {
-
-    @Param({"128", "768"})
-    int dims;
-
-    /** Number of vectors in the batch encode benchmark. */
-    @Param({"1000", "10000"})
-    int batchSize;
-
-    private SvasqEncoder encoder;
-    private SvasqStrategy strategy;
-    private float[] singleVector;
-    private float[][] batchVectors;
-    private MemorySegment segment;
-    private Arena arena;
-    private int bpv;
-
-    @Setup(Level.Trial)
-    public void setup() {
-        Random rng = new Random(42L);
-
-        // Build calibration sample
-        List<float[]> sample = new ArrayList<>(2000);
-        for (int i = 0; i < 2000; i++) {
-            float[] v = gaussianUnit(rng, dims);
-            sample.add(v);
-        }
-
-        SvasqParams params = SvasqCalibrator.calibrate(sample, dims);
-        encoder = new SvasqEncoder(params);
-        strategy = new SvasqStrategy(params, SimilarityFunction.COSINE);
-        bpv = strategy.bytesPerVector();
-
-        // Off-heap segment big enough for batchSize vectors
-        arena = Arena.ofShared();
-        segment = arena.allocate((long) batchSize * bpv, 8L);
-
-        // Single vector for single-encode benchmark
-        singleVector = gaussianUnit(rng, dims);
-
-        // Batch vectors
-        batchVectors = new float[batchSize][dims];
-        for (int i = 0; i < batchSize; i++) {
-            batchVectors[i] = gaussianUnit(rng, dims);
-        }
-    }
-
-    @TearDown(Level.Trial)
-    public void tearDown() {
-        arena.close();
-    }
-
-    /**
-     * Encodes a single vector into the segment at offset 0.
-     * Represents the per-vector cost in the HNSW add() hot path.
-     */
-    @Benchmark
-    public void encode_single(Blackhole bh) {
-        encoder.encode(singleVector, segment, 0L);
-        bh.consume(segment);
-    }
-
-    /**
-     * Encodes all {@code batchSize} vectors sequentially into the segment.
-     * Represents bulk-ingestion throughput (e.g. at shard promotion time).
-     */
-    @Benchmark
-    public void encode_batch(Blackhole bh) {
-        for (int i = 0; i < batchSize; i++) {
-            encoder.encode(batchVectors[i], segment, (long) i * bpv);
-        }
-        bh.consume(segment);
-    }
-
-    // ── Helpers ──────────────────────────────────────────────────────────────
-
-    private static float[] gaussianUnit(Random rng, int dims) {
-        float[] v = new float[dims];
-        double norm = 0;
-        for (int i = 0; i < dims; i++) {
-            v[i] = (float) rng.nextGaussian();
-            norm += (double) v[i] * v[i];
-        }
-        float scale = (float) (1.0 / Math.sqrt(norm));
-        for (int i = 0; i < dims; i++) v[i] *= scale;
-        return v;
-    }
-}
diff --git a/spector-bench/src/main/java/com/spectrayan/spector/bench/package-info.java b/spector-bench/src/main/java/com/spectrayan/spector/bench/package-info.java
index baaf4c6..279ff35 100644
--- a/spector-bench/src/main/java/com/spectrayan/spector/bench/package-info.java
+++ b/spector-bench/src/main/java/com/spectrayan/spector/bench/package-info.java
@@ -1,20 +1,5 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 /**
- * Spector Benchmarks — JMH performance benchmarks for Spector.
+ * Spector Benchmarks — JMH performance benchmarks for Spector Search.
  *
  * <p>Contains microbenchmarks for SIMD kernels, index operations,
  * and end-to-end search latency measurements.</p>
diff --git a/spector-cli/README.md b/spector-cli/README.md
deleted file mode 100644
index 3a0e1d6..0000000
--- a/spector-cli/README.md
+++ /dev/null
@@ -1,99 +0,0 @@
-# spector-cli 🖥️
-
-> **Command-line interface (`spectorctl`) for Spector — with both remote and local batch modes.**
-
-`spector-cli` implements **`spectorctl`**, a unified CLI that supports:
-- **Remote mode** — manage a running Spector server via REST API (search, ingest single docs, status)
-- **Local batch mode** — discover and ingest files directly via `SpectorRuntime` (no server needed)
-
----
-
-## 🚀 Quick Start
-
-```bash
-# Build from source
-mvn clean package -pl spector-dist -am -DskipTests
-
-# Run via fat JAR
-java --add-modules jdk.incubator.vector -cp spector-dist/target/spector.jar \
-    com.spectrayan.spector.cli.SpectorCtl [command] [options]
-```
-
----
-
-## 📥 Ingestion
-
-The `ingest` command auto-detects mode from the flags provided:
-
-### Local Batch Mode (via Runtime)
-
-Discovers and ingests files directly — no server needed. Honors `spector.yml` config.
-
-```bash
-# Ingest from config (root-directory from spector.yml)
-spectorctl ingest --config spector.yml
-
-# Ingest with explicit root directory
-spectorctl ingest --root /path/to/docs --pattern "**/*.md"
-
-# Override chunk size
-spectorctl ingest --config spector.yml --root . --chunk-size 1200
-```
-
-### Remote Mode (via HTTP)
-
-Sends a single document to a running Spector server.
-
-```bash
-# Ingest text content
-spectorctl ingest --content "Hello world" --id doc-1
-
-# Ingest from a file
-spectorctl ingest --file README.md --title "Project README"
-```
-
----
-
-## 🔍 Search
-
-```bash
-# Search with default settings
-spectorctl search --text "vector databases" --topK 5
-
-# Output as JSON (machine-parseable)
-spectorctl search --text "HNSW algorithm" --json
-```
-
----
-
-## 📊 Status
-
-```bash
-# Show engine status
-spectorctl status
-
-# JSON output
-spectorctl status --json
-```
-
----
-
-## 🌐 Global Options
-
-| Option | Default | Description |
-|--------|---------|-------------|
-| `--host` | localhost | Spector server hostname (remote mode) |
-| `--port` | 7070 | Spector server port (remote mode) |
-| `--json` | false | Output in JSON format |
-
----
-
-## 🏗️ Architecture
-
-```
-spectorctl ingest --root /docs    → SpectorRuntime → IngestionHandler → engine/memory
-spectorctl ingest --content "..."  → SpectorClient → HTTP → SpectorNode
-spectorctl search --text "..."     → SpectorClient → HTTP → SpectorNode
-```
-
-The CLI depends on both `spector-runtime` (local operations) and `spector-client` (remote operations). Mode is auto-detected from the flags provided.
diff --git a/spector-cli/pom.xml b/spector-cli/pom.xml
index 2afb91f..db88fd9 100644
--- a/spector-cli/pom.xml
+++ b/spector-cli/pom.xml
@@ -6,13 +6,13 @@
 
     <parent>
         <groupId>com.spectrayan</groupId>
-        <artifactId>spector</artifactId>
+        <artifactId>spector-search</artifactId>
         <version>0.1.0-SNAPSHOT</version>
     </parent>
 
     <artifactId>spector-cli</artifactId>
     <name>Spector CLI (spectorctl)</name>
-    <description>Command-line tool for managing Spector instances.</description>
+    <description>Command-line tool for managing Spector Search instances.</description>
 
     <properties>
         <picocli.version>4.7.6</picocli.version>
@@ -26,34 +26,15 @@
             <version>${picocli.version}</version>
         </dependency>
 
-        <!-- Spector Client SDK (remote mode) -->
+        <!-- Spector Client SDK -->
         <dependency>
             <groupId>com.spectrayan</groupId>
             <artifactId>spector-client</artifactId>
         </dependency>
 
-        <!-- ── Runtime (local mode — direct ingestion via runtime) ── -->
-        <dependency>
-            <groupId>com.spectrayan</groupId>
-            <artifactId>spector-runtime</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>com.spectrayan</groupId>
-            <artifactId>spector-config</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>com.spectrayan</groupId>
-            <artifactId>spector-embed-api</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>com.spectrayan</groupId>
-            <artifactId>spector-embed-ollama</artifactId>
-            <scope>runtime</scope>
-        </dependency>
-
         <!-- Jackson for JSON parsing -->
         <dependency>
-            <groupId>tools.jackson.core</groupId>
+            <groupId>com.fasterxml.jackson.core</groupId>
             <artifactId>jackson-databind</artifactId>
         </dependency>
 
@@ -63,10 +44,6 @@
             <artifactId>logback-classic</artifactId>
             <scope>runtime</scope>
         </dependency>
-        <dependency>
-            <groupId>com.spectrayan</groupId>
-            <artifactId>spector-commons</artifactId>
-        </dependency>
     </dependencies>
 
     <build>
diff --git a/spector-cli/src/main/java/com/spectrayan/spector/cli/BaseCommand.java b/spector-cli/src/main/java/com/spectrayan/spector/cli/BaseCommand.java
index 78611cf..0615e83 100644
--- a/spector-cli/src/main/java/com/spectrayan/spector/cli/BaseCommand.java
+++ b/spector-cli/src/main/java/com/spectrayan/spector/cli/BaseCommand.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.cli;
 
 import com.spectrayan.spector.client.SpectorClient;
@@ -21,8 +6,6 @@
 
 import java.io.PrintWriter;
 import java.time.Duration;
-import com.spectrayan.spector.commons.error.SpectorInternalException;
-import com.spectrayan.spector.commons.error.ErrorCode;
 
 /**
  * Base class for CLI subcommands. Provides access to inherited options
@@ -72,7 +55,7 @@ protected PrintWriter err() {
      * Handles a connection exception by printing a user-friendly error.
      */
     protected int handleConnectionError(SpectorConnectionException e) {
-        err().println("Error: Unable to connect to Spector at " + e.host() + ":" + e.port());
+        err().println("Error: Unable to connect to Spector Search at " + e.host() + ":" + e.port());
         err().println("Cause: " + e.getCause().getMessage());
         return 1;
     }
@@ -97,6 +80,6 @@ private SpectorCtl resolveRoot() {
             return root;
         }
         // Should not happen if Picocli wiring is correct
-        throw new SpectorInternalException(ErrorCode.INTERNAL_ERROR, "Cannot resolve root SpectorCtl command");
+        throw new IllegalStateException("Cannot resolve root SpectorCtl command");
     }
 }
diff --git a/spector-cli/src/main/java/com/spectrayan/spector/cli/IndexCommand.java b/spector-cli/src/main/java/com/spectrayan/spector/cli/IndexCommand.java
index 9a12600..7036389 100644
--- a/spector-cli/src/main/java/com/spectrayan/spector/cli/IndexCommand.java
+++ b/spector-cli/src/main/java/com/spectrayan/spector/cli/IndexCommand.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.cli;
 
 import com.spectrayan.spector.client.SpectorClient;
diff --git a/spector-cli/src/main/java/com/spectrayan/spector/cli/IngestCommand.java b/spector-cli/src/main/java/com/spectrayan/spector/cli/IngestCommand.java
index 235a934..378b982 100644
--- a/spector-cli/src/main/java/com/spectrayan/spector/cli/IngestCommand.java
+++ b/spector-cli/src/main/java/com/spectrayan/spector/cli/IngestCommand.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.cli;
 
 import com.spectrayan.spector.client.SpectorClient;
@@ -20,12 +5,6 @@
 import com.spectrayan.spector.client.SpectorConnectionException;
 import com.spectrayan.spector.client.model.IngestRequest;
 import com.spectrayan.spector.client.model.IngestResponse;
-import com.spectrayan.spector.config.SpectorConfigFactory;
-import com.spectrayan.spector.config.SpectorProperties;
-import com.spectrayan.spector.embed.EmbeddingProvider;
-import com.spectrayan.spector.ingestion.EmbeddingProviderFactory;
-import com.spectrayan.spector.runtime.IngestionHandler;
-import com.spectrayan.spector.runtime.SpectorRuntime;
 import picocli.CommandLine;
 import picocli.CommandLine.Command;
 
@@ -36,186 +15,32 @@
 import java.util.Map;
 
 /**
- * Ingest documents into Spector.
- *
- * <p>Supports two modes, auto-detected from the flags provided:</p>
- * <ul>
- *   <li><strong>Remote</strong> — {@code --content} or {@code --file}: sends a single
- *       document to a running Spector server via HTTP.</li>
- *   <li><strong>Local batch</strong> — {@code --root}: discovers and ingests files
- *       locally through {@link SpectorRuntime}, honoring {@code spector.yml} config.</li>
- * </ul>
- *
- * <h3>Examples</h3>
- * <pre>
- *   spectorctl ingest --content "Hello world"             # remote
- *   spectorctl ingest --file README.md                    # remote
- *   spectorctl ingest --root /docs --pattern "**\/*.md"   # local batch
- *   spectorctl ingest --root . --config spector.yml       # local batch
- * </pre>
+ * Ingest a document into the Spector Search engine.
  */
 @Command(
         name = "ingest",
-        description = "Ingest documents into Spector (remote or local batch).",
+        description = "Ingest a document into Spector Search.",
         mixinStandardHelpOptions = true
 )
 class IngestCommand extends BaseCommand {
 
-    // ── Remote mode options ──
     @CommandLine.Option(names = {"--id"}, description = "Document ID (auto-generated if not provided).")
     private String documentId;
 
     @CommandLine.Option(names = {"--title"}, description = "Document title.")
     private String title;
 
-    @CommandLine.Option(names = {"--content"}, description = "Document content (text). Remote mode.")
+    @CommandLine.Option(names = {"--content"}, description = "Document content (text). Provide either --content or --file.")
     private String content;
 
-    @CommandLine.Option(names = {"--file"}, description = "Path to file to ingest. Remote mode.")
+    @CommandLine.Option(names = {"--file"}, description = "Path to file to ingest.")
     private Path file;
 
-    // ── Local batch mode options ──
-    @CommandLine.Option(names = {"--root"}, description = "Root directory for local batch ingestion.")
-    private Path rootDir;
-
-    @CommandLine.Option(names = {"--pattern"}, description = "File glob pattern (default from config).")
-    private String pattern;
-
-    @CommandLine.Option(names = {"--chunk-size"}, description = "Chunk size in characters (default from config).")
-    private Integer chunkSize;
-
-    @CommandLine.Option(names = {"--config"}, description = "Path to spector.yml config file.")
-    private Path configFile;
-
     @Override
     public void run() {
-        if (rootDir != null) {
-            runLocalBatch();
-        } else if (configFile != null) {
-            // Config provided — check if it has a root-directory for local batch
-            var props = SpectorProperties.builder().configFile(configFile).build();
-            var ingestionConfig = SpectorConfigFactory.ingestionDefaults(props);
-            if (ingestionConfig.rootDirectory() != null) {
-                rootDir = ingestionConfig.rootDirectory();
-                runLocalBatch();
-            } else {
-                runRemote();
-            }
-        } else if (content != null || file != null) {
-            runRemote();
-        } else {
-            err().println("Error: Provide --content, --file, or --root (or --config with root-directory).");
-            spec.commandLine().usage(err());
-        }
-    }
-
-    // ─────────────── Local Batch Mode ───────────────
-
-    private void runLocalBatch() {
-        // ── Build config from spector.yml + CLI overrides ──
-        SpectorProperties.Builder propsBuilder = SpectorProperties.builder();
-
-        if (configFile != null) propsBuilder.configFile(configFile);
-        if (pattern != null)
-            propsBuilder.override("spector.ingestion.file-pattern", pattern);
-        if (chunkSize != null)
-            propsBuilder.override("spector.ingestion.chunk-size", chunkSize.toString());
-
-        if (rootDir != null)
-            propsBuilder.override("spector.ingestion.root-directory", rootDir.toString());
-
-        SpectorProperties props = propsBuilder.build();
-
-        // ── Read configs ──
-        var ingestionConfig = SpectorConfigFactory.ingestionDefaults(props);
-        var embedConfig = SpectorConfigFactory.embeddingDefaults(props);
-        var engineConfig = SpectorConfigFactory.engineDefaults(props);
-        var mode = SpectorConfigFactory.mode(props);
-        Path root = ingestionConfig.rootDirectory().toAbsolutePath().normalize();
-
-        // ── Banner ──
-        out().printf("===================================================%n");
-        out().printf("  Spector Ingestion (local batch)%n");
-        out().printf("  Mode:    %s%n", mode);
-        out().printf("  Root:    %s%n", root);
-        out().printf("  Pattern: %s%n", ingestionConfig.filePattern());
-        out().printf("  Data:    %s%n", engineConfig.dataDirectory());
-        out().printf("  Model:   %s @ %s%n", embedConfig.model(), embedConfig.baseUrl());
-        out().printf("  Chunk:   %d chars%n", ingestionConfig.chunkSize());
-        out().printf("  Threads: %d parallel, %d retries (delay: %dms)%n",
-                ingestionConfig.parallelism(), ingestionConfig.maxRetries(),
-                ingestionConfig.retryDelayMs());
-        out().printf("===================================================%n%n");
-
-        // ── Create embedder + probe dims ──
-        EmbeddingProvider embedder = EmbeddingProviderFactory.create(
-                embedConfig.baseUrl(), embedConfig.model());
-        int dims = embedder.embed("probe").dimensions();
-        out().printf("[Embedding] Dimensions: %d%n%n", dims);
-
-        propsBuilder.override("spector.engine.dimensions", String.valueOf(dims));
-        propsBuilder.override("spector.memory.dimensions", String.valueOf(dims));
-        props = propsBuilder.build();
-
-        // ── Create runtime + ingest ──
-        try (SpectorRuntime runtime = SpectorRuntime.from(props, embedder)) {
-            long startMs = System.currentTimeMillis();
-
-            var results = runtime.ingestion().ingest(
-                    root,
-                    ingestionConfig.filePattern(),
-                    ingestionConfig.chunkSize(),
-                    ingestionConfig.chunkOverlap(),
-                    ingestionConfig.skipDirs(),
-                    new IngestionHandler.IngestionProgress() {
-                        @Override
-                        public void onFileStart(int fileIndex, int totalFiles, String relativePath) {
-                            out().printf("  [%d/%d] > %s ...%n", fileIndex, totalFiles, relativePath);
-                            out().flush();
-                        }
-
-                        @Override
-                        public void onFile(int fileIdx, int total, String path,
-                                           int chunks, long ms, String error) {
-                            if (error != null) {
-                                out().printf("  [%d/%d] X %s -- FAILED (%dms): %s%n",
-                                        fileIdx, total, path, ms, error);
-                            } else {
-                                out().printf("  [%d/%d] OK %s -- %d chunk%s, %dms%n",
-                                        fileIdx, total, path, chunks,
-                                        chunks == 1 ? "" : "s", ms);
-                            }
-                            out().flush();
-                        }
-                    },
-                    ingestionConfig.parallelism(),
-                    ingestionConfig.maxRetries(),
-                    ingestionConfig.retryDelayMs());
-
-            int files = results.size();
-            int chunks = results.stream().mapToInt(r -> r.chunksStored()).sum();
-            int failures = (int) results.stream().filter(r -> !r.isFullSuccess()).count();
-            long elapsed = System.currentTimeMillis() - startMs;
-
-            out().printf("%n===================================================%n");
-            out().printf("  Ingestion Complete%n");
-            out().printf("  Mode:     %s%n", runtime.mode());
-            out().printf("  Files:    %d%n", files);
-            out().printf("  Chunks:   %d%n", chunks);
-            out().printf("  Failures: %d%n", failures);
-            out().printf("  Docs:     %d (in %s)%n", runtime.ingestion().count(),
-                    runtime.mode().name().toLowerCase());
-            out().printf("  Time:     %dms%n", elapsed);
-            out().printf("===================================================%n");
-        }
-    }
-
-    // ─────────────── Remote Mode ───────────────
-
-    private void runRemote() {
         String text = resolveContent();
         if (text == null) {
-            err().println("Error: Provide --content, --file, or --root.");
+            err().println("Error: Provide either --content or --file.");
             spec.commandLine().usage(err());
             return;
         }
diff --git a/spector-cli/src/main/java/com/spectrayan/spector/cli/OutputFormatter.java b/spector-cli/src/main/java/com/spectrayan/spector/cli/OutputFormatter.java
index d9f9ab6..ac64107 100644
--- a/spector-cli/src/main/java/com/spectrayan/spector/cli/OutputFormatter.java
+++ b/spector-cli/src/main/java/com/spectrayan/spector/cli/OutputFormatter.java
@@ -1,36 +1,19 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.cli;
 
 import java.io.PrintWriter;
 import java.util.List;
 
-import tools.jackson.core.JacksonException;
-import tools.jackson.databind.ObjectMapper;
-import tools.jackson.databind.SerializationFeature;
-import tools.jackson.databind.json.JsonMapper;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.SerializationFeature;
 
 /**
  * Utility for formatting CLI output as either a table or JSON.
  */
 final class OutputFormatter {
 
-    private static final ObjectMapper MAPPER = JsonMapper.builder()
-            .enable(SerializationFeature.INDENT_OUTPUT)
-            .build();
+    private static final ObjectMapper MAPPER = new ObjectMapper()
+            .enable(SerializationFeature.INDENT_OUTPUT);
 
     private OutputFormatter() {}
 
@@ -85,7 +68,7 @@ static void printTable(PrintWriter out, String[] headers, List<String[]> rows) {
     static void printJson(PrintWriter out, Object value) {
         try {
             out.println(MAPPER.writeValueAsString(value));
-        } catch (JacksonException e) {
+        } catch (JsonProcessingException e) {
             out.println("{\"error\": \"Failed to serialize output: " + e.getMessage() + "\"}");
         }
     }
diff --git a/spector-cli/src/main/java/com/spectrayan/spector/cli/SearchCommand.java b/spector-cli/src/main/java/com/spectrayan/spector/cli/SearchCommand.java
index 2482b49..a8b5357 100644
--- a/spector-cli/src/main/java/com/spectrayan/spector/cli/SearchCommand.java
+++ b/spector-cli/src/main/java/com/spectrayan/spector/cli/SearchCommand.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.cli;
 
 import com.spectrayan.spector.client.SpectorClient;
@@ -29,11 +14,11 @@
 import java.util.Map;
 
 /**
- * Search documents in the Spector engine.
+ * Search documents in the Spector Search engine.
  */
 @Command(
         name = "search",
-        description = "Search for documents in Spector.",
+        description = "Search for documents in Spector Search.",
         mixinStandardHelpOptions = true
 )
 class SearchCommand extends BaseCommand {
diff --git a/spector-cli/src/main/java/com/spectrayan/spector/cli/SpectorCtl.java b/spector-cli/src/main/java/com/spectrayan/spector/cli/SpectorCtl.java
index 48e744a..9c8afaa 100644
--- a/spector-cli/src/main/java/com/spectrayan/spector/cli/SpectorCtl.java
+++ b/spector-cli/src/main/java/com/spectrayan/spector/cli/SpectorCtl.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.cli;
 
 import picocli.CommandLine;
@@ -22,7 +7,7 @@
 /**
  * Main entry point for the spectorctl command-line tool.
  *
- * <p>Provides subcommands for managing a running Spector instance
+ * <p>Provides subcommands for managing a running Spector Search instance
  * via its REST API.</p>
  *
  * <h3>Usage</h3>
@@ -38,7 +23,7 @@
  */
 @Command(
         name = "spectorctl",
-        description = "Command-line tool for managing Spector instances.",
+        description = "Command-line tool for managing Spector Search instances.",
         mixinStandardHelpOptions = true,
         version = "spectorctl 0.1.0",
         subcommands = {
@@ -50,11 +35,11 @@
 )
 public class SpectorCtl implements Runnable {
 
-    @Option(names = {"--host"}, description = "Spector host (default: localhost).",
+    @Option(names = {"--host"}, description = "Spector Search host (default: localhost).",
             defaultValue = "localhost", scope = CommandLine.ScopeType.INHERIT)
     String host;
 
-    @Option(names = {"--port"}, description = "Spector port (default: 7070).",
+    @Option(names = {"--port"}, description = "Spector Search port (default: 7070).",
             defaultValue = "7070", scope = CommandLine.ScopeType.INHERIT)
     int port;
 
diff --git a/spector-cli/src/main/java/com/spectrayan/spector/cli/StatusCommand.java b/spector-cli/src/main/java/com/spectrayan/spector/cli/StatusCommand.java
index efdead7..ae8afa8 100644
--- a/spector-cli/src/main/java/com/spectrayan/spector/cli/StatusCommand.java
+++ b/spector-cli/src/main/java/com/spectrayan/spector/cli/StatusCommand.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.cli;
 
 import com.spectrayan.spector.client.SpectorClient;
@@ -25,11 +10,11 @@
 import java.util.Map;
 
 /**
- * Displays the status of the connected Spector instance.
+ * Displays the status of the connected Spector Search instance.
  */
 @Command(
         name = "status",
-        description = "Show Spector instance status.",
+        description = "Show Spector Search instance status.",
         mixinStandardHelpOptions = true
 )
 class StatusCommand extends BaseCommand {
@@ -42,7 +27,7 @@ public void run() {
             if (isJson()) {
                 OutputFormatter.printJson(out(), status);
             } else {
-                out().println("Spector Status");
+                out().println("Spector Search Status");
                 out().println("=====================");
                 String[][] entries = {
                         {"Engine", status.getEngine() != null ? status.getEngine() : "N/A"},
diff --git a/spector-cli/src/test/java/com/spectrayan/spector/cli/SpectorCtlTest.java b/spector-cli/src/test/java/com/spectrayan/spector/cli/SpectorCtlTest.java
index 3668093..a64bbb6 100644
--- a/spector-cli/src/test/java/com/spectrayan/spector/cli/SpectorCtlTest.java
+++ b/spector-cli/src/test/java/com/spectrayan/spector/cli/SpectorCtlTest.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.cli;
 
 import org.junit.jupiter.api.Test;
@@ -62,7 +47,7 @@ void helpFlag_displaysUsage() {
 
         assertThat(exitCode).isEqualTo(0);
         String output = sw.toString();
-        assertThat(output).contains("Command-line tool for managing Spector");
+        assertThat(output).contains("Command-line tool for managing Spector Search");
         assertThat(output).contains("--host");
         assertThat(output).contains("--port");
         assertThat(output).contains("--json");
diff --git a/spector-client/README.md b/spector-client/README.md
deleted file mode 100644
index b339753..0000000
--- a/spector-client/README.md
+++ /dev/null
@@ -1,30 +0,0 @@
-# spector-client 🔌
-
-> **High-performance Java SDK client for remote Spector servers.**
-
-`spector-client` implements a type-safe, developer-friendly Java SDK for interacting with remote `SpectorNode` nodes. It handles HTTP request builders, JSON serialization/deserialization, connection pooling, and resilient API call fallbacks automatically.
-
----
-
-## 🚀 Key APIs
-
-### Creating Remote Client Context
-```java
-SpectorClientConfig config = SpectorClientConfig.builder()
-    .endpoint("http://localhost:7070")
-    .apiKey("my-highly-secure-api-key")
-    .timeout(Duration.ofSeconds(10))
-    .build();
-
-try (SpectorClient client = new SpectorClient(config)) {
-    // Ingest remote document
-    client.ingest("doc-1", "Semantic Java SDK Client", embedding);
-    
-    // Execute search request
-    SearchResponse response = client.search("java sdk client", queryVector, 10);
-    
-    for (ScoredResult r : response.results()) {
-        System.out.println(r.id() + " -> " + r.score());
-    }
-}
-```
diff --git a/spector-client/pom.xml b/spector-client/pom.xml
index 0e018d5..883516f 100644
--- a/spector-client/pom.xml
+++ b/spector-client/pom.xml
@@ -6,24 +6,20 @@
 
     <parent>
         <groupId>com.spectrayan</groupId>
-        <artifactId>spector</artifactId>
+        <artifactId>spector-search</artifactId>
         <version>0.1.0-SNAPSHOT</version>
     </parent>
 
     <artifactId>spector-client</artifactId>
     <name>Spector Client SDK</name>
-    <description>Java client SDK for programmatic interaction with Spector REST API.</description>
+    <description>Java client SDK for programmatic interaction with Spector Search REST API.</description>
 
     <dependencies>
         <!-- Jackson for JSON serialization/deserialization -->
         <dependency>
-            <groupId>tools.jackson.core</groupId>
+            <groupId>com.fasterxml.jackson.core</groupId>
             <artifactId>jackson-databind</artifactId>
         </dependency>
-        <dependency>
-            <groupId>com.spectrayan</groupId>
-            <artifactId>spector-commons</artifactId>
-        </dependency>
     </dependencies>
 
 </project>
diff --git a/spector-client/src/main/java/com/spectrayan/spector/client/SpectorClient.java b/spector-client/src/main/java/com/spectrayan/spector/client/SpectorClient.java
index 5b2dc64..3ababd8 100644
--- a/spector-client/src/main/java/com/spectrayan/spector/client/SpectorClient.java
+++ b/spector-client/src/main/java/com/spectrayan/spector/client/SpectorClient.java
@@ -1,24 +1,8 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.client;
 
 import com.fasterxml.jackson.annotation.JsonInclude;
-import tools.jackson.databind.DeserializationFeature;
-import tools.jackson.databind.ObjectMapper;
-import tools.jackson.databind.json.JsonMapper;
+import com.fasterxml.jackson.databind.DeserializationFeature;
+import com.fasterxml.jackson.databind.ObjectMapper;
 import com.spectrayan.spector.client.model.*;
 
 import org.slf4j.Logger;
@@ -33,12 +17,9 @@
 import java.time.Duration;
 import java.util.List;
 import java.util.Map;
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-import com.spectrayan.spector.commons.error.ErrorCode;
-import com.spectrayan.spector.commons.error.SpectorException;
 
 /**
- * Thread-safe Java client SDK for Spector REST API.
+ * Thread-safe Java client SDK for Spector Search REST API.
  *
  * <p>Uses Java HttpClient with connection pooling. All methods are safe
  * for concurrent invocations from multiple threads.</p>
@@ -74,11 +55,9 @@ private SpectorClient(Builder builder) {
                 .connectTimeout(builder.connectTimeout)
                 .build();
 
-        this.objectMapper = JsonMapper.builder()
-                .changeDefaultPropertyInclusion(incl -> incl
-                        .withValueInclusion(JsonInclude.Include.NON_NULL))
-                .disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES)
-                .build();
+        this.objectMapper = new ObjectMapper()
+                .setSerializationInclusion(JsonInclude.Include.NON_NULL)
+                .configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
     }
 
     /**
@@ -116,7 +95,7 @@ public IngestResponse bulkIngest(List<IngestRequest> requests) {
     }
 
     /**
-     * Performs a search against the Spector engine.
+     * Performs a search against the Spector Search engine.
      *
      * @param request the search request (keyword, vector, or hybrid)
      * @return the search response containing results and metadata
@@ -194,7 +173,7 @@ private HttpRequest buildRequest(String method, String path, Object body) {
             try {
                 byte[] jsonBytes = objectMapper.writeValueAsBytes(body);
                 builder.method(method, HttpRequest.BodyPublishers.ofByteArray(jsonBytes));
-            } catch (Exception e) {
+            } catch (IOException e) {
                 throw new SpectorClientException("Failed to serialize request body: " + e.getMessage(), e);
             }
         } else {
@@ -279,7 +258,7 @@ private Builder() {}
         /** Sets the server host (default: localhost). */
         public Builder host(String host) {
             if (host == null || host.isBlank()) {
-                throw new SpectorValidationException(ErrorCode.ARGUMENT_NULL, "host");
+                throw new IllegalArgumentException("host must not be null or blank");
             }
             this.host = host;
             return this;
@@ -288,7 +267,7 @@ public Builder host(String host) {
         /** Sets the server port (default: 7070). */
         public Builder port(int port) {
             if (port <= 0 || port > 65535) {
-                throw new SpectorValidationException(ErrorCode.ARGUMENT_OUT_OF_RANGE, "port", 1, 65535, 0);
+                throw new IllegalArgumentException("port must be between 1 and 65535");
             }
             this.port = port;
             return this;
@@ -303,7 +282,7 @@ public Builder apiKey(String apiKey) {
         /** Sets the maximum connection pool size (default: 10). */
         public Builder maxConnections(int maxConnections) {
             if (maxConnections <= 0) {
-                throw new SpectorValidationException(ErrorCode.ARGUMENT_OUT_OF_RANGE, "maxConnections", 1, Integer.MAX_VALUE, 0);
+                throw new IllegalArgumentException("maxConnections must be positive");
             }
             this.maxConnections = maxConnections;
             return this;
@@ -312,7 +291,7 @@ public Builder maxConnections(int maxConnections) {
         /** Sets the connection timeout (default: 5 seconds). */
         public Builder connectTimeout(Duration connectTimeout) {
             if (connectTimeout == null || connectTimeout.isNegative() || connectTimeout.isZero()) {
-                throw new SpectorValidationException(ErrorCode.ARGUMENT_INVALID, "connectTimeout", "must be a positive duration");
+                throw new IllegalArgumentException("connectTimeout must be a positive duration");
             }
             this.connectTimeout = connectTimeout;
             return this;
@@ -321,7 +300,7 @@ public Builder connectTimeout(Duration connectTimeout) {
         /** Sets the per-request timeout (default: 30 seconds). */
         public Builder requestTimeout(Duration requestTimeout) {
             if (requestTimeout == null || requestTimeout.isNegative() || requestTimeout.isZero()) {
-                throw new SpectorValidationException(ErrorCode.ARGUMENT_INVALID, "requestTimeout", "must be a positive duration");
+                throw new IllegalArgumentException("requestTimeout must be a positive duration");
             }
             this.requestTimeout = requestTimeout;
             return this;
diff --git a/spector-client/src/main/java/com/spectrayan/spector/client/SpectorClientException.java b/spector-client/src/main/java/com/spectrayan/spector/client/SpectorClientException.java
index 4e1a8c7..7fc85ce 100644
--- a/spector-client/src/main/java/com/spectrayan/spector/client/SpectorClientException.java
+++ b/spector-client/src/main/java/com/spectrayan/spector/client/SpectorClientException.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.client;
 
 /**
diff --git a/spector-client/src/main/java/com/spectrayan/spector/client/SpectorConnectionException.java b/spector-client/src/main/java/com/spectrayan/spector/client/SpectorConnectionException.java
index af93be4..f5e5af5 100644
--- a/spector-client/src/main/java/com/spectrayan/spector/client/SpectorConnectionException.java
+++ b/spector-client/src/main/java/com/spectrayan/spector/client/SpectorConnectionException.java
@@ -1,22 +1,7 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.client;
 
 /**
- * Thrown when the client cannot connect to the Spector server.
+ * Thrown when the client cannot connect to the Spector Search server.
  */
 public class SpectorConnectionException extends SpectorClientException {
 
@@ -24,7 +9,7 @@ public class SpectorConnectionException extends SpectorClientException {
     private final int port;
 
     public SpectorConnectionException(String host, int port, Throwable cause) {
-        super("Failed to connect to Spector at " + host + ":" + port + ": " + cause.getMessage(), cause);
+        super("Failed to connect to Spector Search at " + host + ":" + port + ": " + cause.getMessage(), cause);
         this.host = host;
         this.port = port;
     }
diff --git a/spector-client/src/main/java/com/spectrayan/spector/client/SpectorHttpException.java b/spector-client/src/main/java/com/spectrayan/spector/client/SpectorHttpException.java
index 2c0a3b6..d47f1bf 100644
--- a/spector-client/src/main/java/com/spectrayan/spector/client/SpectorHttpException.java
+++ b/spector-client/src/main/java/com/spectrayan/spector/client/SpectorHttpException.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.client;
 
 /**
diff --git a/spector-client/src/main/java/com/spectrayan/spector/client/model/BulkIngestRequest.java b/spector-client/src/main/java/com/spectrayan/spector/client/model/BulkIngestRequest.java
index f030722..fb67c1f 100644
--- a/spector-client/src/main/java/com/spectrayan/spector/client/model/BulkIngestRequest.java
+++ b/spector-client/src/main/java/com/spectrayan/spector/client/model/BulkIngestRequest.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.client.model;
 
 import java.util.List;
diff --git a/spector-client/src/main/java/com/spectrayan/spector/client/model/DeleteResponse.java b/spector-client/src/main/java/com/spectrayan/spector/client/model/DeleteResponse.java
index 2763036..ba35616 100644
--- a/spector-client/src/main/java/com/spectrayan/spector/client/model/DeleteResponse.java
+++ b/spector-client/src/main/java/com/spectrayan/spector/client/model/DeleteResponse.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.client.model;
 
 import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
diff --git a/spector-client/src/main/java/com/spectrayan/spector/client/model/IngestRequest.java b/spector-client/src/main/java/com/spectrayan/spector/client/model/IngestRequest.java
index 4d7e636..e5d64c0 100644
--- a/spector-client/src/main/java/com/spectrayan/spector/client/model/IngestRequest.java
+++ b/spector-client/src/main/java/com/spectrayan/spector/client/model/IngestRequest.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.client.model;
 
 import com.fasterxml.jackson.annotation.JsonInclude;
diff --git a/spector-client/src/main/java/com/spectrayan/spector/client/model/IngestResponse.java b/spector-client/src/main/java/com/spectrayan/spector/client/model/IngestResponse.java
index 4b3e267..685d681 100644
--- a/spector-client/src/main/java/com/spectrayan/spector/client/model/IngestResponse.java
+++ b/spector-client/src/main/java/com/spectrayan/spector/client/model/IngestResponse.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.client.model;
 
 import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
diff --git a/spector-client/src/main/java/com/spectrayan/spector/client/model/MetricsResponse.java b/spector-client/src/main/java/com/spectrayan/spector/client/model/MetricsResponse.java
index bb2aba3..f24859a 100644
--- a/spector-client/src/main/java/com/spectrayan/spector/client/model/MetricsResponse.java
+++ b/spector-client/src/main/java/com/spectrayan/spector/client/model/MetricsResponse.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.client.model;
 
 import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
diff --git a/spector-client/src/main/java/com/spectrayan/spector/client/model/SearchRequest.java b/spector-client/src/main/java/com/spectrayan/spector/client/model/SearchRequest.java
index 5761705..d1c92a3 100644
--- a/spector-client/src/main/java/com/spectrayan/spector/client/model/SearchRequest.java
+++ b/spector-client/src/main/java/com/spectrayan/spector/client/model/SearchRequest.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.client.model;
 
 import com.fasterxml.jackson.annotation.JsonInclude;
diff --git a/spector-client/src/main/java/com/spectrayan/spector/client/model/SearchResponse.java b/spector-client/src/main/java/com/spectrayan/spector/client/model/SearchResponse.java
index a133af0..e89a79b 100644
--- a/spector-client/src/main/java/com/spectrayan/spector/client/model/SearchResponse.java
+++ b/spector-client/src/main/java/com/spectrayan/spector/client/model/SearchResponse.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.client.model;
 
 import java.util.List;
diff --git a/spector-client/src/main/java/com/spectrayan/spector/client/model/StatusResponse.java b/spector-client/src/main/java/com/spectrayan/spector/client/model/StatusResponse.java
index ea4d86d..e247033 100644
--- a/spector-client/src/main/java/com/spectrayan/spector/client/model/StatusResponse.java
+++ b/spector-client/src/main/java/com/spectrayan/spector/client/model/StatusResponse.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.client.model;
 
 import java.util.Map;
diff --git a/spector-client/src/test/java/com/spectrayan/spector/client/SpectorClientTest.java b/spector-client/src/test/java/com/spectrayan/spector/client/SpectorClientTest.java
index b3ce196..8002091 100644
--- a/spector-client/src/test/java/com/spectrayan/spector/client/SpectorClientTest.java
+++ b/spector-client/src/test/java/com/spectrayan/spector/client/SpectorClientTest.java
@@ -1,22 +1,5 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.client;
 
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-
 import com.spectrayan.spector.client.model.*;
 import org.junit.jupiter.api.Test;
 
@@ -53,42 +36,42 @@ void builderAcceptsCustomConfiguration() {
     @Test
     void builderRejectsNullHost() {
         assertThatThrownBy(() -> SpectorClient.builder().host(null))
-                .isInstanceOf(SpectorValidationException.class)
+                .isInstanceOf(IllegalArgumentException.class)
                 .hasMessageContaining("host");
     }
 
     @Test
     void builderRejectsBlankHost() {
         assertThatThrownBy(() -> SpectorClient.builder().host("  "))
-                .isInstanceOf(SpectorValidationException.class)
+                .isInstanceOf(IllegalArgumentException.class)
                 .hasMessageContaining("host");
     }
 
     @Test
     void builderRejectsInvalidPort() {
         assertThatThrownBy(() -> SpectorClient.builder().port(0))
-                .isInstanceOf(SpectorValidationException.class)
+                .isInstanceOf(IllegalArgumentException.class)
                 .hasMessageContaining("port");
 
         assertThatThrownBy(() -> SpectorClient.builder().port(70000))
-                .isInstanceOf(SpectorValidationException.class)
+                .isInstanceOf(IllegalArgumentException.class)
                 .hasMessageContaining("port");
     }
 
     @Test
     void builderRejectsNegativeMaxConnections() {
         assertThatThrownBy(() -> SpectorClient.builder().maxConnections(0))
-                .isInstanceOf(SpectorValidationException.class)
+                .isInstanceOf(IllegalArgumentException.class)
                 .hasMessageContaining("maxConnections");
     }
 
     @Test
     void builderRejectsNullTimeout() {
         assertThatThrownBy(() -> SpectorClient.builder().connectTimeout(null))
-                .isInstanceOf(SpectorValidationException.class);
+                .isInstanceOf(IllegalArgumentException.class);
 
         assertThatThrownBy(() -> SpectorClient.builder().requestTimeout(null))
-                .isInstanceOf(SpectorValidationException.class);
+                .isInstanceOf(IllegalArgumentException.class);
     }
 
     @Test
diff --git a/spector-node/pom.xml b/spector-cluster/pom.xml
similarity index 51%
rename from spector-node/pom.xml
rename to spector-cluster/pom.xml
index dd93a51..6d233e3 100644
--- a/spector-node/pom.xml
+++ b/spector-cluster/pom.xml
@@ -6,15 +6,13 @@
 
     <parent>
         <groupId>com.spectrayan</groupId>
-        <artifactId>spector</artifactId>
+        <artifactId>spector-search</artifactId>
         <version>0.1.0-SNAPSHOT</version>
     </parent>
 
-    <artifactId>spector-node</artifactId>
-    <name>Spector Node</name>
-    <description>Unified Spector node — serves HTTP REST, gRPC, MCP-over-SSE,
-        and Prometheus metrics on a single Armeria (Netty) port. Includes distributed
-        cluster coordination (membership, shard routing, replication) for HA deployments.</description>
+    <artifactId>spector-cluster</artifactId>
+    <name>Spector Cluster</name>
+    <description>Distributed search coordination via gRPC with shard-based partitioning.</description>
 
     <properties>
         <grpc.version>1.68.0</grpc.version>
@@ -23,58 +21,25 @@
     </properties>
 
     <dependencies>
-
-        <!-- ── Spector internal modules ── -->
         <dependency>
             <groupId>com.spectrayan</groupId>
             <artifactId>spector-core</artifactId>
         </dependency>
-        <dependency>
-            <groupId>com.spectrayan</groupId>
-            <artifactId>spector-config</artifactId>
-        </dependency>
         <dependency>
             <groupId>com.spectrayan</groupId>
             <artifactId>spector-index</artifactId>
         </dependency>
-        <dependency>
-            <groupId>com.spectrayan</groupId>
-            <artifactId>spector-runtime</artifactId>
-        </dependency>
         <dependency>
             <groupId>com.spectrayan</groupId>
             <artifactId>spector-engine</artifactId>
         </dependency>
-        <dependency>
-            <groupId>com.spectrayan</groupId>
-            <artifactId>spector-rag</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>com.spectrayan</groupId>
-            <artifactId>spector-commons</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>com.spectrayan</groupId>
-            <artifactId>spector-metrics</artifactId>
-        </dependency>
-
-        <!-- MCP (tool definitions, prompts, resources — for SSE transport) -->
-        <dependency>
-            <groupId>com.spectrayan</groupId>
-            <artifactId>spector-mcp</artifactId>
-        </dependency>
 
-        <!-- ── Armeria (HTTP + gRPC on one port, built on Netty) ── -->
-        <dependency>
-            <groupId>com.linecorp.armeria</groupId>
-            <artifactId>armeria</artifactId>
-        </dependency>
+        <!-- gRPC -->
         <dependency>
-            <groupId>com.linecorp.armeria</groupId>
-            <artifactId>armeria-grpc</artifactId>
+            <groupId>io.grpc</groupId>
+            <artifactId>grpc-netty-shaded</artifactId>
+            <version>${grpc.version}</version>
         </dependency>
-
-        <!-- ── gRPC (stubs + protobuf — Armeria provides the transport) ── -->
         <dependency>
             <groupId>io.grpc</groupId>
             <artifactId>grpc-protobuf</artifactId>
@@ -97,25 +62,6 @@
             <artifactId>javax.annotation-api</artifactId>
             <version>1.3.2</version>
         </dependency>
-
-        <!-- ── Micrometer / Prometheus ── -->
-        <dependency>
-            <groupId>io.micrometer</groupId>
-            <artifactId>micrometer-registry-prometheus</artifactId>
-        </dependency>
-
-        <!-- ── JSON serialization (Jackson 2.x — used by Armeria) ── -->
-        <dependency>
-            <groupId>com.fasterxml.jackson.core</groupId>
-            <artifactId>jackson-databind</artifactId>
-        </dependency>
-
-        <!-- ── Logging runtime ── -->
-        <dependency>
-            <groupId>ch.qos.logback</groupId>
-            <artifactId>logback-classic</artifactId>
-            <scope>runtime</scope>
-        </dependency>
     </dependencies>
 
     <build>
@@ -127,7 +73,6 @@
             </extension>
         </extensions>
         <plugins>
-            <!-- Protobuf + gRPC code generation -->
             <plugin>
                 <groupId>org.xolstice.maven.plugins</groupId>
                 <artifactId>protobuf-maven-plugin</artifactId>
@@ -146,17 +91,6 @@
                     </execution>
                 </executions>
             </plugin>
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-jar-plugin</artifactId>
-                <configuration>
-                    <archive>
-                        <manifest>
-                            <mainClass>com.spectrayan.spector.node.SpectorNode</mainClass>
-                        </manifest>
-                    </archive>
-                </configuration>
-            </plugin>
         </plugins>
     </build>
 
diff --git a/spector-node/src/main/java/com/spectrayan/spector/cluster/ClusterConfig.java b/spector-cluster/src/main/java/com/spectrayan/spector/cluster/ClusterConfig.java
similarity index 78%
rename from spector-node/src/main/java/com/spectrayan/spector/cluster/ClusterConfig.java
rename to spector-cluster/src/main/java/com/spectrayan/spector/cluster/ClusterConfig.java
index c7536f5..8d88059 100644
--- a/spector-node/src/main/java/com/spectrayan/spector/cluster/ClusterConfig.java
+++ b/spector-cluster/src/main/java/com/spectrayan/spector/cluster/ClusterConfig.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.cluster;
 
 import java.util.List;
diff --git a/spector-node/src/main/java/com/spectrayan/spector/cluster/ClusterCoordinator.java b/spector-cluster/src/main/java/com/spectrayan/spector/cluster/ClusterCoordinator.java
similarity index 61%
rename from spector-node/src/main/java/com/spectrayan/spector/cluster/ClusterCoordinator.java
rename to spector-cluster/src/main/java/com/spectrayan/spector/cluster/ClusterCoordinator.java
index f4e840b..798284a 100644
--- a/spector-node/src/main/java/com/spectrayan/spector/cluster/ClusterCoordinator.java
+++ b/spector-cluster/src/main/java/com/spectrayan/spector/cluster/ClusterCoordinator.java
@@ -1,29 +1,12 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.cluster;
 
-import com.spectrayan.spector.commons.concurrent.ConcurrentExecutionException;
-import com.spectrayan.spector.commons.concurrent.ConcurrentTasks;
 import com.spectrayan.spector.index.ScoredResult;
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import java.util.*;
-import java.util.concurrent.Callable;
+import java.util.concurrent.*;
 
 /**
  * Coordinator node for distributed Spector search.
@@ -37,13 +20,6 @@
  *   Client → Coordinator → [Shard 1, Shard 2, ..., Shard N] → Merge → Client
  * </pre>
  *
- * <h3>Concurrency</h3>
- * <p>Uses {@link ConcurrentTasks#forkJoinAll} for parallel shard fan-out.
- * In structured concurrency mode (JEP 505), if any shard fails, all other
- * shard queries are automatically cancelled — preventing thread leaks.
- * Falls back to classic virtual-thread executor when structured concurrency
- * is disabled via {@code -Dspector.concurrency.structured=false}.</p>
- *
  * <h3>Search Flow</h3>
  * <ol>
  *   <li>Fan out the query to all shards in parallel</li>
@@ -63,6 +39,7 @@ public class ClusterCoordinator implements AutoCloseable {
 
     private final ClusterConfig config;
     private final List<RemoteShardClient> shardClients;
+    private final ExecutorService executor;
 
     /**
      * Creates a cluster coordinator.
@@ -72,14 +49,14 @@ public class ClusterCoordinator implements AutoCloseable {
     public ClusterCoordinator(ClusterConfig config) {
         this.config = config;
         this.shardClients = new ArrayList<>();
+        this.executor = Executors.newVirtualThreadPerTaskExecutor();
 
         // Create gRPC clients for each shard
         for (var node : config.nodes()) {
             shardClients.add(new RemoteShardClient(node));
         }
 
-        log.info("ClusterCoordinator initialized: {} shards, structuredConcurrency={}",
-                config.shardCount(), ConcurrentTasks.isStructuredConcurrencyEnabled());
+        log.info("ClusterCoordinator initialized: {} shards", config.shardCount());
     }
 
     /**
@@ -92,11 +69,14 @@ public ClusterCoordinator(ClusterConfig config) {
     public ScoredResult[] vectorSearch(float[] queryVector, int topK) {
         long startTime = System.nanoTime();
 
-        ScoredResult[] merged = fanOutAndMerge(
-                shardClients.stream()
-                        .map(client -> (Callable<ScoredResult[]>) () -> client.vectorSearch(queryVector, topK))
-                        .toList(),
-                topK);
+        // Fan out to all shards in parallel
+        List<Future<ScoredResult[]>> futures = new ArrayList<>();
+        for (var client : shardClients) {
+            futures.add(executor.submit(() -> client.vectorSearch(queryVector, topK)));
+        }
+
+        // Collect and merge results
+        ScoredResult[] merged = collectAndMerge(futures, topK);
 
         long elapsed = (System.nanoTime() - startTime) / 1_000_000;
         log.debug("Distributed vector search: {} shards, {} results, {}ms",
@@ -115,11 +95,12 @@ public ScoredResult[] vectorSearch(float[] queryVector, int topK) {
     public ScoredResult[] keywordSearch(String queryText, int topK) {
         long startTime = System.nanoTime();
 
-        ScoredResult[] merged = fanOutAndMerge(
-                shardClients.stream()
-                        .map(client -> (Callable<ScoredResult[]>) () -> client.keywordSearch(queryText, topK))
-                        .toList(),
-                topK);
+        List<Future<ScoredResult[]>> futures = new ArrayList<>();
+        for (var client : shardClients) {
+            futures.add(executor.submit(() -> client.keywordSearch(queryText, topK)));
+        }
+
+        ScoredResult[] merged = collectAndMerge(futures, topK);
 
         long elapsed = (System.nanoTime() - startTime) / 1_000_000;
         log.debug("Distributed keyword search: {} shards, {} results, {}ms",
@@ -139,11 +120,12 @@ public ScoredResult[] keywordSearch(String queryText, int topK) {
     public ScoredResult[] hybridSearch(String queryText, float[] queryVector, int topK) {
         long startTime = System.nanoTime();
 
-        ScoredResult[] merged = fanOutAndMerge(
-                shardClients.stream()
-                        .map(client -> (Callable<ScoredResult[]>) () -> client.hybridSearch(queryText, queryVector, topK))
-                        .toList(),
-                topK);
+        List<Future<ScoredResult[]>> futures = new ArrayList<>();
+        for (var client : shardClients) {
+            futures.add(executor.submit(() -> client.hybridSearch(queryText, queryVector, topK)));
+        }
+
+        ScoredResult[] merged = collectAndMerge(futures, topK);
 
         long elapsed = (System.nanoTime() - startTime) / 1_000_000;
         log.debug("Distributed hybrid search: {} shards, {} results, {}ms",
@@ -191,41 +173,34 @@ public void close() {
         for (var client : shardClients) {
             client.close();
         }
+        executor.close();
         log.info("ClusterCoordinator closed");
     }
 
-    // ─────────────── Core Fan-Out ───────────────
-
-    /**
-     * Fans out tasks in parallel using {@link ConcurrentTasks}, collects all results,
-     * and merges into global top-K.
-     */
-    private ScoredResult[] fanOutAndMerge(List<Callable<ScoredResult[]>> tasks, int topK) {
-        try {
-            List<ScoredResult[]> shardResults = ConcurrentTasks.forkJoinAll(tasks);
-            return mergeResults(shardResults, topK);
-        } catch (ConcurrentExecutionException e) {
-            log.warn("Shard search failed: {}", e.getCause().getMessage());
-            return new ScoredResult[0];
-        } catch (InterruptedException e) {
-            Thread.currentThread().interrupt();
-            log.warn("Distributed search interrupted");
-            return new ScoredResult[0];
-        }
-    }
-
     // ─────────────── Result merging ───────────────
 
     /**
-     * Merges results from all shards into global top-K.
-     * Sorts by score descending and takes top-K.
+     * Collects results from all shard futures and merges into global top-K.
+     * Uses a min-heap to efficiently track the K best results across all shards.
      */
-    private ScoredResult[] mergeResults(List<ScoredResult[]> shardResults, int topK) {
+    private ScoredResult[] collectAndMerge(List<Future<ScoredResult[]>> futures, int topK) {
+        // Collect all results
         List<ScoredResult> allResults = new ArrayList<>();
-        for (ScoredResult[] results : shardResults) {
-            allResults.addAll(Arrays.asList(results));
+        for (var future : futures) {
+            try {
+                ScoredResult[] shardResults = future.get(10, TimeUnit.SECONDS);
+                allResults.addAll(Arrays.asList(shardResults));
+            } catch (TimeoutException e) {
+                log.warn("Shard timed out");
+            } catch (InterruptedException e) {
+                Thread.currentThread().interrupt();
+                log.warn("Merge interrupted");
+            } catch (ExecutionException e) {
+                log.warn("Shard search failed: {}", e.getCause().getMessage());
+            }
         }
 
+        // Sort by score descending and take top-K
         allResults.sort(Comparator.naturalOrder()); // ScoredResult is Comparable (descending)
         int count = Math.min(topK, allResults.size());
         return allResults.subList(0, count).toArray(ScoredResult[]::new);
diff --git a/spector-node/src/main/java/com/spectrayan/spector/cluster/ClusterTopology.java b/spector-cluster/src/main/java/com/spectrayan/spector/cluster/ClusterTopology.java
similarity index 59%
rename from spector-node/src/main/java/com/spectrayan/spector/cluster/ClusterTopology.java
rename to spector-cluster/src/main/java/com/spectrayan/spector/cluster/ClusterTopology.java
index f4577af..4804782 100644
--- a/spector-node/src/main/java/com/spectrayan/spector/cluster/ClusterTopology.java
+++ b/spector-cluster/src/main/java/com/spectrayan/spector/cluster/ClusterTopology.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.cluster;
 
 import java.util.Collections;
diff --git a/spector-node/src/main/java/com/spectrayan/spector/cluster/ConsistentHashShardManager.java b/spector-cluster/src/main/java/com/spectrayan/spector/cluster/ConsistentHashShardManager.java
similarity index 87%
rename from spector-node/src/main/java/com/spectrayan/spector/cluster/ConsistentHashShardManager.java
rename to spector-cluster/src/main/java/com/spectrayan/spector/cluster/ConsistentHashShardManager.java
index 1c1ddee..3daffab 100644
--- a/spector-node/src/main/java/com/spectrayan/spector/cluster/ConsistentHashShardManager.java
+++ b/spector-cluster/src/main/java/com/spectrayan/spector/cluster/ConsistentHashShardManager.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.cluster;
 
 import java.nio.charset.StandardCharsets;
@@ -29,9 +14,6 @@
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-import com.spectrayan.spector.commons.error.SpectorInternalException;
-import com.spectrayan.spector.commons.error.ErrorCode;
 
 /**
  * Consistent hash ring-based shard manager for distributed document assignment.
@@ -88,7 +70,7 @@ public class ConsistentHashShardManager implements ShardManager {
      * Creates a ConsistentHashShardManager with the specified shard count.
      *
      * @param shardCount the total number of shards (2–256)
-     * @throws SpectorValidationException if shardCount is outside the valid range
+     * @throws IllegalArgumentException if shardCount is outside the valid range
      */
     public ConsistentHashShardManager(int shardCount) {
         this(shardCount, DEFAULT_VIRTUAL_NODES);
@@ -99,14 +81,16 @@ public ConsistentHashShardManager(int shardCount) {
      *
      * @param shardCount          the total number of shards (2–256)
      * @param virtualNodesPerShard number of virtual nodes per physical shard
-     * @throws SpectorValidationException if shardCount is outside the valid range
+     * @throws IllegalArgumentException if shardCount is outside the valid range
      */
     public ConsistentHashShardManager(int shardCount, int virtualNodesPerShard) {
         if (shardCount < MIN_SHARD_COUNT || shardCount > MAX_SHARD_COUNT) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_OUT_OF_RANGE, "shardCount", MIN_SHARD_COUNT, MAX_SHARD_COUNT, shardCount);
+            throw new IllegalArgumentException(
+                    "Shard count must be between " + MIN_SHARD_COUNT + " and " + MAX_SHARD_COUNT
+                            + ", got: " + shardCount);
         }
         if (virtualNodesPerShard < 1) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_OUT_OF_RANGE, "virtualNodesPerShard", 1, Integer.MAX_VALUE, 0);
+            throw new IllegalArgumentException("Virtual nodes per shard must be at least 1");
         }
 
         this.shardCount = shardCount;
@@ -125,7 +109,7 @@ public ConsistentHashShardManager(int shardCount, int virtualNodesPerShard) {
     @Override
     public int assignShard(String documentId) {
         if (documentId == null || documentId.isEmpty()) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_NULL, "Document ID");
+            throw new IllegalArgumentException("Document ID must not be null or empty");
         }
 
         long hash = hash(documentId);
@@ -133,7 +117,7 @@ public int assignShard(String documentId) {
         ringLock.readLock().lock();
         try {
             if (hashRing.isEmpty()) {
-                throw new SpectorInternalException(ErrorCode.EMPTY_COLLECTION, "shards");
+                throw new IllegalStateException("No shards registered in the hash ring");
             }
 
             // Find the first virtual node at or after the hash position
@@ -151,10 +135,11 @@ public int assignShard(String documentId) {
     @Override
     public void addShard(int shardIndex, String nodeEndpoint) {
         if (shardIndex < 0 || shardIndex >= shardCount) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_INVALID, "Shard index must be between 0 and " + (shardCount - 1) + ", got: " + shardIndex);
+            throw new IllegalArgumentException(
+                    "Shard index must be between 0 and " + (shardCount - 1) + ", got: " + shardIndex);
         }
         if (nodeEndpoint == null || nodeEndpoint.isBlank()) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_NULL, "Node endpoint");
+            throw new IllegalArgumentException("Node endpoint must not be null or blank");
         }
 
         ringLock.writeLock().lock();
@@ -302,7 +287,7 @@ public void setRebalanceListener(RebalanceListener listener) {
      */
     public int assignShardExcluding(String documentId, int excludeShard) {
         if (documentId == null || documentId.isEmpty()) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_NULL, "Document ID");
+            throw new IllegalArgumentException("Document ID must not be null or empty");
         }
 
         long hash = hash(documentId);
@@ -334,7 +319,7 @@ public int assignShardExcluding(String documentId, int excludeShard) {
 
                 if (wrapped && position.equals(startPosition)) {
                     // All nodes belong to excluded shard — shouldn't happen
-                    throw new SpectorInternalException(ErrorCode.EMPTY_COLLECTION, "shards");
+                    throw new IllegalStateException("No available shards after exclusion");
                 }
             }
         } finally {
@@ -397,4 +382,4 @@ public interface RebalanceListener {
          */
         void onRebalance(ConsistentHashShardManager shardManager, Set<Integer> pausedShards);
     }
-}
\ No newline at end of file
+}
diff --git a/spector-node/src/main/java/com/spectrayan/spector/cluster/DistributedQueryCoordinator.java b/spector-cluster/src/main/java/com/spectrayan/spector/cluster/DistributedQueryCoordinator.java
similarity index 58%
rename from spector-node/src/main/java/com/spectrayan/spector/cluster/DistributedQueryCoordinator.java
rename to spector-cluster/src/main/java/com/spectrayan/spector/cluster/DistributedQueryCoordinator.java
index 596fb7a..d0c6a10 100644
--- a/spector-node/src/main/java/com/spectrayan/spector/cluster/DistributedQueryCoordinator.java
+++ b/spector-cluster/src/main/java/com/spectrayan/spector/cluster/DistributedQueryCoordinator.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.cluster;
 
 import java.time.Duration;
@@ -24,17 +9,17 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
-import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import com.spectrayan.spector.commons.concurrent.ConcurrentTasks;
-import com.spectrayan.spector.commons.concurrent.ConcurrentTasks.LabeledTask;
-import com.spectrayan.spector.commons.concurrent.ConcurrentTasks.PartialResult;
 import com.spectrayan.spector.index.ScoredResult;
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-import com.spectrayan.spector.commons.error.ErrorCode;
 
 /**
  * Distributed query coordinator that fans out search queries to all shards
@@ -48,12 +33,6 @@
  *   <li>Returns empty result with error when all shards are unreachable</li>
  * </ul>
  *
- * <h3>Concurrency</h3>
- * <p>Uses {@link ConcurrentTasks#forkJoinPartial} for deadline-based fan-out.
- * In structured concurrency mode (JEP 505), uses {@code awaitAll()} joiner with
- * {@code Configuration.withTimeout()} for clean timeout handling. Falls back to
- * classic virtual-thread executor with per-future timeouts when disabled.</p>
- *
  * <h3>Timeout</h3>
  * <p>Configurable between 1 and 60 seconds (default: 10 seconds).</p>
  */
@@ -72,6 +51,7 @@ public class DistributedQueryCoordinator implements AutoCloseable {
 
     private final List<ShardEndpoint> shardEndpoints;
     private final Duration timeout;
+    private final ExecutorService executor;
 
     /**
      * Creates a coordinator with default timeout (10s).
@@ -87,19 +67,22 @@ public DistributedQueryCoordinator(List<ShardEndpoint> shardEndpoints) {
      *
      * @param shardEndpoints the shard endpoints to fan out queries to
      * @param timeout        per-shard timeout (must be between 1s and 60s)
-     * @throws SpectorValidationException if timeout is outside the allowed range
+     * @throws IllegalArgumentException if timeout is outside the allowed range
      */
     public DistributedQueryCoordinator(List<ShardEndpoint> shardEndpoints, Duration timeout) {
-        if (shardEndpoints == null) { throw new SpectorValidationException(ErrorCode.ARGUMENT_NULL, "shardEndpoints"); }
-        if (timeout == null) { throw new SpectorValidationException(ErrorCode.ARGUMENT_NULL, "timeout"); }
+        Objects.requireNonNull(shardEndpoints, "shardEndpoints must not be null");
+        Objects.requireNonNull(timeout, "timeout must not be null");
 
         long timeoutSeconds = timeout.toSeconds();
         if (timeoutSeconds < MIN_TIMEOUT_SECONDS || timeoutSeconds > MAX_TIMEOUT_SECONDS) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_OUT_OF_RANGE, "Timeout", MIN_TIMEOUT_SECONDS, MAX_TIMEOUT_SECONDS, timeoutSeconds);
+            throw new IllegalArgumentException(
+                    "Timeout must be between " + MIN_TIMEOUT_SECONDS + " and " + MAX_TIMEOUT_SECONDS
+                            + " seconds, got: " + timeoutSeconds);
         }
 
         this.shardEndpoints = List.copyOf(shardEndpoints);
         this.timeout = timeout;
+        this.executor = Executors.newVirtualThreadPerTaskExecutor();
     }
 
     /**
@@ -110,7 +93,7 @@ public DistributedQueryCoordinator(List<ShardEndpoint> shardEndpoints, Duration
      * @return merged query result with metadata about timed-out shards
      */
     public QueryResult fanOutVectorSearch(float[] queryVector, int topK) {
-        if (queryVector == null) { throw new SpectorValidationException(ErrorCode.ARGUMENT_NULL, "queryVector"); }
+        Objects.requireNonNull(queryVector, "queryVector must not be null");
         validateTopK(topK);
 
         return fanOut(shardEndpoints, client -> client.vectorSearch(queryVector, topK), topK);
@@ -124,7 +107,7 @@ public QueryResult fanOutVectorSearch(float[] queryVector, int topK) {
      * @return merged query result with metadata about timed-out shards
      */
     public QueryResult fanOutKeywordSearch(String queryText, int topK) {
-        if (queryText == null) { throw new SpectorValidationException(ErrorCode.ARGUMENT_NULL, "queryText"); }
+        Objects.requireNonNull(queryText, "queryText must not be null");
         validateTopK(topK);
 
         return fanOut(shardEndpoints, client -> client.keywordSearch(queryText, topK), topK);
@@ -139,8 +122,8 @@ public QueryResult fanOutKeywordSearch(String queryText, int topK) {
      * @return merged query result with metadata about timed-out shards
      */
     public QueryResult fanOutHybridSearch(String queryText, float[] queryVector, int topK) {
-        if (queryText == null) { throw new SpectorValidationException(ErrorCode.ARGUMENT_NULL, "queryText"); }
-        if (queryVector == null) { throw new SpectorValidationException(ErrorCode.ARGUMENT_NULL, "queryVector"); }
+        Objects.requireNonNull(queryText, "queryText must not be null");
+        Objects.requireNonNull(queryVector, "queryVector must not be null");
         validateTopK(topK);
 
         return fanOut(shardEndpoints, client -> client.hybridSearch(queryText, queryVector, topK), topK);
@@ -155,16 +138,15 @@ public Duration getTimeout() {
 
     @Override
     public void close() {
-        // No executor to close — ConcurrentTasks manages scope per-call
+        executor.close();
         log.info("DistributedQueryCoordinator closed");
     }
 
     // ─────────────── Core Fan-Out Logic ───────────────
 
     /**
-     * Generic fan-out that issues requests in parallel via {@link ConcurrentTasks#forkJoinPartial},
-     * collects results with timeout, merges by descending score with deduplication,
-     * and returns appropriate result type.
+     * Generic fan-out that issues requests in parallel, collects results with timeout,
+     * merges by descending score with deduplication, and returns appropriate result type.
      */
     private QueryResult fanOut(List<ShardEndpoint> shards,
                                ShardSearchFunction searchFn,
@@ -173,55 +155,60 @@ private QueryResult fanOut(List<ShardEndpoint> shards,
             return QueryResult.allShardsUnreachable(List.of());
         }
 
-        // Build labeled tasks for each shard
-        List<LabeledTask<ScoredResult[]>> tasks = shards.stream()
-                .map(shard -> new LabeledTask<>(shard.shardId(),
-                        (Callable<ScoredResult[]>) () -> {
-                            try (RemoteShardClient client = new RemoteShardClient(shard.toNodeEndpoint())) {
-                                return searchFn.search(client);
-                            }
-                        }))
-                .toList();
-
-        try {
-            PartialResult<ScoredResult[]> partial = ConcurrentTasks.forkJoinPartial(tasks, timeout);
-
-            // Log timeouts and failures
-            for (String shardId : partial.timedOut()) {
-                log.warn("Shard '{}' timed out after {}s", shardId, timeout.toSeconds());
-            }
-            for (PartialResult.Failure failure : partial.failures()) {
-                log.warn("Shard '{}' failed: {}", failure.label(), failure.cause().getMessage());
-            }
-
-            // All shards unreachable
-            if (partial.allFailed()) {
-                return QueryResult.allShardsUnreachable(partial.unreachableLabels());
-            }
+        // Submit all shard requests in parallel
+        Map<String, Future<ScoredResult[]>> futuresByShardId = new LinkedHashMap<>();
+        for (ShardEndpoint shard : shards) {
+            Future<ScoredResult[]> future = executor.submit(() -> {
+                try (RemoteShardClient client = new RemoteShardClient(shard.toNodeEndpoint())) {
+                    return searchFn.search(client);
+                }
+            });
+            futuresByShardId.put(shard.shardId(), future);
+        }
 
-            // Collect successful results
-            List<ScoredResult> allResults = new ArrayList<>();
-            for (PartialResult.Entry<ScoredResult[]> entry : partial.successes()) {
-                if (entry.result() != null) {
-                    allResults.addAll(Arrays.asList(entry.result()));
+        // Collect results with timeout
+        List<ScoredResult> allResults = new ArrayList<>();
+        List<String> timedOutShards = new ArrayList<>();
+        List<String> failedShards = new ArrayList<>();
+
+        for (var entry : futuresByShardId.entrySet()) {
+            String shardId = entry.getKey();
+            Future<ScoredResult[]> future = entry.getValue();
+            try {
+                ScoredResult[] shardResults = future.get(timeout.toMillis(), TimeUnit.MILLISECONDS);
+                if (shardResults != null) {
+                    allResults.addAll(Arrays.asList(shardResults));
                 }
+            } catch (TimeoutException e) {
+                timedOutShards.add(shardId);
+                future.cancel(true);
+                log.warn("Shard '{}' timed out after {}s", shardId, timeout.toSeconds());
+            } catch (InterruptedException e) {
+                Thread.currentThread().interrupt();
+                failedShards.add(shardId);
+                log.warn("Interrupted waiting for shard '{}'", shardId);
+            } catch (ExecutionException e) {
+                failedShards.add(shardId);
+                log.warn("Shard '{}' failed: {}", shardId, e.getCause().getMessage());
             }
+        }
 
-            // Merge and deduplicate
-            List<ScoredResult> merged = mergeAndDeduplicate(allResults, topK);
+        // All shards unreachable
+        List<String> unreachableShards = new ArrayList<>(timedOutShards);
+        unreachableShards.addAll(failedShards);
+        if (unreachableShards.size() == shards.size()) {
+            return QueryResult.allShardsUnreachable(unreachableShards);
+        }
 
-            // Return partial or complete
-            if (!partial.timedOut().isEmpty()) {
-                return QueryResult.partial(merged, partial.timedOut());
-            }
-            return QueryResult.complete(merged);
+        // Merge and deduplicate
+        List<ScoredResult> merged = mergeAndDeduplicate(allResults, topK);
 
-        } catch (InterruptedException e) {
-            Thread.currentThread().interrupt();
-            log.warn("Distributed query interrupted");
-            return QueryResult.allShardsUnreachable(
-                    shards.stream().map(ShardEndpoint::shardId).toList());
+        // Return partial or complete
+        if (!timedOutShards.isEmpty()) {
+            return QueryResult.partial(merged, timedOutShards);
         }
+
+        return QueryResult.complete(merged);
     }
 
     // ─────────────── Merge and Deduplication ───────────────
@@ -246,7 +233,7 @@ static List<ScoredResult> mergeAndDeduplicate(List<ScoredResult> results, int to
                     incoming.score() > existing.score() ? incoming : existing);
         }
 
-        // Sort by score descending and take top-K
+        // Sort by descending score and take top-K
         List<ScoredResult> merged = new ArrayList<>(bestByDocId.values());
         merged.sort(Comparator.naturalOrder()); // ScoredResult.compareTo is descending
         if (merged.size() > topK) {
@@ -259,7 +246,7 @@ static List<ScoredResult> mergeAndDeduplicate(List<ScoredResult> results, int to
 
     private static void validateTopK(int topK) {
         if (topK < 1 || topK > 10_000) {
-            throw new SpectorValidationException(ErrorCode.TOP_K_INVALID, 1, topK);
+            throw new IllegalArgumentException("topK must be between 1 and 10,000, got: " + topK);
         }
     }
 
@@ -283,10 +270,10 @@ interface ShardSearchFunction {
     public record ShardEndpoint(String shardId, String host, int port) {
 
         public ShardEndpoint {
-            if (shardId == null) { throw new SpectorValidationException(ErrorCode.ARGUMENT_NULL, "shardId"); }
-            if (host == null) { throw new SpectorValidationException(ErrorCode.ARGUMENT_NULL, "host"); }
+            Objects.requireNonNull(shardId, "shardId must not be null");
+            Objects.requireNonNull(host, "host must not be null");
             if (port <= 0 || port > 65535) {
-                throw new SpectorValidationException(ErrorCode.ARGUMENT_OUT_OF_RANGE, "port", 1, 65535, port);
+                throw new IllegalArgumentException("port must be between 1 and 65535, got: " + port);
             }
         }
 
diff --git a/spector-node/src/main/java/com/spectrayan/spector/cluster/HeartbeatMembershipService.java b/spector-cluster/src/main/java/com/spectrayan/spector/cluster/HeartbeatMembershipService.java
similarity index 88%
rename from spector-node/src/main/java/com/spectrayan/spector/cluster/HeartbeatMembershipService.java
rename to spector-cluster/src/main/java/com/spectrayan/spector/cluster/HeartbeatMembershipService.java
index 4f46436..9f3c729 100644
--- a/spector-node/src/main/java/com/spectrayan/spector/cluster/HeartbeatMembershipService.java
+++ b/spector-cluster/src/main/java/com/spectrayan/spector/cluster/HeartbeatMembershipService.java
@@ -1,22 +1,5 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.cluster;
 
-import com.spectrayan.spector.cluster.error.SpectorMembershipException;
-
 import java.time.Duration;
 import java.time.Instant;
 import java.util.ArrayList;
@@ -35,8 +18,6 @@
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-import com.spectrayan.spector.commons.error.ErrorCode;
 
 /**
  * Heartbeat-based cluster membership service.
@@ -121,11 +102,11 @@ public HeartbeatMembershipService(ShardManager shardManager) {
      * @param shardManager      the shard manager for rebalancing
      * @param heartbeatInterval interval between heartbeat checks (500ms–30s)
      * @param failureTimeout    time after which a non-responding node is marked unavailable (3s–120s)
-     * @throws SpectorValidationException if intervals are outside valid ranges
+     * @throws IllegalArgumentException if intervals are outside valid ranges
      */
     public HeartbeatMembershipService(ShardManager shardManager, Duration heartbeatInterval, Duration failureTimeout) {
         if (shardManager == null) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_NULL, "ShardManager");
+            throw new IllegalArgumentException("ShardManager must not be null");
         }
         validateHeartbeatInterval(heartbeatInterval);
         validateFailureTimeout(failureTimeout);
@@ -167,10 +148,10 @@ public void start() {
     @Override
     public void registerNode(String nodeId, String endpoint) {
         if (nodeId == null || nodeId.isBlank()) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_NULL, "Node ID");
+            throw new IllegalArgumentException("Node ID must not be null or blank");
         }
         if (endpoint == null || endpoint.isBlank()) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_NULL, "Endpoint");
+            throw new IllegalArgumentException("Endpoint must not be null or blank");
         }
 
         int attempts = 0;
@@ -193,14 +174,14 @@ public void registerNode(String nodeId, String endpoint) {
                         Thread.sleep(REGISTRATION_RETRY_DELAY.toMillis());
                     } catch (InterruptedException ie) {
                         Thread.currentThread().interrupt();
-                        throw new SpectorMembershipException(
+                        throw new MembershipException(
                                 "Registration interrupted for node '" + nodeId + "'", ie);
                     }
                 }
             }
         }
 
-        throw new SpectorMembershipException(
+        throw new MembershipException(
                 "Failed to register node '" + nodeId + "' after " + MAX_REGISTRATION_RETRIES
                         + " attempts", lastException);
     }
@@ -208,13 +189,13 @@ public void registerNode(String nodeId, String endpoint) {
     @Override
     public void markUnavailable(String nodeId) {
         if (nodeId == null || nodeId.isBlank()) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_NULL, "Node ID");
+            throw new IllegalArgumentException("Node ID must not be null or blank");
         }
 
         synchronized (membershipLock) {
             NodeInfo info = nodes.get(nodeId);
             if (info == null) {
-                throw new SpectorValidationException(ErrorCode.ARGUMENT_INVALID, "nodeId", nodeId);
+                throw new IllegalArgumentException("Node '" + nodeId + "' not found in cluster");
             }
 
             if (info.status() == NodeStatus.UNAVAILABLE) {
@@ -472,21 +453,27 @@ private void notifyListeners(String nodeId, NodeStatus newStatus) {
 
     private static void validateHeartbeatInterval(Duration interval) {
         if (interval == null) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_NULL, "Heartbeat interval");
+            throw new IllegalArgumentException("Heartbeat interval must not be null");
         }
         if (interval.compareTo(MIN_HEARTBEAT_INTERVAL) < 0
                 || interval.compareTo(MAX_HEARTBEAT_INTERVAL) > 0) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_OUT_OF_RANGE, "Heartbeat interval must be between " + MIN_HEARTBEAT_INTERVAL.toMillis() + "ms and " + MAX_HEARTBEAT_INTERVAL.toSeconds() + "s, got: " + interval.toMillis() + "ms");
+            throw new IllegalArgumentException(
+                    "Heartbeat interval must be between " + MIN_HEARTBEAT_INTERVAL.toMillis()
+                            + "ms and " + MAX_HEARTBEAT_INTERVAL.toSeconds() + "s, got: "
+                            + interval.toMillis() + "ms");
         }
     }
 
     private static void validateFailureTimeout(Duration timeout) {
         if (timeout == null) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_NULL, "Failure timeout");
+            throw new IllegalArgumentException("Failure timeout must not be null");
         }
         if (timeout.compareTo(MIN_FAILURE_TIMEOUT) < 0
                 || timeout.compareTo(MAX_FAILURE_TIMEOUT) > 0) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_OUT_OF_RANGE, "Failure timeout must be between " + MIN_FAILURE_TIMEOUT.toSeconds() + "s and " + MAX_FAILURE_TIMEOUT.toSeconds() + "s, got: " + timeout.toMillis() + "ms");
+            throw new IllegalArgumentException(
+                    "Failure timeout must be between " + MIN_FAILURE_TIMEOUT.toSeconds()
+                            + "s and " + MAX_FAILURE_TIMEOUT.toSeconds() + "s, got: "
+                            + timeout.toMillis() + "ms");
         }
     }
 
@@ -510,4 +497,4 @@ public interface MembershipChangeListener {
          */
         void onMembershipChange(String nodeId, NodeStatus newStatus);
     }
-}
\ No newline at end of file
+}
diff --git a/spector-cluster/src/main/java/com/spectrayan/spector/cluster/MembershipException.java b/spector-cluster/src/main/java/com/spectrayan/spector/cluster/MembershipException.java
new file mode 100644
index 0000000..ad97190
--- /dev/null
+++ b/spector-cluster/src/main/java/com/spectrayan/spector/cluster/MembershipException.java
@@ -0,0 +1,15 @@
+package com.spectrayan.spector.cluster;
+
+/**
+ * Exception thrown when a membership operation fails.
+ */
+public class MembershipException extends RuntimeException {
+
+    public MembershipException(String message) {
+        super(message);
+    }
+
+    public MembershipException(String message, Throwable cause) {
+        super(message, cause);
+    }
+}
diff --git a/spector-node/src/main/java/com/spectrayan/spector/cluster/MembershipService.java b/spector-cluster/src/main/java/com/spectrayan/spector/cluster/MembershipService.java
similarity index 67%
rename from spector-node/src/main/java/com/spectrayan/spector/cluster/MembershipService.java
rename to spector-cluster/src/main/java/com/spectrayan/spector/cluster/MembershipService.java
index de613da..269f527 100644
--- a/spector-node/src/main/java/com/spectrayan/spector/cluster/MembershipService.java
+++ b/spector-cluster/src/main/java/com/spectrayan/spector/cluster/MembershipService.java
@@ -1,22 +1,5 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.cluster;
 
-import com.spectrayan.spector.cluster.error.SpectorMembershipException;
-
 import java.util.Set;
 
 /**
@@ -41,8 +24,8 @@ public interface MembershipService extends AutoCloseable {
      *
      * @param nodeId   unique identifier for the node
      * @param endpoint network endpoint (host:port) for the node
-     * @throws SpectorValidationException if nodeId or endpoint is null or blank
-     * @throws SpectorMembershipException      if registration fails after all retry attempts
+     * @throws IllegalArgumentException if nodeId or endpoint is null or blank
+     * @throws MembershipException      if registration fails after all retry attempts
      */
     void registerNode(String nodeId, String endpoint);
 
@@ -52,7 +35,7 @@ public interface MembershipService extends AutoCloseable {
      * <p>Triggers shard rebalancing within 5 seconds of the status change.</p>
      *
      * @param nodeId the node to mark as unavailable
-     * @throws SpectorValidationException if nodeId is null, blank, or not found in the cluster
+     * @throws IllegalArgumentException if nodeId is null, blank, or not found in the cluster
      */
     void markUnavailable(String nodeId);
 
diff --git a/spector-node/src/main/java/com/spectrayan/spector/cluster/NodeInfo.java b/spector-cluster/src/main/java/com/spectrayan/spector/cluster/NodeInfo.java
similarity index 65%
rename from spector-node/src/main/java/com/spectrayan/spector/cluster/NodeInfo.java
rename to spector-cluster/src/main/java/com/spectrayan/spector/cluster/NodeInfo.java
index 1333684..b67b5e7 100644
--- a/spector-node/src/main/java/com/spectrayan/spector/cluster/NodeInfo.java
+++ b/spector-cluster/src/main/java/com/spectrayan/spector/cluster/NodeInfo.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.cluster;
 
 import java.time.Instant;
diff --git a/spector-cluster/src/main/java/com/spectrayan/spector/cluster/NodeStatus.java b/spector-cluster/src/main/java/com/spectrayan/spector/cluster/NodeStatus.java
new file mode 100644
index 0000000..09e8389
--- /dev/null
+++ b/spector-cluster/src/main/java/com/spectrayan/spector/cluster/NodeStatus.java
@@ -0,0 +1,13 @@
+package com.spectrayan.spector.cluster;
+
+/**
+ * Represents the current status of a node in the cluster.
+ */
+public enum NodeStatus {
+    /** Node is actively participating and responding to heartbeats. */
+    ACTIVE,
+    /** Node has failed heartbeat checks and is considered down. */
+    UNAVAILABLE,
+    /** Node is recovering and synchronizing data. */
+    SYNCING
+}
diff --git a/spector-node/src/main/java/com/spectrayan/spector/cluster/QueryResult.java b/spector-cluster/src/main/java/com/spectrayan/spector/cluster/QueryResult.java
similarity index 71%
rename from spector-node/src/main/java/com/spectrayan/spector/cluster/QueryResult.java
rename to spector-cluster/src/main/java/com/spectrayan/spector/cluster/QueryResult.java
index 11783c4..bffcaf1 100644
--- a/spector-node/src/main/java/com/spectrayan/spector/cluster/QueryResult.java
+++ b/spector-cluster/src/main/java/com/spectrayan/spector/cluster/QueryResult.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.cluster;
 
 import java.util.List;
diff --git a/spector-node/src/main/java/com/spectrayan/spector/cluster/RemoteShardClient.java b/spector-cluster/src/main/java/com/spectrayan/spector/cluster/RemoteShardClient.java
similarity index 75%
rename from spector-node/src/main/java/com/spectrayan/spector/cluster/RemoteShardClient.java
rename to spector-cluster/src/main/java/com/spectrayan/spector/cluster/RemoteShardClient.java
index a6f0d69..ebf4c2f 100644
--- a/spector-node/src/main/java/com/spectrayan/spector/cluster/RemoteShardClient.java
+++ b/spector-cluster/src/main/java/com/spectrayan/spector/cluster/RemoteShardClient.java
@@ -1,28 +1,12 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.cluster;
 
-import com.spectrayan.spector.commons.error.ErrorCode;
-import com.spectrayan.spector.commons.error.SpectorClusterException;
-import com.spectrayan.spector.cluster.error.SpectorShardUnavailableException;
 import com.spectrayan.spector.cluster.proto.*;
 import com.spectrayan.spector.index.ScoredResult;
 
 import io.grpc.ManagedChannel;
 import io.grpc.ManagedChannelBuilder;
+import io.grpc.netty.shaded.io.grpc.netty.GrpcSslContexts;
+import io.grpc.netty.shaded.io.grpc.netty.NettyChannelBuilder;
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -37,10 +21,11 @@
  *
  * <p>Wraps a gRPC channel and blocking stub to provide type-safe methods
  * for vector search, keyword search, hybrid search, and ingestion
- * on a remote shard node.</p>
+ * on a remote {@link ShardNode}.</p>
  *
- * <p>Uses the standard gRPC {@link ManagedChannelBuilder} which is backed
- * by Armeria's Netty transport when running inside {@code SpectorNode}.</p>
+ * <h3>TLS Support</h3>
+ * <p>When TLS certificate paths are provided, the client uses encrypted
+ * communication. Otherwise, falls back to plaintext for development.</p>
  */
 public class RemoteShardClient implements AutoCloseable {
 
@@ -71,18 +56,29 @@ public RemoteShardClient(ClusterConfig.NodeEndpoint endpoint,
                               File trustCertFile, File clientCert, File clientKey) {
         this.endpoint = endpoint;
 
-        // TODO: implement TLS via Armeria ClientFactory when trustCertFile is provided
-        this.channel = ManagedChannelBuilder
-                .forTarget(endpoint.target())
-                .usePlaintext()
-                .build();
-
         if (trustCertFile != null && trustCertFile.exists()) {
-            log.warn("TLS cert provided but TLS not yet implemented via Armeria client — using plaintext for shard '{}'",
-                    endpoint.shardId());
+            try {
+                var sslContext = GrpcSslContexts.forClient()
+                        .trustManager(trustCertFile);
+                if (clientCert != null && clientKey != null) {
+                    sslContext.keyManager(clientCert, clientKey);
+                }
+                this.channel = NettyChannelBuilder
+                        .forTarget(endpoint.target())
+                        .sslContext(sslContext.build())
+                        .build();
+                log.info("Connected to shard '{}' at {} (TLS)", endpoint.shardId(), endpoint.target());
+            } catch (Exception e) {
+                throw new RuntimeException("Failed to configure TLS for shard: " + endpoint.shardId(), e);
+            }
+        } else {
+            this.channel = ManagedChannelBuilder
+                    .forTarget(endpoint.target())
+                    .usePlaintext()
+                    .build();
+            log.info("Connected to shard '{}' at {} (plaintext)", endpoint.shardId(), endpoint.target());
         }
 
-        log.info("Connected to shard '{}' at {} (plaintext)", endpoint.shardId(), endpoint.target());
         this.stub = SpectorSearchServiceGrpc.newBlockingStub(channel);
     }
 
@@ -102,7 +98,8 @@ public ScoredResult[] vectorSearch(float[] queryVector, int topK) {
             SearchResponse response = stub.vectorSearch(request);
             return toScoredResults(response);
         } catch (Exception e) {
-            throw GrpcErrorMapper.toSpectorException(e, endpoint.shardId());
+            log.warn("Vector search failed on shard '{}': {}", endpoint.shardId(), e.getMessage());
+            return new ScoredResult[0];
         }
     }
 
@@ -122,7 +119,8 @@ public ScoredResult[] keywordSearch(String queryText, int topK) {
             SearchResponse response = stub.keywordSearch(request);
             return toScoredResults(response);
         } catch (Exception e) {
-            throw GrpcErrorMapper.toSpectorException(e, endpoint.shardId());
+            log.warn("Keyword search failed on shard '{}': {}", endpoint.shardId(), e.getMessage());
+            return new ScoredResult[0];
         }
     }
 
@@ -144,7 +142,8 @@ public ScoredResult[] hybridSearch(String queryText, float[] queryVector, int to
             SearchResponse response = stub.hybridSearch(request);
             return toScoredResults(response);
         } catch (Exception e) {
-            throw GrpcErrorMapper.toSpectorException(e, endpoint.shardId());
+            log.warn("Hybrid search failed on shard '{}': {}", endpoint.shardId(), e.getMessage());
+            return new ScoredResult[0];
         }
     }
 
@@ -167,7 +166,8 @@ public boolean ingest(String docId, String content, float[] vector) {
             IngestResponse response = stub.ingest(builder.build());
             return response.getSuccess();
         } catch (Exception e) {
-            throw GrpcErrorMapper.toSpectorException(e, endpoint.shardId());
+            log.warn("Ingest failed on shard '{}': {}", endpoint.shardId(), e.getMessage());
+            return false;
         }
     }
 
diff --git a/spector-node/src/main/java/com/spectrayan/spector/cluster/ReplicaInfo.java b/spector-cluster/src/main/java/com/spectrayan/spector/cluster/ReplicaInfo.java
similarity index 62%
rename from spector-node/src/main/java/com/spectrayan/spector/cluster/ReplicaInfo.java
rename to spector-cluster/src/main/java/com/spectrayan/spector/cluster/ReplicaInfo.java
index d4acf7e..a85df2f 100644
--- a/spector-node/src/main/java/com/spectrayan/spector/cluster/ReplicaInfo.java
+++ b/spector-cluster/src/main/java/com/spectrayan/spector/cluster/ReplicaInfo.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.cluster;
 
 import java.time.Instant;
diff --git a/spector-cluster/src/main/java/com/spectrayan/spector/cluster/ReplicaState.java b/spector-cluster/src/main/java/com/spectrayan/spector/cluster/ReplicaState.java
new file mode 100644
index 0000000..ee3c815
--- /dev/null
+++ b/spector-cluster/src/main/java/com/spectrayan/spector/cluster/ReplicaState.java
@@ -0,0 +1,13 @@
+package com.spectrayan.spector.cluster;
+
+/**
+ * Represents the state of a replica in the replication group.
+ */
+public enum ReplicaState {
+    /** Replica is fully synchronized and serving reads. */
+    ACTIVE,
+    /** Replica is synchronizing with the primary (not serving reads). */
+    SYNCING,
+    /** Replica is unreachable/failed. */
+    UNAVAILABLE
+}
diff --git a/spector-node/src/main/java/com/spectrayan/spector/cluster/ReplicationManager.java b/spector-cluster/src/main/java/com/spectrayan/spector/cluster/ReplicationManager.java
similarity index 89%
rename from spector-node/src/main/java/com/spectrayan/spector/cluster/ReplicationManager.java
rename to spector-cluster/src/main/java/com/spectrayan/spector/cluster/ReplicationManager.java
index 6e77c9e..b9f3c0b 100644
--- a/spector-node/src/main/java/com/spectrayan/spector/cluster/ReplicationManager.java
+++ b/spector-cluster/src/main/java/com/spectrayan/spector/cluster/ReplicationManager.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.cluster;
 
 import java.time.Duration;
@@ -30,10 +15,6 @@
 import java.util.concurrent.locks.ReentrantReadWriteLock;
 import java.util.logging.Level;
 import java.util.logging.Logger;
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-import com.spectrayan.spector.commons.error.SpectorServerException;
-import com.spectrayan.spector.storage.error.SpectorSegmentClosedException;
-import com.spectrayan.spector.commons.error.ErrorCode;
 
 /**
  * Manages replication of shard data across cluster nodes for fault tolerance.
@@ -111,7 +92,7 @@ public ReplicationManager() {
      *
      * @param replicaCount initial replica count (1–5)
      * @param membershipService optional membership service for reporting unavailable shards (may be null)
-     * @throws SpectorValidationException if replicaCount is outside [1, 5]
+     * @throws IllegalArgumentException if replicaCount is outside [1, 5]
      */
     public ReplicationManager(int replicaCount, MembershipService membershipService) {
         validateReplicaCount(replicaCount);
@@ -129,7 +110,7 @@ public ReplicationManager(int replicaCount, MembershipService membershipService)
      */
     public void start() {
         if (closed) {
-            throw new SpectorSegmentClosedException();
+            throw new IllegalStateException("ReplicationManager has been closed");
         }
         healthCheckFuture = scheduler.scheduleAtFixedRate(
                 this::checkReplicaHealth,
@@ -144,7 +125,7 @@ public void start() {
      * Sets the replica count for all shards.
      *
      * @param count replica count (1–5)
-     * @throws SpectorValidationException if count is outside [1, 5]
+     * @throws IllegalArgumentException if count is outside [1, 5]
      */
     public void setReplicaCount(int count) {
         validateReplicaCount(count);
@@ -166,14 +147,14 @@ public int getReplicaCount() {
      *
      * @param shardIndex     the shard index
      * @param primaryEndpoint the endpoint of the primary node
-     * @throws SpectorValidationException if shardIndex is negative or endpoint is null/blank
+     * @throws IllegalArgumentException if shardIndex is negative or endpoint is null/blank
      */
     public void registerShard(int shardIndex, String primaryEndpoint) {
         if (shardIndex < 0) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_NEGATIVE, "shardIndex", shardIndex);
+            throw new IllegalArgumentException("Shard index must be non-negative: " + shardIndex);
         }
         if (primaryEndpoint == null || primaryEndpoint.isBlank()) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_NULL, "Primary endpoint");
+            throw new IllegalArgumentException("Primary endpoint must not be null or blank");
         }
         primaryEndpoints.put(shardIndex, primaryEndpoint);
         replicationGroups.computeIfAbsent(shardIndex, k -> new CopyOnWriteArrayList<>());
@@ -188,22 +169,24 @@ public void registerShard(int shardIndex, String primaryEndpoint) {
      * @param shardIndex      the shard index
      * @param replicaId       unique identifier for the replica
      * @param replicaEndpoint the endpoint of the replica node
-     * @throws SpectorValidationException if parameters are invalid
-     * @throws SpectorValidationException    if adding would exceed the configured replica count
+     * @throws IllegalArgumentException if parameters are invalid
+     * @throws IllegalStateException    if adding would exceed the configured replica count
      */
     public void addReplica(int shardIndex, String replicaId, String replicaEndpoint) {
         if (replicaId == null || replicaId.isBlank()) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_NULL, "Replica ID");
+            throw new IllegalArgumentException("Replica ID must not be null or blank");
         }
         if (replicaEndpoint == null || replicaEndpoint.isBlank()) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_NULL, "Replica endpoint");
+            throw new IllegalArgumentException("Replica endpoint must not be null or blank");
         }
 
         CopyOnWriteArrayList<ReplicaInfo> group = replicationGroups.computeIfAbsent(
                 shardIndex, k -> new CopyOnWriteArrayList<>());
 
         if (group.size() >= replicaCount) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_INVALID, "Cannot add replica: shard " + shardIndex + " already has " + group.size() + " replicas (max: " + replicaCount + ")");
+            throw new IllegalStateException(
+                    "Cannot add replica: shard " + shardIndex + " already has " +
+                            group.size() + " replicas (max: " + replicaCount + ")");
         }
 
         ReplicaInfo replica = new ReplicaInfo(replicaId, replicaEndpoint, ReplicaState.SYNCING, Instant.now());
@@ -221,12 +204,12 @@ public void addReplica(int shardIndex, String replicaId, String replicaEndpoint)
      * is reported to the MembershipService.</p>
      *
      * @param shardIndex the shard index whose primary has failed
-     * @throws SpectorValidationException if shardIndex is not registered
+     * @throws IllegalArgumentException if shardIndex is not registered
      */
     public void promoteReplica(int shardIndex) {
         ReentrantReadWriteLock lock = shardLocks.get(shardIndex);
         if (lock == null) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_INVALID, "shardIndex", shardIndex);
+            throw new IllegalArgumentException("Shard " + shardIndex + " is not registered");
         }
 
         lock.writeLock().lock();
@@ -299,12 +282,12 @@ public void promoteReplica(int shardIndex) {
      */
     public boolean synchronizeReplica(int shardIndex, String replicaEndpoint) {
         if (replicaEndpoint == null || replicaEndpoint.isBlank()) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_NULL, "Replica endpoint");
+            throw new IllegalArgumentException("Replica endpoint must not be null or blank");
         }
 
         CopyOnWriteArrayList<ReplicaInfo> group = replicationGroups.get(shardIndex);
         if (group == null) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_INVALID, "shardIndex", shardIndex);
+            throw new IllegalArgumentException("Shard " + shardIndex + " is not registered");
         }
 
         // Find the replica
@@ -397,7 +380,7 @@ public boolean canServeReads(int shardIndex, String replicaEndpoint) {
      */
     public void replicateWrite(int shardIndex, WriteOperation operation) {
         if (operation == null) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_NULL, "Write operation");
+            throw new IllegalArgumentException("Write operation must not be null");
         }
 
         // Append to write-ahead log for delta sync
@@ -536,7 +519,9 @@ public void close() {
 
     private void validateReplicaCount(int count) {
         if (count < MIN_REPLICA_COUNT || count > MAX_REPLICA_COUNT) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_OUT_OF_RANGE, "replicaCount", MIN_REPLICA_COUNT, MAX_REPLICA_COUNT, count);
+            throw new IllegalArgumentException(
+                    "Replica count must be between " + MIN_REPLICA_COUNT +
+                            " and " + MAX_REPLICA_COUNT + ", got: " + count);
         }
     }
 
@@ -609,4 +594,4 @@ private boolean replicateToReplica(String replicaEndpoint, WriteOperation operat
         // Simulate successful replication
         return true;
     }
-}
\ No newline at end of file
+}
diff --git a/spector-cluster/src/main/java/com/spectrayan/spector/cluster/ShardAssignment.java b/spector-cluster/src/main/java/com/spectrayan/spector/cluster/ShardAssignment.java
new file mode 100644
index 0000000..4cf7794
--- /dev/null
+++ b/spector-cluster/src/main/java/com/spectrayan/spector/cluster/ShardAssignment.java
@@ -0,0 +1,11 @@
+package com.spectrayan.spector.cluster;
+
+/**
+ * Represents a shard assignment to a node with a specific role.
+ *
+ * @param shardIndex   the shard index
+ * @param nodeEndpoint the endpoint of the node hosting this shard
+ * @param role         the role of this assignment (PRIMARY or REPLICA)
+ */
+public record ShardAssignment(int shardIndex, String nodeEndpoint, ShardRole role) {
+}
diff --git a/spector-node/src/main/java/com/spectrayan/spector/cluster/ShardManager.java b/spector-cluster/src/main/java/com/spectrayan/spector/cluster/ShardManager.java
similarity index 65%
rename from spector-node/src/main/java/com/spectrayan/spector/cluster/ShardManager.java
rename to spector-cluster/src/main/java/com/spectrayan/spector/cluster/ShardManager.java
index c028911..f087a9c 100644
--- a/spector-node/src/main/java/com/spectrayan/spector/cluster/ShardManager.java
+++ b/spector-cluster/src/main/java/com/spectrayan/spector/cluster/ShardManager.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.cluster;
 
 import java.util.Map;
@@ -31,7 +16,7 @@ public interface ShardManager {
      *
      * @param documentId the document identifier
      * @return the shard index (0-based) for the document
-     * @throws SpectorValidationException if documentId is null or empty
+     * @throws IllegalArgumentException if documentId is null or empty
      */
     int assignShard(String documentId);
 
@@ -40,7 +25,7 @@ public interface ShardManager {
      *
      * @param shardIndex   the index of the new shard
      * @param nodeEndpoint the network endpoint (host:port) of the node hosting this shard
-     * @throws SpectorValidationException if shardIndex is out of configured range or endpoint is invalid
+     * @throws IllegalArgumentException if shardIndex is out of configured range or endpoint is invalid
      */
     void addShard(int shardIndex, String nodeEndpoint);
 
diff --git a/spector-node/src/main/java/com/spectrayan/spector/cluster/ShardNode.java b/spector-cluster/src/main/java/com/spectrayan/spector/cluster/ShardNode.java
similarity index 81%
rename from spector-node/src/main/java/com/spectrayan/spector/cluster/ShardNode.java
rename to spector-cluster/src/main/java/com/spectrayan/spector/cluster/ShardNode.java
index 3621676..ce3f32f 100644
--- a/spector-node/src/main/java/com/spectrayan/spector/cluster/ShardNode.java
+++ b/spector-cluster/src/main/java/com/spectrayan/spector/cluster/ShardNode.java
@@ -1,21 +1,5 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.cluster;
 
-import com.spectrayan.spector.engine.DefaultSpectorEngine;
 import com.spectrayan.spector.engine.SpectorEngine;
 
 import io.grpc.Server;
@@ -37,7 +21,7 @@
  *
  * <h3>Usage</h3>
  * <pre>{@code
- *   SpectorEngine engine = new DefaultSpectorEngine(config);
+ *   SpectorEngine engine = new SpectorEngine(config);
  *   ShardNode node = new ShardNode("shard-0", engine, 50051);
  *   node.start();  // blocks until shutdown
  * }</pre>
diff --git a/spector-cluster/src/main/java/com/spectrayan/spector/cluster/ShardRole.java b/spector-cluster/src/main/java/com/spectrayan/spector/cluster/ShardRole.java
new file mode 100644
index 0000000..68224e9
--- /dev/null
+++ b/spector-cluster/src/main/java/com/spectrayan/spector/cluster/ShardRole.java
@@ -0,0 +1,11 @@
+package com.spectrayan.spector.cluster;
+
+/**
+ * Role of a shard assignment on a node.
+ */
+public enum ShardRole {
+    /** The authoritative copy of the shard data. */
+    PRIMARY,
+    /** A replica copy for fault tolerance. */
+    REPLICA
+}
diff --git a/spector-node/src/main/java/com/spectrayan/spector/cluster/SpectorSearchServiceImpl.java b/spector-cluster/src/main/java/com/spectrayan/spector/cluster/SpectorSearchServiceImpl.java
similarity index 85%
rename from spector-node/src/main/java/com/spectrayan/spector/cluster/SpectorSearchServiceImpl.java
rename to spector-cluster/src/main/java/com/spectrayan/spector/cluster/SpectorSearchServiceImpl.java
index 04f1176..6ca8315 100644
--- a/spector-node/src/main/java/com/spectrayan/spector/cluster/SpectorSearchServiceImpl.java
+++ b/spector-cluster/src/main/java/com/spectrayan/spector/cluster/SpectorSearchServiceImpl.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.cluster;
 
 import com.spectrayan.spector.cluster.proto.*;
@@ -58,7 +43,7 @@ public void vectorSearch(VectorSearchRequest request,
             responseObserver.onCompleted();
         } catch (Exception e) {
             log.error("Vector search failed on shard '{}'", shardId, e);
-            responseObserver.onError(GrpcErrorMapper.toStatusRuntimeException(e));
+            responseObserver.onError(e);
         }
     }
 
@@ -72,7 +57,7 @@ public void keywordSearch(KeywordSearchRequest request,
             responseObserver.onCompleted();
         } catch (Exception e) {
             log.error("Keyword search failed on shard '{}'", shardId, e);
-            responseObserver.onError(GrpcErrorMapper.toStatusRuntimeException(e));
+            responseObserver.onError(e);
         }
     }
 
@@ -88,7 +73,7 @@ public void hybridSearch(HybridSearchRequest request,
             responseObserver.onCompleted();
         } catch (Exception e) {
             log.error("Hybrid search failed on shard '{}'", shardId, e);
-            responseObserver.onError(GrpcErrorMapper.toStatusRuntimeException(e));
+            responseObserver.onError(e);
         }
     }
 
@@ -112,7 +97,11 @@ public void ingest(IngestRequest request,
             responseObserver.onCompleted();
         } catch (Exception e) {
             log.error("Ingest failed on shard '{}'", shardId, e);
-            responseObserver.onError(GrpcErrorMapper.toStatusRuntimeException(e));
+            responseObserver.onNext(IngestResponse.newBuilder()
+                    .setSuccess(false)
+                    .setError(e.getMessage())
+                    .build());
+            responseObserver.onCompleted();
         }
     }
 
diff --git a/spector-node/src/main/java/com/spectrayan/spector/cluster/WriteOperation.java b/spector-cluster/src/main/java/com/spectrayan/spector/cluster/WriteOperation.java
similarity index 58%
rename from spector-node/src/main/java/com/spectrayan/spector/cluster/WriteOperation.java
rename to spector-cluster/src/main/java/com/spectrayan/spector/cluster/WriteOperation.java
index 015d2ea..b76a8cc 100644
--- a/spector-node/src/main/java/com/spectrayan/spector/cluster/WriteOperation.java
+++ b/spector-cluster/src/main/java/com/spectrayan/spector/cluster/WriteOperation.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.cluster;
 
 import java.time.Instant;
diff --git a/spector-node/src/main/proto/spector_search.proto b/spector-cluster/src/main/proto/spector_search.proto
similarity index 100%
rename from spector-node/src/main/proto/spector_search.proto
rename to spector-cluster/src/main/proto/spector_search.proto
diff --git a/spector-node/src/test/java/com/spectrayan/spector/cluster/ClusterConfigTest.java b/spector-cluster/src/test/java/com/spectrayan/spector/cluster/ClusterConfigTest.java
similarity index 79%
rename from spector-node/src/test/java/com/spectrayan/spector/cluster/ClusterConfigTest.java
rename to spector-cluster/src/test/java/com/spectrayan/spector/cluster/ClusterConfigTest.java
index e1becf8..51caf28 100644
--- a/spector-node/src/test/java/com/spectrayan/spector/cluster/ClusterConfigTest.java
+++ b/spector-cluster/src/test/java/com/spectrayan/spector/cluster/ClusterConfigTest.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.cluster;
 
 import org.junit.jupiter.api.Test;
diff --git a/spector-node/src/test/java/com/spectrayan/spector/cluster/ConsistentHashShardManagerTest.java b/spector-cluster/src/test/java/com/spectrayan/spector/cluster/ConsistentHashShardManagerTest.java
similarity index 88%
rename from spector-node/src/test/java/com/spectrayan/spector/cluster/ConsistentHashShardManagerTest.java
rename to spector-cluster/src/test/java/com/spectrayan/spector/cluster/ConsistentHashShardManagerTest.java
index a6daa42..5f573e6 100644
--- a/spector-node/src/test/java/com/spectrayan/spector/cluster/ConsistentHashShardManagerTest.java
+++ b/spector-cluster/src/test/java/com/spectrayan/spector/cluster/ConsistentHashShardManagerTest.java
@@ -1,24 +1,5 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.cluster;
 
-import com.spectrayan.spector.commons.error.SpectorException;
-
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-
 import java.util.HashSet;
 import java.util.Map;
 import java.util.Set;
@@ -55,13 +36,13 @@ void setUp() {
 
     @Test
     void shouldRejectShardCountBelowMinimum() {
-        assertThrows(SpectorValidationException.class,
+        assertThrows(IllegalArgumentException.class,
                 () -> new ConsistentHashShardManager(1));
     }
 
     @Test
     void shouldRejectShardCountAboveMaximum() {
-        assertThrows(SpectorValidationException.class,
+        assertThrows(IllegalArgumentException.class,
                 () -> new ConsistentHashShardManager(257));
     }
 
@@ -112,33 +93,33 @@ void shouldReturnValidShardIndex() {
 
     @Test
     void shouldRejectNullDocumentId() {
-        assertThrows(SpectorValidationException.class,
+        assertThrows(IllegalArgumentException.class,
                 () -> manager.assignShard(null));
     }
 
     @Test
     void shouldRejectEmptyDocumentId() {
-        assertThrows(SpectorValidationException.class,
+        assertThrows(IllegalArgumentException.class,
                 () -> manager.assignShard(""));
     }
 
     @Test
     void shouldRejectInvalidShardIndex() {
-        assertThrows(SpectorValidationException.class,
+        assertThrows(IllegalArgumentException.class,
                 () -> manager.addShard(5, "node5:8080"));
     }
 
     @Test
     void shouldRejectNullEndpoint() {
         var mgr = new ConsistentHashShardManager(4);
-        assertThrows(SpectorValidationException.class,
+        assertThrows(IllegalArgumentException.class,
                 () -> mgr.addShard(0, null));
     }
 
     @Test
     void shouldRejectBlankEndpoint() {
         var mgr = new ConsistentHashShardManager(4);
-        assertThrows(SpectorValidationException.class,
+        assertThrows(IllegalArgumentException.class,
                 () -> mgr.addShard(0, "  "));
     }
 
@@ -273,7 +254,7 @@ void shouldNotifyListenerWithPausedShardsOnRebalance() {
     @Test
     void shouldThrowWhenNoShardsRegistered() {
         var mgr = new ConsistentHashShardManager(4);
-        assertThrows(SpectorException.class,
+        assertThrows(IllegalStateException.class,
                 () -> mgr.assignShard("doc-1"));
     }
 
diff --git a/spector-node/src/test/java/com/spectrayan/spector/cluster/DistributedQueryCoordinatorTest.java b/spector-cluster/src/test/java/com/spectrayan/spector/cluster/DistributedQueryCoordinatorTest.java
similarity index 86%
rename from spector-node/src/test/java/com/spectrayan/spector/cluster/DistributedQueryCoordinatorTest.java
rename to spector-cluster/src/test/java/com/spectrayan/spector/cluster/DistributedQueryCoordinatorTest.java
index 46c0713..71aa31a 100644
--- a/spector-node/src/test/java/com/spectrayan/spector/cluster/DistributedQueryCoordinatorTest.java
+++ b/spector-cluster/src/test/java/com/spectrayan/spector/cluster/DistributedQueryCoordinatorTest.java
@@ -1,22 +1,5 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.cluster;
 
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-
 import java.time.Duration;
 import java.util.ArrayList;
 import java.util.List;
@@ -145,25 +128,25 @@ void constructor_validTimeout_accepted() {
 
     @Test
     void constructor_timeoutTooLow_throws() {
-        assertThrows(SpectorValidationException.class, () ->
+        assertThrows(IllegalArgumentException.class, () ->
                 new DistributedQueryCoordinator(List.of(), Duration.ofMillis(500)));
     }
 
     @Test
     void constructor_timeoutTooHigh_throws() {
-        assertThrows(SpectorValidationException.class, () ->
+        assertThrows(IllegalArgumentException.class, () ->
                 new DistributedQueryCoordinator(List.of(), Duration.ofSeconds(61)));
     }
 
     @Test
     void constructor_nullShardEndpoints_throws() {
-        assertThrows(SpectorValidationException.class, () ->
+        assertThrows(NullPointerException.class, () ->
                 new DistributedQueryCoordinator(null));
     }
 
     @Test
     void constructor_nullTimeout_throws() {
-        assertThrows(SpectorValidationException.class, () ->
+        assertThrows(NullPointerException.class, () ->
                 new DistributedQueryCoordinator(List.of(), null));
     }
 
@@ -172,7 +155,7 @@ void constructor_nullTimeout_throws() {
     @Test
     void fanOutVectorSearch_topKZero_throws() {
         var coordinator = new DistributedQueryCoordinator(List.of());
-        assertThrows(SpectorValidationException.class, () ->
+        assertThrows(IllegalArgumentException.class, () ->
                 coordinator.fanOutVectorSearch(new float[]{1.0f}, 0));
         coordinator.close();
     }
@@ -180,7 +163,7 @@ void fanOutVectorSearch_topKZero_throws() {
     @Test
     void fanOutVectorSearch_topKTooLarge_throws() {
         var coordinator = new DistributedQueryCoordinator(List.of());
-        assertThrows(SpectorValidationException.class, () ->
+        assertThrows(IllegalArgumentException.class, () ->
                 coordinator.fanOutVectorSearch(new float[]{1.0f}, 10_001));
         coordinator.close();
     }
@@ -188,7 +171,7 @@ void fanOutVectorSearch_topKTooLarge_throws() {
     @Test
     void fanOutVectorSearch_nullQuery_throws() {
         var coordinator = new DistributedQueryCoordinator(List.of());
-        assertThrows(SpectorValidationException.class, () ->
+        assertThrows(NullPointerException.class, () ->
                 coordinator.fanOutVectorSearch(null, 10));
         coordinator.close();
     }
@@ -217,23 +200,23 @@ void shardEndpoint_validConstruction() {
 
     @Test
     void shardEndpoint_invalidPort_throws() {
-        assertThrows(SpectorValidationException.class, () ->
+        assertThrows(IllegalArgumentException.class, () ->
                 new DistributedQueryCoordinator.ShardEndpoint("shard-0", "localhost", 0));
-        assertThrows(SpectorValidationException.class, () ->
+        assertThrows(IllegalArgumentException.class, () ->
                 new DistributedQueryCoordinator.ShardEndpoint("shard-0", "localhost", -1));
-        assertThrows(SpectorValidationException.class, () ->
+        assertThrows(IllegalArgumentException.class, () ->
                 new DistributedQueryCoordinator.ShardEndpoint("shard-0", "localhost", 70000));
     }
 
     @Test
     void shardEndpoint_nullShardId_throws() {
-        assertThrows(SpectorValidationException.class, () ->
+        assertThrows(NullPointerException.class, () ->
                 new DistributedQueryCoordinator.ShardEndpoint(null, "localhost", 9090));
     }
 
     @Test
     void shardEndpoint_nullHost_throws() {
-        assertThrows(SpectorValidationException.class, () ->
+        assertThrows(NullPointerException.class, () ->
                 new DistributedQueryCoordinator.ShardEndpoint("shard-0", null, 9090));
     }
 
diff --git a/spector-node/src/test/java/com/spectrayan/spector/cluster/HeartbeatMembershipServiceTest.java b/spector-cluster/src/test/java/com/spectrayan/spector/cluster/HeartbeatMembershipServiceTest.java
similarity index 91%
rename from spector-node/src/test/java/com/spectrayan/spector/cluster/HeartbeatMembershipServiceTest.java
rename to spector-cluster/src/test/java/com/spectrayan/spector/cluster/HeartbeatMembershipServiceTest.java
index 88a5b9a..905cc0c 100644
--- a/spector-node/src/test/java/com/spectrayan/spector/cluster/HeartbeatMembershipServiceTest.java
+++ b/spector-cluster/src/test/java/com/spectrayan/spector/cluster/HeartbeatMembershipServiceTest.java
@@ -1,22 +1,5 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.cluster;
 
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-
 import java.time.Duration;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
@@ -72,23 +55,23 @@ void constructorWithCustomConfig() {
 
     @Test
     void constructorRejectsNullShardManager() {
-        assertThrows(SpectorValidationException.class,
+        assertThrows(IllegalArgumentException.class,
                 () -> new HeartbeatMembershipService(null));
     }
 
     @Test
     void constructorRejectsInvalidHeartbeatInterval() {
-        assertThrows(SpectorValidationException.class,
+        assertThrows(IllegalArgumentException.class,
                 () -> new HeartbeatMembershipService(shardManager, Duration.ofMillis(100), Duration.ofSeconds(10)));
-        assertThrows(SpectorValidationException.class,
+        assertThrows(IllegalArgumentException.class,
                 () -> new HeartbeatMembershipService(shardManager, Duration.ofSeconds(31), Duration.ofSeconds(10)));
     }
 
     @Test
     void constructorRejectsInvalidFailureTimeout() {
-        assertThrows(SpectorValidationException.class,
+        assertThrows(IllegalArgumentException.class,
                 () -> new HeartbeatMembershipService(shardManager, Duration.ofSeconds(2), Duration.ofSeconds(2)));
-        assertThrows(SpectorValidationException.class,
+        assertThrows(IllegalArgumentException.class,
                 () -> new HeartbeatMembershipService(shardManager, Duration.ofSeconds(2), Duration.ofSeconds(121)));
     }
 
@@ -107,14 +90,14 @@ void registerNodeAddsToActiveNodes() {
     @Test
     void registerNodeRejectsNullId() {
         service = new HeartbeatMembershipService(shardManager);
-        assertThrows(SpectorValidationException.class,
+        assertThrows(IllegalArgumentException.class,
                 () -> service.registerNode(null, "localhost:6000"));
     }
 
     @Test
     void registerNodeRejectsBlankEndpoint() {
         service = new HeartbeatMembershipService(shardManager);
-        assertThrows(SpectorValidationException.class,
+        assertThrows(IllegalArgumentException.class,
                 () -> service.registerNode("node-1", "  "));
     }
 
@@ -150,7 +133,7 @@ void markUnavailableRemovesFromActiveNodes() {
     @Test
     void markUnavailableRejectsUnknownNode() {
         service = new HeartbeatMembershipService(shardManager);
-        assertThrows(SpectorValidationException.class,
+        assertThrows(IllegalArgumentException.class,
                 () -> service.markUnavailable("nonexistent"));
     }
 
diff --git a/spector-node/src/test/java/com/spectrayan/spector/cluster/ReplicationManagerTest.java b/spector-cluster/src/test/java/com/spectrayan/spector/cluster/ReplicationManagerTest.java
similarity index 87%
rename from spector-node/src/test/java/com/spectrayan/spector/cluster/ReplicationManagerTest.java
rename to spector-cluster/src/test/java/com/spectrayan/spector/cluster/ReplicationManagerTest.java
index d56802d..e4ebe40 100644
--- a/spector-node/src/test/java/com/spectrayan/spector/cluster/ReplicationManagerTest.java
+++ b/spector-cluster/src/test/java/com/spectrayan/spector/cluster/ReplicationManagerTest.java
@@ -1,24 +1,5 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.cluster;
 
-import com.spectrayan.spector.commons.error.SpectorException;
-
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-
 import java.time.Instant;
 import java.util.List;
 
@@ -61,18 +42,18 @@ void setReplicaCount_validRange_updates() {
 
     @Test
     void setReplicaCount_belowMinimum_throws() {
-        assertThrows(SpectorValidationException.class, () -> replicationManager.setReplicaCount(0));
+        assertThrows(IllegalArgumentException.class, () -> replicationManager.setReplicaCount(0));
     }
 
     @Test
     void setReplicaCount_aboveMaximum_throws() {
-        assertThrows(SpectorValidationException.class, () -> replicationManager.setReplicaCount(6));
+        assertThrows(IllegalArgumentException.class, () -> replicationManager.setReplicaCount(6));
     }
 
     @Test
     void constructor_invalidReplicaCount_throws() {
-        assertThrows(SpectorValidationException.class, () -> new ReplicationManager(0, null));
-        assertThrows(SpectorValidationException.class, () -> new ReplicationManager(6, null));
+        assertThrows(IllegalArgumentException.class, () -> new ReplicationManager(0, null));
+        assertThrows(IllegalArgumentException.class, () -> new ReplicationManager(6, null));
     }
 
     // --- Shard registration tests ---
@@ -85,19 +66,19 @@ void registerShard_validParams_succeeds() {
 
     @Test
     void registerShard_negativeIndex_throws() {
-        assertThrows(SpectorValidationException.class,
+        assertThrows(IllegalArgumentException.class,
                 () -> replicationManager.registerShard(-1, "node1:9090"));
     }
 
     @Test
     void registerShard_nullEndpoint_throws() {
-        assertThrows(SpectorValidationException.class,
+        assertThrows(IllegalArgumentException.class,
                 () -> replicationManager.registerShard(0, null));
     }
 
     @Test
     void registerShard_blankEndpoint_throws() {
-        assertThrows(SpectorValidationException.class,
+        assertThrows(IllegalArgumentException.class,
                 () -> replicationManager.registerShard(0, "  "));
     }
 
@@ -122,14 +103,14 @@ void addReplica_exceedsReplicaCount_throws() {
         replicationManager.addReplica(0, "r1", "node2:9090");
         replicationManager.addReplica(0, "r2", "node3:9090");
 
-        assertThrows(SpectorException.class,
+        assertThrows(IllegalStateException.class,
                 () -> replicationManager.addReplica(0, "r3", "node4:9090"));
     }
 
     @Test
     void addReplica_nullId_throws() {
         replicationManager.registerShard(0, "primary:9090");
-        assertThrows(SpectorValidationException.class,
+        assertThrows(IllegalArgumentException.class,
                 () -> replicationManager.addReplica(0, null, "node2:9090"));
     }
 
@@ -163,7 +144,7 @@ void promoteReplica_noReplicaAvailable_marksUnavailable() {
 
     @Test
     void promoteReplica_unregisteredShard_throws() {
-        assertThrows(SpectorValidationException.class,
+        assertThrows(IllegalArgumentException.class,
                 () -> replicationManager.promoteReplica(99));
     }
 
@@ -192,7 +173,7 @@ void synchronizeReplica_unknownEndpoint_returnsFalse() {
 
     @Test
     void synchronizeReplica_unregisteredShard_throws() {
-        assertThrows(SpectorValidationException.class,
+        assertThrows(IllegalArgumentException.class,
                 () -> replicationManager.synchronizeReplica(99, "node:9090"));
     }
 
@@ -246,7 +227,7 @@ void replicateWrite_appendsToWal() {
     @Test
     void replicateWrite_nullOperation_throws() {
         replicationManager.registerShard(0, "primary:9090");
-        assertThrows(SpectorValidationException.class,
+        assertThrows(IllegalArgumentException.class,
                 () -> replicationManager.replicateWrite(0, null));
     }
 
diff --git a/spector-commons/README.md b/spector-commons/README.md
deleted file mode 100644
index 6387146..0000000
--- a/spector-commons/README.md
+++ /dev/null
@@ -1,35 +0,0 @@
-# spector-commons 📄
-
-> **Ingestion utilities, text tokenizers, semantic chunkers, and document content extractors for Spector.**
-
-`spector-commons` handles the preprocessing phase of document ingestion. It parses raw file formats (HTML, PDF, plain text), extracts core text content, and chunks it using character, token-level, or streaming boundaries to fit model context windows before embedding generation.
-
----
-
-## 🏗️ Core Architecture & Roles
-
-1. **Semantic Chunkers (`TextChunker` / `TokenChunker`):** Segments large text blocks into overlapping passages to maintain query context and respect model token limits.
-2. **Streaming Chunkers (`StreamingChunker`):** High-throughput chunking controller designed to ingest streams of tokens/characters with sliding context windows.
-3. **Content Extraction (`ContentExtractor` / `PdfDocumentReader`):** Pure Java, zero-dependency HTML parser and PDF decoder designed to extract structured text without heavy external libraries.
-
----
-
-## 🚀 Key APIs
-
-### Token-level Overlapping Chunking
-```java
-String text = "Large document content...";
-int maxTokens = 256;
-int overlap = 32;
-
-List<Chunk> chunks = TokenChunker.chunk(text, maxTokens, overlap);
-for (Chunk chunk : chunks) {
-    System.out.printf("Chunk %d (%d tokens) -> %s%n", chunk.index(), chunk.tokenCount(), chunk.text());
-}
-```
-
-### Pure Java PDF Reading
-```java
-byte[] pdfBytes = ...;
-String extractedText = PdfDocumentReader.readText(pdfBytes);
-```
diff --git a/spector-commons/pom.xml b/spector-commons/pom.xml
index dce0997..df246c7 100644
--- a/spector-commons/pom.xml
+++ b/spector-commons/pom.xml
@@ -6,32 +6,14 @@
 
     <parent>
         <groupId>com.spectrayan</groupId>
-        <artifactId>spector</artifactId>
+        <artifactId>spector-search</artifactId>
         <version>0.1.0-SNAPSHOT</version>
     </parent>
 
     <artifactId>spector-commons</artifactId>
     <name>Spector Commons</name>
-    <description>Shared utilities: content extraction, text chunking, normalization, and configuration.</description>
+    <description>Shared utilities: content extraction, text chunking, and normalization.</description>
 
-    <dependencies>
-        <!-- Logging -->
-        <dependency>
-            <groupId>org.slf4j</groupId>
-            <artifactId>slf4j-api</artifactId>
-        </dependency>
-
-        <!-- Test -->
-        <dependency>
-            <groupId>org.junit.jupiter</groupId>
-            <artifactId>junit-jupiter</artifactId>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>org.assertj</groupId>
-            <artifactId>assertj-core</artifactId>
-            <scope>test</scope>
-        </dependency>
-    </dependencies>
+    <!-- No external dependencies for document readers — uses built-in Java APIs -->
 
 </project>
diff --git a/spector-commons/src/main/java/com/spectrayan/spector/commons/ChunkConfig.java b/spector-commons/src/main/java/com/spectrayan/spector/commons/ChunkConfig.java
index a9c8891..376162c 100644
--- a/spector-commons/src/main/java/com/spectrayan/spector/commons/ChunkConfig.java
+++ b/spector-commons/src/main/java/com/spectrayan/spector/commons/ChunkConfig.java
@@ -1,23 +1,5 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.commons;
 
-import com.spectrayan.spector.commons.error.ErrorCode;
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-
 /**
  * Configuration for the {@link TokenAwareChunker}.
  *
@@ -29,15 +11,17 @@ public record ChunkConfig(int maxTokens, int overlapTokens) {
     /**
      * Validates the configuration parameters.
      *
-     * @throws SpectorValidationException if maxTokens is not in [1, 8192] or
+     * @throws IllegalArgumentException if maxTokens is not in [1, 8192] or
      *                                  overlapTokens is not in [0, maxTokens - 1]
      */
     public ChunkConfig {
         if (maxTokens <= 0 || maxTokens > 8192) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_OUT_OF_RANGE, "maxTokens", 1, 8192, maxTokens);
+            throw new IllegalArgumentException(
+                    "maxTokens must be greater than 0 and at most 8192, got: " + maxTokens);
         }
         if (overlapTokens < 0 || overlapTokens >= maxTokens) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_OUT_OF_RANGE, "overlapTokens", 0, maxTokens - 1, overlapTokens);
+            throw new IllegalArgumentException(
+                    "overlap must be >= 0 and less than maxTokens (" + maxTokens + "), got: " + overlapTokens);
         }
     }
 
diff --git a/spector-commons/src/main/java/com/spectrayan/spector/commons/ContentExtractor.java b/spector-commons/src/main/java/com/spectrayan/spector/commons/ContentExtractor.java
index 15f1bb3..440a44f 100644
--- a/spector-commons/src/main/java/com/spectrayan/spector/commons/ContentExtractor.java
+++ b/spector-commons/src/main/java/com/spectrayan/spector/commons/ContentExtractor.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.commons;
 
 import java.util.ArrayList;
diff --git a/spector-commons/src/main/java/com/spectrayan/spector/commons/ResourceUtils.java b/spector-commons/src/main/java/com/spectrayan/spector/commons/ResourceUtils.java
deleted file mode 100644
index 2085802..0000000
--- a/spector-commons/src/main/java/com/spectrayan/spector/commons/ResourceUtils.java
+++ /dev/null
@@ -1,163 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.commons;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.io.IOException;
-import java.io.InputStream;
-import java.nio.charset.StandardCharsets;
-import java.util.Objects;
-import java.util.concurrent.ConcurrentHashMap;
-
-/**
- * Utility for loading and caching classpath resources.
- *
- * <h3>Usage</h3>
- * <pre>
- *   String prompt = ResourceUtils.loadResource("prompts/entity-extraction.txt");
- *   // Subsequent calls return the cached copy — zero I/O.
- * </pre>
- *
- * <h3>Thread Safety</h3>
- * <p>All methods are thread-safe. The internal cache uses {@link ConcurrentHashMap}
- * and resources are loaded at most once per JVM lifetime.</p>
- *
- * <h3>Cache Policy</h3>
- * <p>Resources are cached permanently (process-scoped). This is appropriate for
- * prompt templates, SQL schemas, and other static classpath resources that never
- * change at runtime. Call {@link #clearCache()} or {@link #evict(String)} to
- * force a reload (e.g., during testing).</p>
- */
-public final class ResourceUtils {
-
-    private static final Logger log = LoggerFactory.getLogger(ResourceUtils.class);
-
-    /** Process-scoped cache: resourcePath → contents. */
-    private static final ConcurrentHashMap<String, String> CACHE = new ConcurrentHashMap<>();
-
-    private ResourceUtils() {} // utility class — no instances
-
-    /**
-     * Loads a classpath resource as a UTF-8 string, caching the result.
-     *
-     * <p>The resource is looked up via the current thread's context class loader,
-     * falling back to {@code ResourceUtils.class} class loader.</p>
-     *
-     * @param resourcePath classpath path (e.g. "prompts/entity-extraction.txt")
-     * @return the resource contents as a string
-     * @throws IllegalArgumentException if the resource is not found
-     */
-    public static String loadResource(String resourcePath) {
-        Objects.requireNonNull(resourcePath, "resourcePath must not be null");
-        return CACHE.computeIfAbsent(resourcePath, ResourceUtils::doLoad);
-    }
-
-    /**
-     * Loads a classpath resource as a UTF-8 string, returning a default value
-     * if the resource is not found.
-     *
-     * @param resourcePath classpath path
-     * @param defaultValue value to return if the resource is not found
-     * @return the resource contents or the default value
-     */
-    public static String loadResourceOrDefault(String resourcePath, String defaultValue) {
-        Objects.requireNonNull(resourcePath, "resourcePath must not be null");
-        try {
-            return CACHE.computeIfAbsent(resourcePath, ResourceUtils::doLoad);
-        } catch (IllegalArgumentException e) {
-            log.debug("Resource not found '{}', using default", resourcePath);
-            return defaultValue;
-        }
-    }
-
-    /**
-     * Loads a classpath resource as raw bytes without caching.
-     *
-     * @param resourcePath classpath path
-     * @return the resource bytes
-     * @throws IllegalArgumentException if the resource is not found
-     * @throws IOException if an I/O error occurs
-     */
-    public static byte[] loadResourceBytes(String resourcePath) throws IOException {
-        Objects.requireNonNull(resourcePath, "resourcePath must not be null");
-        try (InputStream is = openStream(resourcePath)) {
-            return is.readAllBytes();
-        }
-    }
-
-    /**
-     * Checks whether a classpath resource exists.
-     *
-     * @param resourcePath classpath path
-     * @return true if the resource exists
-     */
-    public static boolean exists(String resourcePath) {
-        ClassLoader cl = Thread.currentThread().getContextClassLoader();
-        if (cl != null && cl.getResource(resourcePath) != null) return true;
-        return ResourceUtils.class.getClassLoader().getResource(resourcePath) != null;
-    }
-
-    /**
-     * Evicts a single resource from the cache, forcing a reload on next access.
-     *
-     * @param resourcePath classpath path to evict
-     */
-    public static void evict(String resourcePath) {
-        CACHE.remove(resourcePath);
-    }
-
-    /**
-     * Clears the entire resource cache.
-     */
-    public static void clearCache() {
-        CACHE.clear();
-    }
-
-    /**
-     * Returns the number of cached resources.
-     */
-    public static int cacheSize() {
-        return CACHE.size();
-    }
-
-    // ── Internal ──
-
-    private static String doLoad(String resourcePath) {
-        try (InputStream is = openStream(resourcePath)) {
-            String content = new String(is.readAllBytes(), StandardCharsets.UTF_8);
-            log.debug("Loaded and cached resource '{}' ({} bytes)", resourcePath, content.length());
-            return content;
-        } catch (IOException e) {
-            throw new IllegalArgumentException(
-                    "Failed to read classpath resource: " + resourcePath, e);
-        }
-    }
-
-    private static InputStream openStream(String resourcePath) {
-        ClassLoader cl = Thread.currentThread().getContextClassLoader();
-        InputStream is = cl != null ? cl.getResourceAsStream(resourcePath) : null;
-        if (is == null) {
-            is = ResourceUtils.class.getClassLoader().getResourceAsStream(resourcePath);
-        }
-        if (is == null) {
-            throw new IllegalArgumentException(
-                    "Classpath resource not found: " + resourcePath);
-        }
-        return is;
-    }
-}
diff --git a/spector-commons/src/main/java/com/spectrayan/spector/commons/StreamingChunker.java b/spector-commons/src/main/java/com/spectrayan/spector/commons/StreamingChunker.java
index 18afc3c..780071a 100644
--- a/spector-commons/src/main/java/com/spectrayan/spector/commons/StreamingChunker.java
+++ b/spector-commons/src/main/java/com/spectrayan/spector/commons/StreamingChunker.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.commons;
 
 import java.io.*;
@@ -26,8 +11,6 @@
 import java.util.Spliterators;
 import java.util.stream.Stream;
 import java.util.stream.StreamSupport;
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-import com.spectrayan.spector.commons.error.ErrorCode;
 
 /**
  * Streaming chunker for very large files that cannot fit into memory.
@@ -64,8 +47,8 @@ private StreamingChunker() {}
      */
     public static Iterator<TextChunker.Chunk> chunkIterator(
             Reader reader, String documentId, int chunkSize, int overlap) {
-        if (chunkSize <= 0) throw new SpectorValidationException(ErrorCode.ARGUMENT_OUT_OF_RANGE, "chunkSize", 1, Integer.MAX_VALUE, 0);
-        if (overlap < 0 || overlap >= chunkSize) throw new SpectorValidationException(ErrorCode.ARGUMENT_OUT_OF_RANGE, "overlap", 0, 0, 0);
+        if (chunkSize <= 0) throw new IllegalArgumentException("chunkSize must be > 0");
+        if (overlap < 0 || overlap >= chunkSize) throw new IllegalArgumentException("overlap must be in [0, chunkSize)");
         return new StreamingChunkIterator(reader, documentId, chunkSize, overlap);
     }
 
diff --git a/spector-commons/src/main/java/com/spectrayan/spector/commons/TextChunk.java b/spector-commons/src/main/java/com/spectrayan/spector/commons/TextChunk.java
index 84c16ec..3fff090 100644
--- a/spector-commons/src/main/java/com/spectrayan/spector/commons/TextChunk.java
+++ b/spector-commons/src/main/java/com/spectrayan/spector/commons/TextChunk.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.commons;
 
 /**
diff --git a/spector-commons/src/main/java/com/spectrayan/spector/commons/TextChunker.java b/spector-commons/src/main/java/com/spectrayan/spector/commons/TextChunker.java
index a3bf477..3ee69c1 100644
--- a/spector-commons/src/main/java/com/spectrayan/spector/commons/TextChunker.java
+++ b/spector-commons/src/main/java/com/spectrayan/spector/commons/TextChunker.java
@@ -1,26 +1,9 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.commons;
 
 import java.text.BreakIterator;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Locale;
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-import com.spectrayan.spector.commons.error.ErrorCode;
 
 /**
  * Splits large documents into overlapping chunks for indexing.
@@ -84,12 +67,12 @@ public record Chunk(
      *
      * @param chunkSize  target chunk size in characters
      * @param overlap    overlap between consecutive chunks in characters
-     * @throws SpectorValidationException if overlap >= chunkSize
+     * @throws IllegalArgumentException if overlap >= chunkSize
      */
     public TextChunker(int chunkSize, int overlap) {
-        if (chunkSize <= 0) throw new SpectorValidationException(ErrorCode.ARGUMENT_OUT_OF_RANGE, "chunkSize", 1, Integer.MAX_VALUE, 0);
-        if (overlap < 0) throw new SpectorValidationException(ErrorCode.ARGUMENT_NEGATIVE, "overlap", 0);
-        if (overlap >= chunkSize) throw new SpectorValidationException(ErrorCode.ARGUMENT_OUT_OF_RANGE, "overlap", 0, 0, 0);
+        if (chunkSize <= 0) throw new IllegalArgumentException("chunkSize must be > 0");
+        if (overlap < 0) throw new IllegalArgumentException("overlap must be >= 0");
+        if (overlap >= chunkSize) throw new IllegalArgumentException("overlap must be < chunkSize");
         this.chunkSize = chunkSize;
         this.overlap = overlap;
     }
diff --git a/spector-commons/src/main/java/com/spectrayan/spector/commons/TextUtils.java b/spector-commons/src/main/java/com/spectrayan/spector/commons/TextUtils.java
index de70209..58d95b9 100644
--- a/spector-commons/src/main/java/com/spectrayan/spector/commons/TextUtils.java
+++ b/spector-commons/src/main/java/com/spectrayan/spector/commons/TextUtils.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.commons;
 
 /**
diff --git a/spector-commons/src/main/java/com/spectrayan/spector/commons/TokenAwareChunker.java b/spector-commons/src/main/java/com/spectrayan/spector/commons/TokenAwareChunker.java
index 2b53265..613a652 100644
--- a/spector-commons/src/main/java/com/spectrayan/spector/commons/TokenAwareChunker.java
+++ b/spector-commons/src/main/java/com/spectrayan/spector/commons/TokenAwareChunker.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.commons;
 
 import java.text.BreakIterator;
diff --git a/spector-commons/src/main/java/com/spectrayan/spector/commons/TokenChunker.java b/spector-commons/src/main/java/com/spectrayan/spector/commons/TokenChunker.java
index 14528bd..f1f080b 100644
--- a/spector-commons/src/main/java/com/spectrayan/spector/commons/TokenChunker.java
+++ b/spector-commons/src/main/java/com/spectrayan/spector/commons/TokenChunker.java
@@ -1,27 +1,9 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.commons;
 
 import java.text.BreakIterator;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Locale;
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-import com.spectrayan.spector.commons.error.ErrorCode;
-import com.spectrayan.spector.commons.error.SpectorException;
 
 /**
  * Token-aware text chunker that splits by word/token count instead of character count.
@@ -60,9 +42,9 @@ public class TokenChunker {
      * @param overlapTokens overlap tokens between consecutive chunks
      */
     public TokenChunker(int maxTokens, int overlapTokens) {
-        if (maxTokens <= 0) throw new SpectorValidationException(ErrorCode.ARGUMENT_OUT_OF_RANGE, "maxTokens", 1, Integer.MAX_VALUE, 0);
-        if (overlapTokens < 0) throw new SpectorValidationException(ErrorCode.ARGUMENT_NEGATIVE, "overlapTokens", 0);
-        if (overlapTokens >= maxTokens) throw new SpectorValidationException(ErrorCode.ARGUMENT_OUT_OF_RANGE, "overlapTokens", 0, 0, 0);
+        if (maxTokens <= 0) throw new IllegalArgumentException("maxTokens must be > 0");
+        if (overlapTokens < 0) throw new IllegalArgumentException("overlapTokens must be >= 0");
+        if (overlapTokens >= maxTokens) throw new IllegalArgumentException("overlapTokens must be < maxTokens");
         this.maxTokens = maxTokens;
         this.overlapTokens = overlapTokens;
     }
diff --git a/spector-commons/src/main/java/com/spectrayan/spector/commons/WordTokenizer.java b/spector-commons/src/main/java/com/spectrayan/spector/commons/WordTokenizer.java
index 27df431..c0cb3d5 100644
--- a/spector-commons/src/main/java/com/spectrayan/spector/commons/WordTokenizer.java
+++ b/spector-commons/src/main/java/com/spectrayan/spector/commons/WordTokenizer.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.commons;
 
 import java.text.BreakIterator;
diff --git a/spector-commons/src/main/java/com/spectrayan/spector/commons/concurrent/ConcurrentExecutionException.java b/spector-commons/src/main/java/com/spectrayan/spector/commons/concurrent/ConcurrentExecutionException.java
deleted file mode 100644
index 48d1057..0000000
--- a/spector-commons/src/main/java/com/spectrayan/spector/commons/concurrent/ConcurrentExecutionException.java
+++ /dev/null
@@ -1,36 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.commons.concurrent;
-
-/**
- * Exception thrown when a concurrent fork-join operation fails.
- *
- * <p>Wraps the root cause of the first failed subtask. In structured
- * concurrency mode, this wraps the {@code FailedException} cause.
- * In classic mode, it wraps the {@code ExecutionException} cause.</p>
- */
-public class ConcurrentExecutionException extends Exception {
-
-    /**
-     * Creates a new concurrent execution exception.
-     *
-     * @param message descriptive message
-     * @param cause   the underlying exception from the failed task
-     */
-    public ConcurrentExecutionException(String message, Throwable cause) {
-        super(message, cause);
-    }
-}
diff --git a/spector-commons/src/main/java/com/spectrayan/spector/commons/concurrent/ConcurrentTasks.java b/spector-commons/src/main/java/com/spectrayan/spector/commons/concurrent/ConcurrentTasks.java
deleted file mode 100644
index 3c3ce6d..0000000
--- a/spector-commons/src/main/java/com/spectrayan/spector/commons/concurrent/ConcurrentTasks.java
+++ /dev/null
@@ -1,443 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.commons.concurrent;
-
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-import com.spectrayan.spector.commons.error.ErrorCode;
-
-import java.time.Duration;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.concurrent.Callable;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-import java.util.concurrent.Future;
-import java.util.concurrent.StructuredTaskScope;
-import java.util.concurrent.StructuredTaskScope.Subtask;
-import java.util.stream.Stream;
-
-/**
- * Centralized concurrency utilities for Spector.
- *
- * <p>Provides a dual-mode execution model controlled by a feature flag:
- * <ul>
- *   <li><b>Structured mode</b> (default): Uses {@link StructuredTaskScope}
- *       from JEP 505 for automatic cancellation propagation and thread-leak prevention.</li>
- *   <li><b>Classic mode</b> (fallback): Uses {@link ExecutorService} with virtual threads,
- *       matching the original behavior.</li>
- * </ul>
- *
- * <h3>Feature Flag</h3>
- * <p>Set {@code -Dspector.concurrency.structured=false} to disable structured concurrency
- * and fall back to the classic {@link ExecutorService} path. By default, structured
- * concurrency is enabled.</p>
- *
- * <h3>Usage</h3>
- * <pre>{@code
- * // Fan out N tasks — all must succeed
- * List<Result> results = ConcurrentTasks.forkJoinAll(List.of(
- *     () -> keywordSearch(query),
- *     () -> vectorSearch(query)
- * ));
- *
- * // Fan out with deadline — partial results accepted
- * var partial = ConcurrentTasks.forkJoinPartial(List.of(
- *     new LabeledTask<>("shard-1", () -> searchShard(s1)),
- *     new LabeledTask<>("shard-2", () -> searchShard(s2))
- * ), Duration.ofSeconds(10));
- * }</pre>
- *
- * @see StructuredTaskScope
- */
-public final class ConcurrentTasks {
-
-    private static final System.Logger log = System.getLogger(ConcurrentTasks.class.getName());
-
-    /**
-     * Feature flag: set to {@code false} to disable structured concurrency.
-     * Defaults to {@code true}.
-     */
-    private static final boolean STRUCTURED_ENABLED =
-            Boolean.parseBoolean(System.getProperty("spector.concurrency.structured", "true"));
-
-    /**
-     * Whether structured concurrency is actually available at runtime.
-     * Checks both the feature flag AND JDK support.
-     */
-    private static final boolean STRUCTURED_AVAILABLE;
-
-    static {
-        boolean available = false;
-        if (STRUCTURED_ENABLED) {
-            try {
-                Class.forName("java.util.concurrent.StructuredTaskScope");
-                available = true;
-            } catch (ClassNotFoundException e) {
-                log.log(System.Logger.Level.INFO,
-                        "StructuredTaskScope not available, falling back to ExecutorService");
-            }
-        } else {
-            log.log(System.Logger.Level.INFO,
-                    "Structured concurrency disabled via spector.concurrency.structured=false");
-        }
-        STRUCTURED_AVAILABLE = available;
-    }
-
-    private ConcurrentTasks() {}
-
-    /**
-     * Returns whether structured concurrency is active.
-     *
-     * @return true if using {@link StructuredTaskScope}, false if using {@link ExecutorService}
-     */
-    public static boolean isStructuredConcurrencyEnabled() {
-        return STRUCTURED_AVAILABLE;
-    }
-
-    // ═══════════════════════════════════════════════════════════════════════
-    //  Fork-Join All: all tasks must succeed (fail-fast with auto-cancel)
-    // ═══════════════════════════════════════════════════════════════════════
-
-    /**
-     * Forks all tasks concurrently and joins them. All must succeed.
-     *
-     * <p>In structured mode, if any task fails, all siblings are automatically cancelled
-     * and a {@link ConcurrentExecutionException} is thrown.</p>
-     *
-     * <p>In classic mode, if any task fails, remaining futures are cancelled manually.</p>
-     *
-     * @param tasks the tasks to execute concurrently
-     * @param <T>   result type
-     * @return list of results in submission order
-     * @throws ConcurrentExecutionException if any task fails
-     * @throws InterruptedException         if the calling thread is interrupted
-     */
-    public static <T> List<T> forkJoinAll(List<Callable<T>> tasks)
-            throws ConcurrentExecutionException, InterruptedException {
-        if (tasks.isEmpty()) return List.of();
-        if (tasks.size() == 1) {
-            try {
-                return List.of(tasks.getFirst().call());
-            } catch (Exception e) {
-                throw new ConcurrentExecutionException("Single task failed", e);
-            }
-        }
-
-        return STRUCTURED_AVAILABLE
-                ? forkJoinAllStructured(tasks)
-                : forkJoinAllClassic(tasks);
-    }
-
-    /**
-     * Convenience overload for exactly two tasks of the same type.
-     *
-     * @return a two-element list [resultA, resultB]
-     */
-    public static <T> List<T> forkJoinAll(Callable<T> taskA, Callable<T> taskB)
-            throws ConcurrentExecutionException, InterruptedException {
-        return forkJoinAll(List.of(taskA, taskB));
-    }
-
-    /**
-     * Optimized two-task fork-join for heterogeneous result types.
-     *
-     * <p>Avoids all list allocations — forks exactly two tasks and returns
-     * a typed pair. This is the hot-path specialization for
-     * {@code HybridSearchOrchestrator} (keyword ∥ vector).</p>
-     *
-     * @param taskA first task
-     * @param taskB second task
-     * @param <A>   result type of first task
-     * @param <B>   result type of second task
-     * @return a {@link Pair} containing both results
-     * @throws ConcurrentExecutionException if either task fails
-     * @throws InterruptedException         if the calling thread is interrupted
-     */
-    public static <A, B> Pair<A, B> forkJoin2(Callable<A> taskA, Callable<B> taskB)
-            throws ConcurrentExecutionException, InterruptedException {
-        return STRUCTURED_AVAILABLE
-                ? forkJoin2Structured(taskA, taskB)
-                : forkJoin2Classic(taskA, taskB);
-    }
-
-    // ── Structured implementation ───────────────────────────────────────
-
-    @SuppressWarnings("preview")
-    private static <T> List<T> forkJoinAllStructured(List<Callable<T>> tasks)
-            throws ConcurrentExecutionException, InterruptedException {
-        try (var scope = StructuredTaskScope.open(
-                StructuredTaskScope.Joiner.<T>awaitAllSuccessfulOrThrow())) {
-            List<Subtask<T>> subtasks = new ArrayList<>(tasks.size());
-            for (Callable<T> task : tasks) {
-                subtasks.add(scope.fork(task::call));
-            }
-            scope.join(); // auto-cancels siblings on first failure
-
-            // Direct loop — avoids Stream/Iterator/intermediate list allocation
-            List<T> results = new ArrayList<>(subtasks.size());
-            for (Subtask<T> st : subtasks) {
-                results.add(st.get());
-            }
-            return results;
-        } catch (StructuredTaskScope.FailedException e) {
-            throw new ConcurrentExecutionException("Structured fork-join failed", e.getCause());
-        }
-    }
-
-    @SuppressWarnings({"preview", "unchecked"})
-    private static <A, B> Pair<A, B> forkJoin2Structured(Callable<A> taskA, Callable<B> taskB)
-            throws ConcurrentExecutionException, InterruptedException {
-        try (var scope = StructuredTaskScope.open(
-                StructuredTaskScope.Joiner.awaitAllSuccessfulOrThrow())) {
-            Subtask<A> a = scope.fork(taskA::call);
-            Subtask<B> b = scope.fork(taskB::call);
-            scope.join();
-            return new Pair<>(a.get(), b.get());
-        } catch (StructuredTaskScope.FailedException e) {
-            throw new ConcurrentExecutionException("Structured fork-join failed", e.getCause());
-        }
-    }
-
-    private static <A, B> Pair<A, B> forkJoin2Classic(Callable<A> taskA, Callable<B> taskB)
-            throws ConcurrentExecutionException, InterruptedException {
-        try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {
-            Future<A> futureA = executor.submit(taskA);
-            Future<B> futureB = executor.submit(taskB);
-            try {
-                return new Pair<>(futureA.get(), futureB.get());
-            } catch (java.util.concurrent.ExecutionException e) {
-                futureA.cancel(true);
-                futureB.cancel(true);
-                throw new ConcurrentExecutionException("Task failed", e.getCause());
-            }
-        }
-    }
-
-    // ── Classic (ExecutorService) implementation ─────────────────────────
-
-    private static <T> List<T> forkJoinAllClassic(List<Callable<T>> tasks)
-            throws ConcurrentExecutionException, InterruptedException {
-        try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {
-            List<Future<T>> futures = new ArrayList<>(tasks.size());
-            for (Callable<T> task : tasks) {
-                futures.add(executor.submit(task));
-            }
-
-            List<T> results = new ArrayList<>(tasks.size());
-            Exception firstFailure = null;
-            int failIndex = -1;
-
-            for (int i = 0; i < futures.size(); i++) {
-                try {
-                    results.add(futures.get(i).get());
-                } catch (ExecutionException e) {
-                    if (firstFailure == null) {
-                        firstFailure = e;
-                        failIndex = i;
-                        // Cancel remaining
-                        for (int j = i + 1; j < futures.size(); j++) {
-                            futures.get(j).cancel(true);
-                        }
-                    }
-                    results.add(null); // placeholder
-                }
-            }
-
-            if (firstFailure != null) {
-                throw new ConcurrentExecutionException(
-                        "Task " + failIndex + " failed", firstFailure.getCause());
-            }
-            return results;
-        }
-    }
-
-    // ═══════════════════════════════════════════════════════════════════════
-    //  Fork-Join Partial: deadline-based, collects successful + failed
-    // ═══════════════════════════════════════════════════════════════════════
-
-    /**
-     * Forks all tasks concurrently and joins with a deadline.
-     * Returns partial results for tasks that completed, and reports
-     * timed-out and failed tasks separately.
-     *
-     * @param tasks   the tasks to execute (each identified by a label)
-     * @param timeout maximum time to wait for all tasks
-     * @param <T>     result type
-     * @return a {@link PartialResult} containing successes, timeouts, and failures
-     * @throws InterruptedException if the calling thread is interrupted
-     */
-    public static <T> PartialResult<T> forkJoinPartial(
-            List<LabeledTask<T>> tasks, Duration timeout) throws InterruptedException {
-        if (tasks.isEmpty()) return PartialResult.empty();
-
-        return STRUCTURED_AVAILABLE
-                ? forkJoinPartialStructured(tasks, timeout)
-                : forkJoinPartialClassic(tasks, timeout);
-    }
-
-    // ── Structured implementation ───────────────────────────────────────
-
-    @SuppressWarnings("preview")
-    private static <T> PartialResult<T> forkJoinPartialStructured(
-            List<LabeledTask<T>> tasks, Duration timeout) throws InterruptedException {
-        // Use awaitAll() joiner (never auto-cancels) + Configuration.withTimeout()
-        try (var scope = StructuredTaskScope.open(
-                StructuredTaskScope.Joiner.<T>awaitAll(),
-                cf -> cf.withTimeout(timeout))) {
-
-            List<Subtask<T>> subtasks = new ArrayList<>(tasks.size());
-            for (LabeledTask<T> task : tasks) {
-                subtasks.add(scope.fork(task.callable()::call));
-            }
-
-            try {
-                scope.join();
-            } catch (StructuredTaskScope.TimeoutException e) {
-                // Expected — some tasks didn't finish within the deadline
-            }
-
-            // Inspect subtask states after join — pre-sized to avoid resize
-            int n = subtasks.size();
-            List<PartialResult.Entry<T>> successes = new ArrayList<>(n);
-            List<String> timedOut = new ArrayList<>(n);
-            List<PartialResult.Failure> failures = new ArrayList<>(n);
-
-            for (int i = 0; i < subtasks.size(); i++) {
-                Subtask<T> subtask = subtasks.get(i);
-                String label = tasks.get(i).label();
-                switch (subtask.state()) {
-                    case SUCCESS -> successes.add(new PartialResult.Entry<>(label, subtask.get()));
-                    case FAILED -> failures.add(new PartialResult.Failure(label, subtask.exception()));
-                    case UNAVAILABLE -> timedOut.add(label);
-                }
-            }
-            return new PartialResult<>(successes, timedOut, failures);
-        }
-    }
-
-    // ── Classic implementation ──────────────────────────────────────────
-
-    private static <T> PartialResult<T> forkJoinPartialClassic(
-            List<LabeledTask<T>> tasks, Duration timeout) throws InterruptedException {
-        try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {
-            record FutureEntry<T>(String label, Future<T> future) {}
-            List<FutureEntry<T>> entries = new ArrayList<>(tasks.size());
-
-            for (LabeledTask<T> task : tasks) {
-                entries.add(new FutureEntry<>(task.label(), executor.submit(task.callable())));
-            }
-
-            int n = entries.size();
-            List<PartialResult.Entry<T>> successes = new ArrayList<>(n);
-            List<String> timedOut = new ArrayList<>(n);
-            List<PartialResult.Failure> failures = new ArrayList<>(n);
-
-            long deadlineMs = System.currentTimeMillis() + timeout.toMillis();
-
-            for (FutureEntry<T> entry : entries) {
-                long remaining = deadlineMs - System.currentTimeMillis();
-                if (remaining <= 0) {
-                    timedOut.add(entry.label());
-                    entry.future().cancel(true);
-                    continue;
-                }
-                try {
-                    T result = entry.future().get(remaining, java.util.concurrent.TimeUnit.MILLISECONDS);
-                    successes.add(new PartialResult.Entry<>(entry.label(), result));
-                } catch (java.util.concurrent.TimeoutException e) {
-                    timedOut.add(entry.label());
-                    entry.future().cancel(true);
-                } catch (ExecutionException e) {
-                    failures.add(new PartialResult.Failure(entry.label(), e.getCause()));
-                }
-            }
-
-            return new PartialResult<>(successes, timedOut, failures);
-        }
-    }
-
-    // ═══════════════════════════════════════════════════════════════════════
-    //  Supporting types
-    // ═══════════════════════════════════════════════════════════════════════
-
-    /**
-     * A typed pair of results from {@link #forkJoin2}.
-     *
-     * <p>Zero-overhead alternative to {@code List<T>} when exactly two tasks
-     * with potentially different result types are forked concurrently.
-     * Avoids list allocation, iterator creation, and index-based access.</p>
-     *
-     * @param first  result of the first task
-     * @param second result of the second task
-     * @param <A>    type of first result
-     * @param <B>    type of second result
-     */
-    public record Pair<A, B>(A first, B second) {}
-
-    /**
-     * A labeled task for use with {@link #forkJoinPartial}.
-     *
-     * @param label    human-readable identifier (e.g., shard ID)
-     * @param callable the work to execute
-     * @param <T>      result type
-     */
-    public record LabeledTask<T>(String label, Callable<T> callable) {
-        public LabeledTask {
-            if (label == null) { throw new SpectorValidationException(ErrorCode.ARGUMENT_NULL, "label"); }
-            if (callable == null) { throw new SpectorValidationException(ErrorCode.ARGUMENT_NULL, "callable"); }
-        }
-    }
-
-    /**
-     * Result of a partial fork-join with deadline. Contains successful results,
-     * timed-out task labels, and failed task details.
-     *
-     * @param <T> the result type of successful tasks
-     */
-    public record PartialResult<T>(
-            List<Entry<T>> successes,
-            List<String> timedOut,
-            List<Failure> failures
-    ) {
-        /** A successful result with its task label. */
-        public record Entry<T>(String label, T result) {}
-
-        /** A failed task with its label and cause. */
-        public record Failure(String label, Throwable cause) {}
-
-        /** Returns true if all tasks completed successfully (no timeouts or failures). */
-        public boolean isComplete() {
-            return timedOut.isEmpty() && failures.isEmpty();
-        }
-
-        /** Returns true if no tasks succeeded at all. */
-        public boolean allFailed() {
-            return successes.isEmpty();
-        }
-
-        /** Returns the combined list of timed-out and failed task labels. */
-        public List<String> unreachableLabels() {
-            List<String> result = new ArrayList<>(timedOut);
-            for (Failure f : failures) result.add(f.label());
-            return result;
-        }
-
-        static <T> PartialResult<T> empty() {
-            return new PartialResult<>(List.of(), List.of(), List.of());
-        }
-    }
-}
diff --git a/spector-commons/src/main/java/com/spectrayan/spector/commons/concurrent/MemoryPinning.java b/spector-commons/src/main/java/com/spectrayan/spector/commons/concurrent/MemoryPinning.java
deleted file mode 100644
index ba6bb5f..0000000
--- a/spector-commons/src/main/java/com/spectrayan/spector/commons/concurrent/MemoryPinning.java
+++ /dev/null
@@ -1,180 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.commons.concurrent;
-
-import java.lang.foreign.*;
-import java.lang.invoke.MethodHandle;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-/**
- * Utility for pinning memory-mapped memory segments to physical RAM
- * to prevent cold starts, page cache thrashing, and OS swapping.
- * Uses native OS-level mlock/munlock on Linux/POSIX and VirtualLock/VirtualUnlock on Windows.
- */
-public final class MemoryPinning {
-
-    private static final Logger log = LoggerFactory.getLogger(MemoryPinning.class);
-
-    private static final MethodHandle LOCK_HANDLE;
-    private static final MethodHandle UNLOCK_HANDLE;
-    private static final boolean WINDOWS;
-
-    private static final java.util.concurrent.atomic.AtomicLong pinnedBytes = new java.util.concurrent.atomic.AtomicLong(0);
-
-    static {
-        Linker linker = Linker.nativeLinker();
-        MethodHandle lock = null;
-        MethodHandle unlock = null;
-        boolean isWin = false;
-
-        String os = System.getProperty("os.name", "").toLowerCase();
-        if (os.contains("win")) {
-            isWin = true;
-            try {
-                // Windows kernel32 symbols
-                SymbolLookup kernel32 = SymbolLookup.libraryLookup("kernel32", Arena.global());
-                lock = kernel32.find("VirtualLock").map(addr -> linker.downcallHandle(
-                    addr,
-                    FunctionDescriptor.of(ValueLayout.JAVA_INT, ValueLayout.ADDRESS, ValueLayout.JAVA_LONG)
-                )).orElse(null);
-
-                unlock = kernel32.find("VirtualUnlock").map(addr -> linker.downcallHandle(
-                    addr,
-                    FunctionDescriptor.of(ValueLayout.JAVA_INT, ValueLayout.ADDRESS, ValueLayout.JAVA_LONG)
-                )).orElse(null);
-
-                if (lock != null && unlock != null) {
-                    log.info("MemoryPinning: Successfully bound Windows VirtualLock/VirtualUnlock");
-                }
-            } catch (Exception e) {
-                log.warn("MemoryPinning: Failed to load Windows kernel32 symbols", e);
-            }
-        } else {
-            // Linux/macOS/POSIX symbols from standard libc
-            try {
-                SymbolLookup libc = linker.defaultLookup();
-                lock = libc.find("mlock").map(addr -> linker.downcallHandle(
-                    addr,
-                    FunctionDescriptor.of(ValueLayout.JAVA_INT, ValueLayout.ADDRESS, ValueLayout.JAVA_LONG)
-                )).orElse(null);
-
-                unlock = libc.find("munlock").map(addr -> linker.downcallHandle(
-                    addr,
-                    FunctionDescriptor.of(ValueLayout.JAVA_INT, ValueLayout.ADDRESS, ValueLayout.JAVA_LONG)
-                )).orElse(null);
-
-                if (lock != null && unlock != null) {
-                    log.info("MemoryPinning: Successfully bound POSIX mlock/munlock");
-                }
-            } catch (Exception e) {
-                log.warn("MemoryPinning: Failed to load POSIX symbols from libc", e);
-            }
-        }
-
-        LOCK_HANDLE = lock;
-        UNLOCK_HANDLE = unlock;
-        WINDOWS = isWin;
-    }
-
-    private MemoryPinning() {}
-
-    /**
-     * Returns the total off-heap memory bytes successfully pinned in physical RAM.
-     */
-    public static long pinnedBytes() {
-        return pinnedBytes.get();
-    }
-
-    /**
-     * Pins the memory segment to physical RAM, preventing it from being swapped or paged out.
-     *
-     * @param segment the memory segment to lock
-     * @return true if successfully locked, false otherwise
-     */
-    public static boolean lock(MemorySegment segment) {
-        if (segment == null || !segment.isMapped()) {
-            return false;
-        }
-
-        if (LOCK_HANDLE == null) {
-            log.warn("MemoryPinning: Lock handle is not available on this platform.");
-            return false;
-        }
-
-        try {
-            int result = (int) LOCK_HANDLE.invokeExact(segment.address(), segment.byteSize());
-            if (WINDOWS) {
-                // Windows VirtualLock returns non-zero (true) on success
-                if (result != 0) {
-                    log.debug("VirtualLock: Locked off-heap segment at address {} ({} bytes)", segment.address(), segment.byteSize());
-                    pinnedBytes.addAndGet(segment.byteSize());
-                    return true;
-                } else {
-                    log.warn("VirtualLock failed. Ensure working set size limits are sufficient on Windows.");
-                }
-            } else {
-                // POSIX mlock returns 0 on success
-                if (result == 0) {
-                    log.debug("mlock: Locked off-heap segment at address {} ({} bytes)", segment.address(), segment.byteSize());
-                    pinnedBytes.addAndGet(segment.byteSize());
-                    return true;
-                } else {
-                    log.warn("mlock failed with return code {}. Ensure sufficient locked memory limits (ulimit -l / CAP_SYS_RESOURCE).", result);
-                }
-            }
-        } catch (Throwable t) {
-            log.warn("MemoryPinning: Failed to pin memory segment: {}", t.getMessage());
-        }
-        return false;
-    }
-
-    /**
-     * Unlocks the memory segment, allowing the operating system to page or swap it out.
-     *
-     * @param segment the memory segment to unlock
-     * @return true if successfully unlocked, false otherwise
-     */
-    public static boolean unlock(MemorySegment segment) {
-        if (segment == null || !segment.isMapped()) {
-            return false;
-        }
-
-        if (UNLOCK_HANDLE == null) {
-            return false;
-        }
-
-        try {
-            int result = (int) UNLOCK_HANDLE.invokeExact(segment.address(), segment.byteSize());
-            if (WINDOWS) {
-                if (result != 0) {
-                    log.debug("VirtualUnlock: Unlocked off-heap segment at address {}", segment.address());
-                    pinnedBytes.addAndGet(-segment.byteSize());
-                    return true;
-                }
-            } else {
-                if (result == 0) {
-                    log.debug("munlock: Unlocked off-heap segment at address {}", segment.address());
-                    pinnedBytes.addAndGet(-segment.byteSize());
-                    return true;
-                }
-            }
-        } catch (Throwable t) {
-            log.warn("MemoryPinning: Failed to unpin memory segment: {}", t.getMessage());
-        }
-        return false;
-    }
-}
diff --git a/spector-commons/src/main/java/com/spectrayan/spector/commons/concurrent/NativeOsMemory.java b/spector-commons/src/main/java/com/spectrayan/spector/commons/concurrent/NativeOsMemory.java
deleted file mode 100644
index f3def29..0000000
--- a/spector-commons/src/main/java/com/spectrayan/spector/commons/concurrent/NativeOsMemory.java
+++ /dev/null
@@ -1,102 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.commons.concurrent;
-
-import java.lang.foreign.*;
-import java.lang.invoke.MethodHandle;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-/**
- * Utility for executing low-level native OS page cache operations using Java Panama FFM API.
- * Primarily binds POSIX madvise(2) on Linux/Unix systems with safe cross-platform no-ops on Windows.
- */
-public final class NativeOsMemory {
-
-    private static final Logger log = LoggerFactory.getLogger(NativeOsMemory.class);
-
-    // POSIX madvise constants
-    public static final int MADV_NORMAL = 0;
-    public static final int MADV_RANDOM = 1;
-    public static final int MADV_SEQUENTIAL = 2;
-    public static final int MADV_WILLNEED = 3;
-    public static final int MADV_DONTNEED = 4;
-
-    private static final MethodHandle MADVISE_HANDLE;
-
-    static {
-        Linker linker = Linker.nativeLinker();
-        MethodHandle madvise = null;
-
-        String os = System.getProperty("os.name", "").toLowerCase();
-        if (!os.contains("win")) {
-            try {
-                // POSIX default symbols from standard libc
-                SymbolLookup libc = linker.defaultLookup();
-                madvise = libc.find("madvise").map(addr -> linker.downcallHandle(
-                    addr,
-                    FunctionDescriptor.of(ValueLayout.JAVA_INT, ValueLayout.ADDRESS, ValueLayout.JAVA_LONG, ValueLayout.JAVA_INT)
-                )).orElse(null);
-
-                if (madvise != null) {
-                    log.info("NativeOsMemory: Successfully bound POSIX madvise(2)");
-                } else {
-                    log.warn("NativeOsMemory: POSIX madvise(2) symbol not found in standard libc");
-                }
-            } catch (Exception e) {
-                log.warn("NativeOsMemory: Failed to bind POSIX madvise(2)", e);
-            }
-        } else {
-            log.debug("NativeOsMemory: Running on Windows. Dynamic OS paging optimizations will use safe no-ops.");
-        }
-
-        MADVISE_HANDLE = madvise;
-    }
-
-    private NativeOsMemory() {}
-
-    /**
-     * Executes the POSIX madvise(2) system call on a mapped memory segment.
-     *
-     * @param segment the memory-mapped segment
-     * @param advice  the advice constant (e.g. MADV_WILLNEED, MADV_DONTNEED)
-     * @return true if successful or if operating on a platform where madvise is a safe no-op; false on error
-     */
-    public static boolean advise(MemorySegment segment, int advice) {
-        if (segment == null || !segment.isMapped()) {
-            return false;
-        }
-
-        if (MADVISE_HANDLE == null) {
-            log.trace("NativeOsMemory: Paging advice {} requested, but native handle is unavailable (safe no-op).", advice);
-            return true; 
-        }
-
-        try {
-            int result = (int) MADVISE_HANDLE.invokeExact(segment.address(), segment.byteSize(), advice);
-            if (result == 0) {
-                log.debug("madvise: Successfully applied advice {} on segment at address {} ({} bytes)", advice, segment.address(), segment.byteSize());
-                return true;
-            } else {
-                log.warn("madvise: Failed with code {} for advice {} on segment at address {}", result, advice, segment.address());
-                return false;
-            }
-        } catch (Throwable t) {
-            log.warn("NativeOsMemory: Failed to invoke native madvise: {}", t.getMessage());
-            return false;
-        }
-    }
-}
diff --git a/spector-commons/src/main/java/com/spectrayan/spector/commons/document/DocumentMetadata.java b/spector-commons/src/main/java/com/spectrayan/spector/commons/document/DocumentMetadata.java
index c750f7c..e825bb5 100644
--- a/spector-commons/src/main/java/com/spectrayan/spector/commons/document/DocumentMetadata.java
+++ b/spector-commons/src/main/java/com/spectrayan/spector/commons/document/DocumentMetadata.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.commons.document;
 
 /**
diff --git a/spector-commons/src/main/java/com/spectrayan/spector/commons/document/DocumentReadException.java b/spector-commons/src/main/java/com/spectrayan/spector/commons/document/DocumentReadException.java
new file mode 100644
index 0000000..3b8f221
--- /dev/null
+++ b/spector-commons/src/main/java/com/spectrayan/spector/commons/document/DocumentReadException.java
@@ -0,0 +1,33 @@
+package com.spectrayan.spector.commons.document;
+
+/**
+ * Exception thrown when a document cannot be read or processed.
+ *
+ * <p>This exception carries information about the file that failed and the
+ * nature of the failure, without terminating the pipeline.</p>
+ */
+public class DocumentReadException extends RuntimeException {
+
+    private final String fileName;
+    private final String reason;
+
+    public DocumentReadException(String fileName, String reason) {
+        super("Failed to read document '%s': %s".formatted(fileName, reason));
+        this.fileName = fileName;
+        this.reason = reason;
+    }
+
+    public DocumentReadException(String fileName, String reason, Throwable cause) {
+        super("Failed to read document '%s': %s".formatted(fileName, reason), cause);
+        this.fileName = fileName;
+        this.reason = reason;
+    }
+
+    public String getFileName() {
+        return fileName;
+    }
+
+    public String getReason() {
+        return reason;
+    }
+}
diff --git a/spector-commons/src/main/java/com/spectrayan/spector/commons/document/DocumentReader.java b/spector-commons/src/main/java/com/spectrayan/spector/commons/document/DocumentReader.java
index 02436da..a075e43 100644
--- a/spector-commons/src/main/java/com/spectrayan/spector/commons/document/DocumentReader.java
+++ b/spector-commons/src/main/java/com/spectrayan/spector/commons/document/DocumentReader.java
@@ -1,22 +1,5 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.commons.document;
 
-import com.spectrayan.spector.commons.error.SpectorDocumentReadException;
-
 import java.nio.file.Path;
 
 /**
@@ -32,9 +15,9 @@ public interface DocumentReader {
      *
      * @param file the path to the document file
      * @return the extracted text and metadata
-     * @throws SpectorDocumentReadException if the file cannot be read or is in an unsupported format
+     * @throws DocumentReadException if the file cannot be read or is in an unsupported format
      */
-    DocumentResult read(Path file) throws SpectorDocumentReadException;
+    DocumentResult read(Path file) throws DocumentReadException;
 
     /**
      * Returns the format this reader supports.
diff --git a/spector-commons/src/main/java/com/spectrayan/spector/commons/document/DocumentReaderFactory.java b/spector-commons/src/main/java/com/spectrayan/spector/commons/document/DocumentReaderFactory.java
index 1ceb511..de8322b 100644
--- a/spector-commons/src/main/java/com/spectrayan/spector/commons/document/DocumentReaderFactory.java
+++ b/spector-commons/src/main/java/com/spectrayan/spector/commons/document/DocumentReaderFactory.java
@@ -1,22 +1,5 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.commons.document;
 
-import com.spectrayan.spector.commons.error.SpectorDocumentReadException;
-
 import java.nio.file.Path;
 import java.util.List;
 import java.util.Locale;
@@ -47,15 +30,15 @@ private DocumentReaderFactory() {
      *
      * @param file the path to the document
      * @return the reader for the detected format
-     * @throws SpectorDocumentReadException if the format is unsupported
+     * @throws DocumentReadException if the format is unsupported
      */
-    public static DocumentReader getReader(Path file) throws SpectorDocumentReadException {
+    public static DocumentReader getReader(Path file) throws DocumentReadException {
         String fileName = file.getFileName().toString();
         String extension = getExtension(fileName).toLowerCase(Locale.ROOT);
 
         DocumentReader reader = READERS.get(extension);
         if (reader == null) {
-            throw new SpectorDocumentReadException(fileName,
+            throw new DocumentReadException(fileName,
                     "unsupported format '.%s'. Supported formats: %s".formatted(extension, SUPPORTED_FORMATS));
         }
         return reader;
@@ -66,9 +49,9 @@ public static DocumentReader getReader(Path file) throws SpectorDocumentReadExce
      *
      * @param file the path to the document
      * @return the extracted text and metadata
-     * @throws SpectorDocumentReadException if the format is unsupported or the file cannot be read
+     * @throws DocumentReadException if the format is unsupported or the file cannot be read
      */
-    public static DocumentResult read(Path file) throws SpectorDocumentReadException {
+    public static DocumentResult read(Path file) throws DocumentReadException {
         return getReader(file).read(file);
     }
 
@@ -82,7 +65,7 @@ public static List<String> supportedFormats() {
     private static String getExtension(String fileName) {
         int lastDot = fileName.lastIndexOf('.');
         if (lastDot < 0 || lastDot == fileName.length() - 1) {
-            throw new SpectorDocumentReadException(fileName,
+            throw new DocumentReadException(fileName,
                     "unsupported format (no file extension). Supported formats: " + SUPPORTED_FORMATS);
         }
         return fileName.substring(lastDot + 1);
diff --git a/spector-commons/src/main/java/com/spectrayan/spector/commons/document/DocumentResult.java b/spector-commons/src/main/java/com/spectrayan/spector/commons/document/DocumentResult.java
index 3087253..9544d12 100644
--- a/spector-commons/src/main/java/com/spectrayan/spector/commons/document/DocumentResult.java
+++ b/spector-commons/src/main/java/com/spectrayan/spector/commons/document/DocumentResult.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.commons.document;
 
 /**
diff --git a/spector-commons/src/main/java/com/spectrayan/spector/commons/document/HtmlDocumentReader.java b/spector-commons/src/main/java/com/spectrayan/spector/commons/document/HtmlDocumentReader.java
index 6343e32..4d4f518 100644
--- a/spector-commons/src/main/java/com/spectrayan/spector/commons/document/HtmlDocumentReader.java
+++ b/spector-commons/src/main/java/com/spectrayan/spector/commons/document/HtmlDocumentReader.java
@@ -1,22 +1,5 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.commons.document;
 
-import com.spectrayan.spector.commons.error.SpectorDocumentReadException;
-
 import java.io.IOException;
 import java.nio.charset.StandardCharsets;
 import java.nio.file.Files;
@@ -63,7 +46,7 @@ public final class HtmlDocumentReader implements DocumentReader {
     private static final Pattern HTML_ENTITY = Pattern.compile("&(amp|lt|gt|quot|apos|nbsp|#\\d+|#x[0-9a-fA-F]+);");
 
     @Override
-    public DocumentResult read(Path file) throws SpectorDocumentReadException {
+    public DocumentResult read(Path file) throws DocumentReadException {
         String fileName = file.getFileName().toString();
 
         validateFile(file, fileName);
@@ -73,18 +56,18 @@ public DocumentResult read(Path file) throws SpectorDocumentReadException {
             String text = extractText(html);
 
             if (text.isEmpty()) {
-                throw new SpectorDocumentReadException(fileName, "HTML contains no extractable text");
+                throw new DocumentReadException(fileName, "HTML contains no extractable text");
             }
 
             var metadata = new DocumentMetadata(fileName, "HTML", text.length());
             return new DocumentResult(text, metadata);
 
-        } catch (SpectorDocumentReadException e) {
+        } catch (DocumentReadException e) {
             throw e;
         } catch (IOException e) {
-            throw new SpectorDocumentReadException(fileName, "unable to read HTML file", e);
+            throw new DocumentReadException(fileName, "unable to read HTML file", e);
         } catch (Exception e) {
-            throw new SpectorDocumentReadException(fileName,
+            throw new DocumentReadException(fileName,
                     "unexpected error reading HTML: " + e.getMessage(), e);
         }
     }
@@ -96,16 +79,16 @@ public String supportedFormat() {
 
     private void validateFile(Path file, String fileName) {
         if (!Files.exists(file)) {
-            throw new SpectorDocumentReadException(fileName, "file does not exist");
+            throw new DocumentReadException(fileName, "file does not exist");
         }
         try {
             long size = Files.size(file);
             if (size > MAX_FILE_SIZE) {
-                throw new SpectorDocumentReadException(fileName,
+                throw new DocumentReadException(fileName,
                         "file size %d bytes exceeds the 100 MB limit".formatted(size));
             }
         } catch (IOException e) {
-            throw new SpectorDocumentReadException(fileName, "unable to determine file size", e);
+            throw new DocumentReadException(fileName, "unable to determine file size", e);
         }
     }
 
diff --git a/spector-commons/src/main/java/com/spectrayan/spector/commons/document/MarkdownDocumentReader.java b/spector-commons/src/main/java/com/spectrayan/spector/commons/document/MarkdownDocumentReader.java
index e0bf244..136fe73 100644
--- a/spector-commons/src/main/java/com/spectrayan/spector/commons/document/MarkdownDocumentReader.java
+++ b/spector-commons/src/main/java/com/spectrayan/spector/commons/document/MarkdownDocumentReader.java
@@ -1,22 +1,5 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.commons.document;
 
-import com.spectrayan.spector.commons.error.SpectorDocumentReadException;
-
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -49,7 +32,7 @@ public final class MarkdownDocumentReader implements DocumentReader {
     private static final Pattern HTML_TAG = Pattern.compile("<[^>]+>");
 
     @Override
-    public DocumentResult read(Path file) throws SpectorDocumentReadException {
+    public DocumentResult read(Path file) throws DocumentReadException {
         String fileName = file.getFileName().toString();
 
         validateFile(file, fileName);
@@ -59,18 +42,18 @@ public DocumentResult read(Path file) throws SpectorDocumentReadException {
             String text = extractText(content);
 
             if (text.isEmpty()) {
-                throw new SpectorDocumentReadException(fileName, "Markdown contains no extractable text");
+                throw new DocumentReadException(fileName, "Markdown contains no extractable text");
             }
 
             var metadata = new DocumentMetadata(fileName, "MARKDOWN", text.length());
             return new DocumentResult(text, metadata);
 
-        } catch (SpectorDocumentReadException e) {
+        } catch (DocumentReadException e) {
             throw e;
         } catch (IOException e) {
-            throw new SpectorDocumentReadException(fileName, "unable to read Markdown file", e);
+            throw new DocumentReadException(fileName, "unable to read Markdown file", e);
         } catch (Exception e) {
-            throw new SpectorDocumentReadException(fileName,
+            throw new DocumentReadException(fileName,
                     "unexpected error reading Markdown: " + e.getMessage(), e);
         }
     }
@@ -82,16 +65,16 @@ public String supportedFormat() {
 
     private void validateFile(Path file, String fileName) {
         if (!Files.exists(file)) {
-            throw new SpectorDocumentReadException(fileName, "file does not exist");
+            throw new DocumentReadException(fileName, "file does not exist");
         }
         try {
             long size = Files.size(file);
             if (size > MAX_FILE_SIZE) {
-                throw new SpectorDocumentReadException(fileName,
+                throw new DocumentReadException(fileName,
                         "file size %d bytes exceeds the 100 MB limit".formatted(size));
             }
         } catch (IOException e) {
-            throw new SpectorDocumentReadException(fileName, "unable to determine file size", e);
+            throw new DocumentReadException(fileName, "unable to determine file size", e);
         }
     }
 
diff --git a/spector-commons/src/main/java/com/spectrayan/spector/commons/document/PdfDocumentReader.java b/spector-commons/src/main/java/com/spectrayan/spector/commons/document/PdfDocumentReader.java
index b7b988e..621dc48 100644
--- a/spector-commons/src/main/java/com/spectrayan/spector/commons/document/PdfDocumentReader.java
+++ b/spector-commons/src/main/java/com/spectrayan/spector/commons/document/PdfDocumentReader.java
@@ -1,22 +1,5 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.commons.document;
 
-import com.spectrayan.spector.commons.error.SpectorDocumentReadException;
-
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
@@ -62,7 +45,7 @@ public final class PdfDocumentReader implements DocumentReader {
             "(-?[\\d.]+)\\s+(-?[\\d.]+)\\s+Td");
 
     @Override
-    public DocumentResult read(Path file) throws SpectorDocumentReadException {
+    public DocumentResult read(Path file) throws DocumentReadException {
         String fileName = file.getFileName().toString();
 
         validateFile(file, fileName);
@@ -73,18 +56,18 @@ public DocumentResult read(Path file) throws SpectorDocumentReadException {
             String text = extractText(content);
 
             if (text.isEmpty()) {
-                throw new SpectorDocumentReadException(fileName, "PDF contains no extractable text");
+                throw new DocumentReadException(fileName, "PDF contains no extractable text");
             }
 
             var metadata = new DocumentMetadata(fileName, "PDF", text.length());
             return new DocumentResult(text, metadata);
 
-        } catch (SpectorDocumentReadException e) {
+        } catch (DocumentReadException e) {
             throw e;
         } catch (IOException e) {
-            throw new SpectorDocumentReadException(fileName, "corrupted or unreadable PDF file", e);
+            throw new DocumentReadException(fileName, "corrupted or unreadable PDF file", e);
         } catch (Exception e) {
-            throw new SpectorDocumentReadException(fileName,
+            throw new DocumentReadException(fileName,
                     "unexpected error reading PDF: " + e.getMessage(), e);
         }
     }
@@ -96,16 +79,16 @@ public String supportedFormat() {
 
     private void validateFile(Path file, String fileName) {
         if (!Files.exists(file)) {
-            throw new SpectorDocumentReadException(fileName, "file does not exist");
+            throw new DocumentReadException(fileName, "file does not exist");
         }
         try {
             long size = Files.size(file);
             if (size > MAX_FILE_SIZE) {
-                throw new SpectorDocumentReadException(fileName,
+                throw new DocumentReadException(fileName,
                         "file size %d bytes exceeds the 100 MB limit".formatted(size));
             }
         } catch (IOException e) {
-            throw new SpectorDocumentReadException(fileName, "unable to determine file size", e);
+            throw new DocumentReadException(fileName, "unable to determine file size", e);
         }
     }
 
@@ -113,18 +96,18 @@ private void validatePdfFormat(Path file, String fileName) {
         try (RandomAccessFile raf = new RandomAccessFile(file.toFile(), "r")) {
             byte[] header = new byte[5];
             if (raf.read(header) < 5) {
-                throw new SpectorDocumentReadException(fileName, "file is too small to be a valid PDF");
+                throw new DocumentReadException(fileName, "file is too small to be a valid PDF");
             }
             for (int i = 0; i < PDF_HEADER.length; i++) {
                 if (header[i] != PDF_HEADER[i]) {
-                    throw new SpectorDocumentReadException(fileName,
+                    throw new DocumentReadException(fileName,
                             "corrupted or unreadable PDF file (invalid header)");
                 }
             }
-        } catch (SpectorDocumentReadException e) {
+        } catch (DocumentReadException e) {
             throw e;
         } catch (IOException e) {
-            throw new SpectorDocumentReadException(fileName, "corrupted or unreadable PDF file", e);
+            throw new DocumentReadException(fileName, "corrupted or unreadable PDF file", e);
         }
     }
 
diff --git a/spector-commons/src/main/java/com/spectrayan/spector/commons/error/ErrorCategory.java b/spector-commons/src/main/java/com/spectrayan/spector/commons/error/ErrorCategory.java
deleted file mode 100644
index a47387f..0000000
--- a/spector-commons/src/main/java/com/spectrayan/spector/commons/error/ErrorCategory.java
+++ /dev/null
@@ -1,114 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.commons.error;
-
-/**
- * Error categories for the Spector exception framework.
- *
- * <p>Each category owns a range of numeric codes in the {@code SPE-XXX-YYY} schema,
- * where the category prefix ({@code XXX}) identifies the subsystem and the suffix
- * ({@code YYY}) identifies the specific error within that subsystem.</p>
- *
- * <p>Categories are grouped by hundreds for logical affinity:
- * <ul>
- *   <li>{@code 1xx} — Input and configuration</li>
- *   <li>{@code 2xx} — Index and storage</li>
- *   <li>{@code 3xx} — Embedding and cognitive memory</li>
- *   <li>{@code 4xx} — GPU and hardware</li>
- *   <li>{@code 5xx} — Server and client transport</li>
- *   <li>{@code 6xx} — Ingestion pipeline</li>
- *   <li>{@code 7xx} — Cluster and distribution</li>
- *   <li>{@code 8xx} — Reserved for future expansion</li>
- *   <li>{@code 9xx} — Internal / framework</li>
- * </ul>
- *
- * @see ErrorCode
- * @see SpectorException
- */
-public enum ErrorCategory {
-
-    /** Input validation failures — bad arguments, null values, range violations. */
-    VALIDATION  ("Validation",     100, 109),
-
-    /** Configuration loading, parsing, and value validation errors. */
-    CONFIG      ("Configuration",  110, 119),
-
-    /** Index construction, search, persistence, and integrity errors. */
-    INDEX       ("Index",          200, 209),
-
-    /** Vector store, memory-mapped I/O, off-heap segment, and disk errors. */
-    STORAGE     ("Storage",        210, 219),
-
-    /** Embedding provider communication, model, and timeout errors. */
-    EMBEDDING   ("Embedding",      300, 309),
-
-    /** Cognitive memory tier, scoring pipeline, and WAL errors. */
-    MEMORY      ("Memory",         310, 319),
-
-    /** CUDA driver, GPU memory allocation, and kernel launch errors. */
-    GPU         ("GPU",            400, 409),
-
-    /** REST API, gRPC, and MCP transport errors. */
-    SERVER      ("Server",         500, 509),
-
-    /** Client SDK communication and response parsing errors. */
-    CLIENT      ("Client",         510, 519),
-
-    /** Document parsing, chunking, and ingestion pipeline errors. */
-    INGESTION   ("Ingestion",      600, 609),
-
-    /** Distributed mode — sharding, routing, and membership errors. */
-    CLUSTER     ("Cluster",        700, 709),
-
-    /** Internal bugs, invariant violations, and unreachable code paths. */
-    INTERNAL    ("Internal",       900, 909);
-
-    private final String displayName;
-    private final int rangeStart;
-    private final int rangeEnd;
-
-    ErrorCategory(String displayName, int rangeStart, int rangeEnd) {
-        this.displayName = displayName;
-        this.rangeStart = rangeStart;
-        this.rangeEnd = rangeEnd;
-    }
-
-    /** Human-readable name of this category, e.g. "Validation". */
-    public String displayName() {
-        return displayName;
-    }
-
-    /** Inclusive lower bound of the category prefix range (e.g. 100). */
-    public int rangeStart() {
-        return rangeStart;
-    }
-
-    /** Inclusive upper bound of the category prefix range (e.g. 109). */
-    public int rangeEnd() {
-        return rangeEnd;
-    }
-
-    /**
-     * Returns {@code true} if the given numeric code belongs to this category.
-     *
-     * @param code the full numeric code (e.g. 100_001)
-     * @return true if {@code code / 1000} falls within this category's range
-     */
-    public boolean contains(int code) {
-        int prefix = code / 1000;
-        return prefix >= rangeStart && prefix <= rangeEnd;
-    }
-}
diff --git a/spector-commons/src/main/java/com/spectrayan/spector/commons/error/ErrorCode.java b/spector-commons/src/main/java/com/spectrayan/spector/commons/error/ErrorCode.java
deleted file mode 100644
index e641222..0000000
--- a/spector-commons/src/main/java/com/spectrayan/spector/commons/error/ErrorCode.java
+++ /dev/null
@@ -1,561 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.commons.error;
-
-import java.util.HashMap;
-import java.util.Map;
-import com.spectrayan.spector.commons.error.ErrorCode;
-import com.spectrayan.spector.commons.error.SpectorException;
-
-/**
- * Central registry of all Spector error codes.
- *
- * <p>Each error code follows the {@code SPE-XXX-YYY} schema where {@code XXX} is the
- * category prefix and {@code YYY} is the specific error within that category.
- * Internally, codes are stored as a single integer (e.g. {@code 100_001} for
- * {@code SPE-100-001}).</p>
- *
- * <h3>Stability Guarantee</h3>
- * <p>Error codes are <b>immutable once assigned</b>. If an error is deprecated, it is
- * marked {@code @Deprecated} but never reassigned or removed. Users can safely build
- * automation, monitoring alerts, and support workflows on these codes.</p>
- *
- * <h3>Message Templates</h3>
- * <p>Each code carries an SLF4J-style message template with {@code {}} placeholders.
- * Use {@link #format(Object...)} to produce the final message:
- * <pre>{@code
- *   ErrorCode.DIMENSIONS_MISMATCH.format(384, 768)
- *   // → "[SPE-100-002] Expected 384 dimensions but received 768"
- * }</pre>
- *
- * @see ErrorCategory
- * @see SpectorException
- */
-public enum ErrorCode {
-
-    // ══════════════════════════════════════════════════════════════════════
-    // VALIDATION (SPE-100-xxx)
-    // ══════════════════════════════════════════════════════════════════════
-
-    /** Vector dimensions must be a positive integer. */
-    DIMENSIONS_INVALID        (100_001, ErrorCategory.VALIDATION,
-            "Vector dimensions must be positive, got {}"),
-
-    /** Vector dimensions do not match the index configuration. */
-    DIMENSIONS_MISMATCH       (100_002, ErrorCategory.VALIDATION,
-            "Expected {} dimensions but received {}"),
-
-    /** A required vector argument was null. */
-    VECTOR_NULL               (100_003, ErrorCategory.VALIDATION,
-            "Vector must not be null"),
-
-    /** Vector array length does not match the expected dimension count. */
-    VECTOR_LENGTH_MISMATCH    (100_004, ErrorCategory.VALIDATION,
-            "Vector length {} does not match expected {}"),
-
-    /** The top-K parameter is out of valid range. */
-    TOP_K_INVALID             (100_005, ErrorCategory.VALIDATION,
-            "top_k must be between 1 and {}, got {}"),
-
-    /** Document ID was null or empty. */
-    DOCUMENT_ID_NULL          (100_006, ErrorCategory.VALIDATION,
-            "Document ID must not be null or empty"),
-
-    /** A required argument was null. */
-    ARGUMENT_NULL             (100_007, ErrorCategory.VALIDATION,
-            "{} must not be null"),
-
-    /** An argument value is outside its valid range. */
-    ARGUMENT_OUT_OF_RANGE     (100_008, ErrorCategory.VALIDATION,
-            "{} must be between {} and {}, got {}"),
-
-    /** An unsupported quantization type was specified. */
-    QUANTIZATION_TYPE_INVALID (100_009, ErrorCategory.VALIDATION,
-            "Unsupported quantization type: {}"),
-
-    /** A capacity limit has been exceeded. */
-    CAPACITY_EXCEEDED         (100_010, ErrorCategory.VALIDATION,
-            "Capacity exceeded: max={}, requested={}"),
-
-    /** SimilarityFunction argument was null. */
-    SIMILARITY_FUNCTION_NULL  (100_011, ErrorCategory.VALIDATION,
-            "SimilarityFunction must not be null"),
-
-    /** A required collection was null or empty. */
-    EMPTY_COLLECTION          (100_012, ErrorCategory.VALIDATION,
-            "{} must not be empty"),
-
-    /** A general argument value is invalid. */
-    ARGUMENT_INVALID          (100_013, ErrorCategory.VALIDATION,
-            "Invalid value for {}: {}"),
-
-    /** A numeric argument must be non-negative. */
-    ARGUMENT_NEGATIVE         (100_014, ErrorCategory.VALIDATION,
-            "{} must be non-negative, got {}"),
-
-    /** Two arrays or segments must have equal length. */
-    LENGTH_MISMATCH           (100_015, ErrorCategory.VALIDATION,
-            "{} length {} does not match {} length {}"),
-
-    /** Bit width is not one of the supported values. */
-    BIT_WIDTH_INVALID         (100_016, ErrorCategory.VALIDATION,
-            "Bit width must be one of {}, got {}"),
-
-    /** The engine has been closed and cannot accept further operations. */
-    ENGINE_CLOSED             (100_017, ErrorCategory.VALIDATION,
-            "SpectorEngine is closed"),
-
-    /** An embedding provider is required but was not configured. */
-    EMBEDDING_PROVIDER_MISSING(100_018, ErrorCategory.VALIDATION,
-            "No EmbeddingProvider configured — use builder().embeddingProvider() or supply vectors manually"),
-
-    // ══════════════════════════════════════════════════════════════════════
-    // CONFIG (SPE-110-xxx)
-    // ══════════════════════════════════════════════════════════════════════
-
-    /** Configuration file could not be found at the specified path. */
-    CONFIG_FILE_NOT_FOUND     (110_001, ErrorCategory.CONFIG,
-            "Configuration file not found: {}"),
-
-    /** Configuration file exists but could not be parsed. */
-    CONFIG_PARSE_FAILED       (110_002, ErrorCategory.CONFIG,
-            "Failed to parse configuration: {}"),
-
-    /** A configuration value is invalid or out of range. */
-    CONFIG_VALUE_INVALID      (110_003, ErrorCategory.CONFIG,
-            "Invalid configuration value for {}: {}"),
-
-    /** A named configuration profile was not found. */
-    CONFIG_PROFILE_NOT_FOUND  (110_004, ErrorCategory.CONFIG,
-            "Configuration profile not found: {}"),
-
-    /** A required configuration key is missing. */
-    CONFIG_REQUIRED_MISSING   (110_005, ErrorCategory.CONFIG,
-            "Required configuration key missing: {}"),
-
-    // ══════════════════════════════════════════════════════════════════════
-    // INDEX (SPE-200-xxx)
-    // ══════════════════════════════════════════════════════════════════════
-
-    /** Parallel HNSW index construction failed. */
-    HNSW_BUILD_FAILED         (200_001, ErrorCategory.INDEX,
-            "HNSW index construction failed"),
-
-    /** HNSW graph structural integrity check detected corruption. */
-    HNSW_GRAPH_CORRUPTED      (200_002, ErrorCategory.INDEX,
-            "HNSW graph integrity check failed: {}"),
-
-    /** Index has reached its maximum document capacity. */
-    INDEX_FULL                (200_003, ErrorCategory.INDEX,
-            "Index has reached maximum capacity: {}"),
-
-    /** Index is in read-only mode and cannot accept writes. */
-    INDEX_READ_ONLY           (200_004, ErrorCategory.INDEX,
-            "Index is read-only, write operations not permitted"),
-
-    /** IVF centroid training failed during calibration. */
-    IVF_TRAINING_FAILED       (200_005, ErrorCategory.INDEX,
-            "IVF centroid training failed: {}"),
-
-    /** BM25 text tokenization encountered an error. */
-    BM25_TOKENIZATION_FAILED  (200_006, ErrorCategory.INDEX,
-            "BM25 text tokenization failed: {}"),
-
-    /** Index could not be serialized to persistent storage. */
-    INDEX_SERIALIZATION_FAILED(200_007, ErrorCategory.INDEX,
-            "Index serialization to disk failed: {}"),
-
-    /** Index could not be loaded from persistent storage. */
-    INDEX_LOAD_FAILED         (200_008, ErrorCategory.INDEX,
-            "Index deserialization from disk failed: {}"),
-
-    /** Operation requires a trained index, but train() has not been called. */
-    INDEX_NOT_TRAINED         (200_009, ErrorCategory.INDEX,
-            "Index not trained, call train() before search"),
-
-    /** Centroid count for IVF must be a positive integer. */
-    CENTROID_COUNT_INVALID    (200_010, ErrorCategory.INDEX,
-            "Centroid count must be positive, got {}"),
-
-    /** HNSW graph connectivity is below the required threshold. */
-    HNSW_CONNECTIVITY_LOW     (200_011, ErrorCategory.INDEX,
-            "HNSW graph connectivity below threshold: {} < {}"),
-
-    // ══════════════════════════════════════════════════════════════════════
-    // STORAGE (SPE-210-xxx)
-    // ══════════════════════════════════════════════════════════════════════
-
-    /** Attempted operation on a closed memory segment. */
-    SEGMENT_CLOSED            (210_001, ErrorCategory.STORAGE,
-            "Memory segment is closed"),
-
-    /** Failed to create a memory-mapped file. */
-    MMAP_FAILED               (210_002, ErrorCategory.STORAGE,
-            "Memory-mapped file creation failed: {}"),
-
-    /** Vector store has reached its configured capacity. */
-    STORE_FULL                (210_003, ErrorCategory.STORAGE,
-            "Vector store has reached capacity: {}"),
-
-    /** A disk I/O operation failed (read, write, or sync). */
-    DISK_IO_FAILED            (210_004, ErrorCategory.STORAGE,
-            "Disk I/O operation failed: {}"),
-
-    /** Write-ahead log entry could not be written. */
-    WAL_WRITE_FAILED          (210_005, ErrorCategory.STORAGE,
-            "Write-ahead log write failed"),
-
-    /** Write-ahead log replay encountered an error. */
-    WAL_REPLAY_FAILED         (210_006, ErrorCategory.STORAGE,
-            "Write-ahead log replay failed: {}"),
-
-    /** Vector store has not been initialized. */
-    STORE_NOT_INITIALIZED     (210_007, ErrorCategory.STORAGE,
-            "Vector store not initialized"),
-
-    /** Persistent index file has an unrecognized format or version. */
-    FILE_FORMAT_INVALID       (210_008, ErrorCategory.STORAGE,
-            "Invalid index file format: {}"),
-
-    // ══════════════════════════════════════════════════════════════════════
-    // EMBEDDING (SPE-300-xxx)
-    // ══════════════════════════════════════════════════════════════════════
-
-    /** Embedding provider (e.g. Ollama) is not reachable. */
-    EMBEDDING_UNAVAILABLE     (300_001, ErrorCategory.EMBEDDING,
-            "Embedding provider is unavailable: {}"),
-
-    /** Embedding request returned an error response. */
-    EMBEDDING_REQUEST_FAILED  (300_002, ErrorCategory.EMBEDDING,
-            "Embedding request failed: {}"),
-
-    /** Embedding request exceeded the configured timeout. */
-    EMBEDDING_TIMEOUT         (300_003, ErrorCategory.EMBEDDING,
-            "Embedding request timed out after {}ms"),
-
-    /** The requested embedding model was not found. */
-    EMBEDDING_MODEL_NOT_FOUND (300_004, ErrorCategory.EMBEDDING,
-            "Embedding model not found: {}"),
-
-    /** Embedding provider returned vectors with unexpected dimensions. */
-    EMBEDDING_DIM_MISMATCH    (300_005, ErrorCategory.EMBEDDING,
-            "Embedding returned {} dims, expected {}"),
-
-    // ══════════════════════════════════════════════════════════════════════
-    // MEMORY (SPE-310-xxx)
-    // ══════════════════════════════════════════════════════════════════════
-
-    /** A cognitive memory tier has reached its capacity limit. */
-    MEMORY_TIER_FULL          (310_001, ErrorCategory.MEMORY,
-            "Memory tier {} has reached capacity: {}"),
-
-    /** The cognitive recall pipeline encountered a failure. */
-    MEMORY_RECALL_FAILED      (310_002, ErrorCategory.MEMORY,
-            "Cognitive recall pipeline failed"),
-
-    /** Memory consolidation process failed. */
-    MEMORY_CONSOLIDATION_FAILED(310_003, ErrorCategory.MEMORY,
-            "Memory consolidation failed: {}"),
-
-    /** The specified memory ID does not exist. */
-    MEMORY_ID_NOT_FOUND       (310_004, ErrorCategory.MEMORY,
-            "Memory ID not found: {}"),
-
-    /** Memory WAL file is corrupted or unreadable. */
-    MEMORY_WAL_CORRUPTED      (310_005, ErrorCategory.MEMORY,
-            "Memory WAL file corrupted: {}"),
-
-    /** Hebbian graph operation failed (edge strengthening, decay, spreading activation). */
-    GRAPH_HEBBIAN_FAILED      (310_006, ErrorCategory.MEMORY,
-            "Hebbian graph operation failed: {}"),
-
-    /** Temporal chain operation failed (link, follow forward/backward). */
-    GRAPH_TEMPORAL_FAILED     (310_007, ErrorCategory.MEMORY,
-            "Temporal chain operation failed: {}"),
-
-    /** Entity graph operation failed (add entity, relation, traversal). */
-    GRAPH_ENTITY_FAILED       (310_008, ErrorCategory.MEMORY,
-            "Entity graph operation failed: {}"),
-
-    /** Co-activation tracker operation failed (pair recording, STDP update). */
-    GRAPH_COACTIVATION_FAILED (310_009, ErrorCategory.MEMORY,
-            "Co-activation tracker operation failed: {}"),
-
-    /** Graph persistence (save/load) failed. */
-    GRAPH_PERSISTENCE_FAILED  (310_010, ErrorCategory.MEMORY,
-            "Graph persistence failed for {}: {}"),
-
-    /** Graph decay or pruning operation failed during consolidation. */
-    GRAPH_DECAY_FAILED        (310_011, ErrorCategory.MEMORY,
-            "Graph decay failed: {}"),
-
-    // ══════════════════════════════════════════════════════════════════════
-    // GPU (SPE-400-xxx)
-    // ══════════════════════════════════════════════════════════════════════
-
-    /** CUDA driver library could not be located on the system. */
-    CUDA_DRIVER_NOT_FOUND     (400_001, ErrorCategory.GPU,
-            "CUDA driver not found"),
-
-    /** GPU memory allocation failed — not enough device memory. */
-    GPU_MEMORY_EXHAUSTED      (400_002, ErrorCategory.GPU,
-            "GPU memory allocation failed: requested={}B, available={}B"),
-
-    /** A GPU compute kernel failed to launch or execute. */
-    GPU_KERNEL_LAUNCH_FAILED  (400_003, ErrorCategory.GPU,
-            "GPU kernel launch failed: {}"),
-
-    /** The GPU device reported a hardware or driver error. */
-    GPU_DEVICE_ERROR          (400_004, ErrorCategory.GPU,
-            "GPU device error: {}"),
-
-    /** The allocation would exceed the configured GPU memory budget. */
-    GPU_BUDGET_EXCEEDED       (400_005, ErrorCategory.GPU,
-            "GPU memory budget exceeded: requested={}B, budget={}B"),
-
-    /** GPU is not available on this system. */
-    GPU_NOT_AVAILABLE         (400_006, ErrorCategory.GPU,
-            "GPU is not available: {}"),
-
-    /** GPU memory allocation failed. */
-    GPU_MEMORY_ALLOC_FAILED   (400_007, ErrorCategory.GPU,
-            "GPU memory allocation failed: {}"),
-
-    // ══════════════════════════════════════════════════════════════════════
-    // SERVER (SPE-500-xxx)
-    // ══════════════════════════════════════════════════════════════════════
-
-    /** HTTP 400 — client sent a malformed or invalid request. */
-    API_BAD_REQUEST           (500_001, ErrorCategory.SERVER,
-            "Bad request: {}"),
-
-    /** HTTP 404 — the requested resource does not exist. */
-    API_NOT_FOUND             (500_002, ErrorCategory.SERVER,
-            "Resource not found: {}"),
-
-    /** HTTP 409 — resource state conflict (e.g. duplicate ID). */
-    API_CONFLICT              (500_003, ErrorCategory.SERVER,
-            "Resource conflict: {}"),
-
-    /** HTTP 401/403 — invalid or missing API key. */
-    API_UNAUTHORIZED          (500_004, ErrorCategory.SERVER,
-            "Unauthorized: invalid or missing API key"),
-
-    /** HTTP 503 — a required backend service is unavailable. */
-    API_SERVICE_UNAVAILABLE   (500_005, ErrorCategory.SERVER,
-            "Service unavailable: {}"),
-
-    /** An MCP tool handler encountered a failure during execution. */
-    MCP_TOOL_FAILED           (500_006, ErrorCategory.SERVER,
-            "MCP tool execution failed: {}"),
-
-    /** gRPC transport-level error during inter-node communication. */
-    GRPC_TRANSPORT_FAILED     (500_007, ErrorCategory.SERVER,
-            "gRPC transport error: {}"),
-
-    // ══════════════════════════════════════════════════════════════════════
-    // CLIENT (SPE-510-xxx)
-    // ══════════════════════════════════════════════════════════════════════
-
-    /** Failed to establish a connection to the Spector server. */
-    CLIENT_CONNECTION_FAILED  (510_001, ErrorCategory.CLIENT,
-            "Failed to connect to Spector server: {}"),
-
-    /** A client request exceeded the configured timeout. */
-    CLIENT_TIMEOUT            (510_002, ErrorCategory.CLIENT,
-            "Client request timed out after {}ms"),
-
-    /** The server returned a response that could not be parsed. */
-    CLIENT_RESPONSE_INVALID   (510_003, ErrorCategory.CLIENT,
-            "Invalid server response: {}"),
-
-    // ══════════════════════════════════════════════════════════════════════
-    // INGESTION (SPE-600-xxx)
-    // ══════════════════════════════════════════════════════════════════════
-
-    /** The document format is not supported by any registered parser. */
-    INGESTION_FORMAT_UNSUPPORTED(600_001, ErrorCategory.INGESTION,
-            "Unsupported document format: {}"),
-
-    /** A document could not be read or processed. */
-    DOCUMENT_READ_FAILED      (600_004, ErrorCategory.INGESTION,
-            "Failed to read document '{}': {}"),
-
-    /** Document content chunking failed. */
-    INGESTION_CHUNKING_FAILED (600_002, ErrorCategory.INGESTION,
-            "Document chunking failed: {}"),
-
-    /** The ingestion pipeline encountered a fatal error. */
-    INGESTION_PIPELINE_FAILED (600_003, ErrorCategory.INGESTION,
-            "Ingestion pipeline failed: {}"),
-
-    // ══════════════════════════════════════════════════════════════════════
-    // CLUSTER (SPE-700-xxx)
-    // ══════════════════════════════════════════════════════════════════════
-
-    /** A target shard is not reachable or has been decommissioned. */
-    SHARD_UNAVAILABLE         (700_001, ErrorCategory.CLUSTER,
-            "Shard is unavailable: {}"),
-
-    /** A cluster membership operation (join, leave, heartbeat) failed. */
-    CLUSTER_MEMBERSHIP_FAILED (700_002, ErrorCategory.CLUSTER,
-            "Cluster membership operation failed: {}"),
-
-    /** A query could not be routed to the appropriate shard. */
-    CLUSTER_ROUTING_FAILED    (700_003, ErrorCategory.CLUSTER,
-            "Request routing failed: {}"),
-
-    // ══════════════════════════════════════════════════════════════════════
-    // INTERNAL (SPE-900-xxx)
-    // ══════════════════════════════════════════════════════════════════════
-
-    /** An unexpected internal error occurred — likely a bug. */
-    INTERNAL_ERROR            (900_001, ErrorCategory.INTERNAL,
-            "Internal error: {}"),
-
-    /** An internal invariant or assertion was violated — this is a bug. */
-    INVARIANT_VIOLATED        (900_002, ErrorCategory.INTERNAL,
-            "Internal invariant violated: {}"),
-
-    /** Execution reached a code path that should be unreachable — this is a bug. */
-    UNREACHABLE_CODE          (900_003, ErrorCategory.INTERNAL,
-            "Reached unreachable code path: {}"),
-
-    /** A concurrent execution subtask failed. */
-    CONCURRENT_EXECUTION_FAILED(900_004, ErrorCategory.INTERNAL,
-            "Concurrent execution failed: {}");
-
-    // ══════════════════════════════════════════════════════════════════════
-
-    private final int code;
-    private final ErrorCategory category;
-    private final String messageTemplate;
-
-    ErrorCode(int code, ErrorCategory category, String messageTemplate) {
-        this.code = code;
-        this.category = category;
-        this.messageTemplate = messageTemplate;
-    }
-
-    /** The full numeric code, e.g. {@code 100001}. */
-    public int code() {
-        return code;
-    }
-
-    /** The error category this code belongs to. */
-    public ErrorCategory category() {
-        return category;
-    }
-
-    /** The raw message template with {@code {}} placeholders. */
-    public String messageTemplate() {
-        return messageTemplate;
-    }
-
-    /**
-     * Returns the formatted error ID, e.g. {@code "SPE-100-001"}.
-     *
-     * @return the stable string identifier for this error code
-     */
-    public String id() {
-        return String.format("SPE-%03d-%03d", code / 1000, code % 1000);
-    }
-
-    /**
-     * Formats the message template by replacing {@code {}} placeholders
-     * left-to-right with the provided arguments (SLF4J style).
-     *
-     * <p>The returned string includes the error code prefix:
-     * <pre>{@code
-     *   ErrorCode.DIMENSIONS_MISMATCH.format(384, 768)
-     *   // → "[SPE-100-002] Expected 384 dimensions but received 768"
-     * }</pre>
-     *
-     * @param args values to substitute for {@code {}} placeholders
-     * @return formatted message with error code prefix
-     */
-    public String format(Object... args) {
-        StringBuilder sb = new StringBuilder(messageTemplate.length() + 32);
-        sb.append('[').append(id()).append("] ");
-
-        int argIndex = 0;
-        int start = 0;
-        int idx;
-        while ((idx = messageTemplate.indexOf("{}", start)) >= 0) {
-            sb.append(messageTemplate, start, idx);
-            if (argIndex < args.length) {
-                sb.append(args[argIndex++]);
-            } else {
-                sb.append("{}");
-            }
-            start = idx + 2;
-        }
-        sb.append(messageTemplate, start, messageTemplate.length());
-        return sb.toString();
-    }
-
-    // ────────────────────── Lookup ──────────────────────
-
-    private static final Map<Integer, ErrorCode> BY_CODE;
-    static {
-        ErrorCode[] values = values();
-        BY_CODE = HashMap.newHashMap(values.length);
-        for (ErrorCode ec : values) {
-            if (BY_CODE.put(ec.code, ec) != null) {
-                throw new ExceptionInInitializerError(
-                        "Duplicate ErrorCode: " + ec.code + " (" + ec.name() + ")");
-            }
-        }
-    }
-
-    /**
-     * Looks up an error code by its numeric value.
-     *
-     * @param code the numeric code, e.g. {@code 100001}
-     * @return the matching {@link ErrorCode}, or {@code null} if not found
-     */
-    public static ErrorCode fromCode(int code) {
-        return BY_CODE.get(code);
-    }
-
-    /**
-     * Looks up an error code by its string ID, e.g. {@code "SPE-100-001"}.
-     *
-     * @param id the formatted code string (case-insensitive prefix)
-     * @return the matching {@link ErrorCode}, or {@code null} if malformed or not found
-     */
-    public static ErrorCode fromId(String id) {
-        if (id == null || id.length() < 11) {
-            return null;
-        }
-        try {
-            // Parse "SPE-XXX-YYY" → category * 1000 + specific
-            String normalized = id.toUpperCase();
-            if (!normalized.startsWith("SPE-")) {
-                return null;
-            }
-            int dashPos = normalized.indexOf('-', 4);
-            if (dashPos < 0) {
-                return null;
-            }
-            int categoryPrefix = Integer.parseInt(normalized.substring(4, dashPos));
-            int specific = Integer.parseInt(normalized.substring(dashPos + 1));
-            return fromCode(categoryPrefix * 1000 + specific);
-        } catch (NumberFormatException e) {
-            return null;
-        }
-    }
-}
diff --git a/spector-commons/src/main/java/com/spectrayan/spector/commons/error/SpectorApiException.java b/spector-commons/src/main/java/com/spectrayan/spector/commons/error/SpectorApiException.java
deleted file mode 100644
index b723c8c..0000000
--- a/spector-commons/src/main/java/com/spectrayan/spector/commons/error/SpectorApiException.java
+++ /dev/null
@@ -1,99 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.commons.error;
-
-/**
- * Exception for HTTP API errors with status code mapping ({@code SPE-500-xxx}).
- *
- * <p>Extends {@link SpectorServerException} with an HTTP status code for REST API
- * error responses. Used by the API exception handler to build structured JSON
- * error responses.</p>
- *
- * <h3>Usage</h3>
- * <pre>{@code
- *   throw SpectorApiException.badRequest(ErrorCode.API_BAD_REQUEST, "id is required");
- *   throw SpectorApiException.notFound(ErrorCode.API_NOT_FOUND, "doc-123");
- * }</pre>
- *
- * @see ErrorCode#API_BAD_REQUEST
- * @see ErrorCode#API_NOT_FOUND
- */
-public class SpectorApiException extends SpectorServerException {
-
-    private final int httpStatus;
-
-    /**
-     * Creates an API exception with an HTTP status code and error code.
-     *
-     * @param httpStatus the HTTP response status code (e.g. 400, 404, 500)
-     * @param errorCode  the stable Spector error code
-     * @param args       values for message template placeholders
-     */
-    public SpectorApiException(int httpStatus, ErrorCode errorCode, Object... args) {
-        super(errorCode, args);
-        this.httpStatus = httpStatus;
-    }
-
-    /**
-     * Creates an API exception with an HTTP status code, error code, and cause.
-     *
-     * @param httpStatus the HTTP response status code
-     * @param errorCode  the stable Spector error code
-     * @param cause      the underlying exception
-     * @param args       values for message template placeholders
-     */
-    public SpectorApiException(int httpStatus, ErrorCode errorCode, Throwable cause, Object... args) {
-        super(errorCode, cause, args);
-        this.httpStatus = httpStatus;
-    }
-
-    /** The HTTP status code for the error response. */
-    public int httpStatus() {
-        return httpStatus;
-    }
-
-    // ─────────────── Factory methods ───────────────
-
-    /** 400 Bad Request. */
-    public static SpectorApiException badRequest(ErrorCode errorCode, Object... args) {
-        return new SpectorApiException(400, errorCode, args);
-    }
-
-    /** 404 Not Found. */
-    public static SpectorApiException notFound(ErrorCode errorCode, Object... args) {
-        return new SpectorApiException(404, errorCode, args);
-    }
-
-    /** 409 Conflict. */
-    public static SpectorApiException conflict(ErrorCode errorCode, Object... args) {
-        return new SpectorApiException(409, errorCode, args);
-    }
-
-    /** 401 Unauthorized. */
-    public static SpectorApiException unauthorized() {
-        return new SpectorApiException(401, ErrorCode.API_UNAUTHORIZED);
-    }
-
-    /** 503 Service Unavailable. */
-    public static SpectorApiException serviceUnavailable(ErrorCode errorCode, Object... args) {
-        return new SpectorApiException(503, errorCode, args);
-    }
-
-    /** 500 Internal Server Error. */
-    public static SpectorApiException internal(ErrorCode errorCode, Throwable cause, Object... args) {
-        return new SpectorApiException(500, errorCode, cause, args);
-    }
-}
diff --git a/spector-commons/src/main/java/com/spectrayan/spector/commons/error/SpectorClientException.java b/spector-commons/src/main/java/com/spectrayan/spector/commons/error/SpectorClientException.java
deleted file mode 100644
index afe0510..0000000
--- a/spector-commons/src/main/java/com/spectrayan/spector/commons/error/SpectorClientException.java
+++ /dev/null
@@ -1,40 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.commons.error;
-
-/**
- * Exception for client SDK errors ({@code SPE-510-xxx}).
- *
- * <p>Thrown when the Spector client fails to connect, times out,
- * or receives an unparseable response from the server.</p>
- *
- * @see ErrorCode#CLIENT_CONNECTION_FAILED
- * @see ErrorCode#CLIENT_TIMEOUT
- */
-public class SpectorClientException extends SpectorException {
-
-    public SpectorClientException(ErrorCode errorCode, Object... args) {
-        super(errorCode, args);
-    }
-
-    public SpectorClientException(ErrorCode errorCode, String preformattedMessage, boolean isPreformatted) {
-        super(errorCode, preformattedMessage, isPreformatted);
-    }
-
-    public SpectorClientException(ErrorCode errorCode, Throwable cause, Object... args) {
-        super(errorCode, cause, args);
-    }
-}
diff --git a/spector-commons/src/main/java/com/spectrayan/spector/commons/error/SpectorClusterException.java b/spector-commons/src/main/java/com/spectrayan/spector/commons/error/SpectorClusterException.java
deleted file mode 100644
index ac344f8..0000000
--- a/spector-commons/src/main/java/com/spectrayan/spector/commons/error/SpectorClusterException.java
+++ /dev/null
@@ -1,40 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.commons.error;
-
-/**
- * Exception for distributed cluster errors ({@code SPE-700-xxx}).
- *
- * <p>Thrown when shard routing fails, cluster membership operations fail,
- * or a target shard is unavailable in distributed mode.</p>
- *
- * @see ErrorCode#SHARD_UNAVAILABLE
- * @see ErrorCode#CLUSTER_MEMBERSHIP_FAILED
- */
-public class SpectorClusterException extends SpectorException {
-
-    public SpectorClusterException(ErrorCode errorCode, Object... args) {
-        super(errorCode, args);
-    }
-
-    public SpectorClusterException(ErrorCode errorCode, String preformattedMessage, boolean isPreformatted) {
-        super(errorCode, preformattedMessage, isPreformatted);
-    }
-
-    public SpectorClusterException(ErrorCode errorCode, Throwable cause, Object... args) {
-        super(errorCode, cause, args);
-    }
-}
diff --git a/spector-commons/src/main/java/com/spectrayan/spector/commons/error/SpectorConfigException.java b/spector-commons/src/main/java/com/spectrayan/spector/commons/error/SpectorConfigException.java
deleted file mode 100644
index 0441069..0000000
--- a/spector-commons/src/main/java/com/spectrayan/spector/commons/error/SpectorConfigException.java
+++ /dev/null
@@ -1,40 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.commons.error;
-
-/**
- * Exception for configuration loading, parsing, and validation errors ({@code SPE-110-xxx}).
- *
- * <p>Thrown when a configuration file cannot be found, parsed, or contains invalid values.
- * Replaces the previous unstructured {@code SpectorConfigException} from spector-config.</p>
- *
- * @see ErrorCode#CONFIG_FILE_NOT_FOUND
- * @see ErrorCode#CONFIG_PARSE_FAILED
- */
-public class SpectorConfigException extends SpectorException {
-
-    public SpectorConfigException(ErrorCode errorCode, Object... args) {
-        super(errorCode, args);
-    }
-
-    public SpectorConfigException(ErrorCode errorCode, String preformattedMessage, boolean isPreformatted) {
-        super(errorCode, preformattedMessage, isPreformatted);
-    }
-
-    public SpectorConfigException(ErrorCode errorCode, Throwable cause, Object... args) {
-        super(errorCode, cause, args);
-    }
-}
diff --git a/spector-commons/src/main/java/com/spectrayan/spector/commons/error/SpectorDocumentReadException.java b/spector-commons/src/main/java/com/spectrayan/spector/commons/error/SpectorDocumentReadException.java
deleted file mode 100644
index 760e676..0000000
--- a/spector-commons/src/main/java/com/spectrayan/spector/commons/error/SpectorDocumentReadException.java
+++ /dev/null
@@ -1,52 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.commons.error;
-
-/**
- * Exception thrown when a document cannot be read or processed.
- *
- * <p>This exception carries information about the file that failed and the
- * nature of the failure, without terminating the pipeline.</p>
- *
- * @see SpectorIngestionException
- */
-public class SpectorDocumentReadException extends SpectorIngestionException {
-
-    private final String fileName;
-    private final String reason;
-
-    public SpectorDocumentReadException(String fileName, String reason) {
-        super(ErrorCode.DOCUMENT_READ_FAILED, fileName, reason);
-        this.fileName = fileName;
-        this.reason = reason;
-    }
-
-    public SpectorDocumentReadException(String fileName, String reason, Throwable cause) {
-        super(ErrorCode.DOCUMENT_READ_FAILED, cause, fileName, reason);
-        this.fileName = fileName;
-        this.reason = reason;
-    }
-
-    /** Returns the name of the file that could not be read. */
-    public String getFileName() {
-        return fileName;
-    }
-
-    /** Returns the reason the read failed. */
-    public String getReason() {
-        return reason;
-    }
-}
diff --git a/spector-commons/src/main/java/com/spectrayan/spector/commons/error/SpectorEmbeddingException.java b/spector-commons/src/main/java/com/spectrayan/spector/commons/error/SpectorEmbeddingException.java
deleted file mode 100644
index caaacb1..0000000
--- a/spector-commons/src/main/java/com/spectrayan/spector/commons/error/SpectorEmbeddingException.java
+++ /dev/null
@@ -1,40 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.commons.error;
-
-/**
- * Exception for embedding provider errors ({@code SPE-300-xxx}).
- *
- * <p>Thrown when an embedding provider (e.g. Ollama) is unreachable, returns an error,
- * times out, or returns vectors with unexpected dimensions.</p>
- *
- * @see ErrorCode#EMBEDDING_UNAVAILABLE
- * @see ErrorCode#EMBEDDING_TIMEOUT
- */
-public class SpectorEmbeddingException extends SpectorException {
-
-    public SpectorEmbeddingException(ErrorCode errorCode, Object... args) {
-        super(errorCode, args);
-    }
-
-    public SpectorEmbeddingException(ErrorCode errorCode, String preformattedMessage, boolean isPreformatted) {
-        super(errorCode, preformattedMessage, isPreformatted);
-    }
-
-    public SpectorEmbeddingException(ErrorCode errorCode, Throwable cause, Object... args) {
-        super(errorCode, cause, args);
-    }
-}
diff --git a/spector-commons/src/main/java/com/spectrayan/spector/commons/error/SpectorException.java b/spector-commons/src/main/java/com/spectrayan/spector/commons/error/SpectorException.java
deleted file mode 100644
index 469ea5c..0000000
--- a/spector-commons/src/main/java/com/spectrayan/spector/commons/error/SpectorException.java
+++ /dev/null
@@ -1,136 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.commons.error;
-
-/**
- * Abstract base for all Spector exceptions.
- *
- * <p>Every Spector exception carries an {@link ErrorCode} that uniquely identifies the
- * error condition. The error code follows the {@code SPE-XXX-YYY} schema and is
- * <b>immutable once assigned</b> — users and monitoring systems can safely key on it.</p>
- *
- * <h3>Exception Hierarchy</h3>
- * <pre>{@code
- *   SpectorException
- *   ├── SpectorValidationException      (SPE-100-xxx)
- *   ├── SpectorConfigException          (SPE-110-xxx)
- *   ├── SpectorIndexException           (SPE-200-xxx)
- *   ├── SpectorStorageException         (SPE-210-xxx)
- *   ├── SpectorEmbeddingException       (SPE-300-xxx)
- *   ├── SpectorMemoryException          (SPE-310-xxx)
- *   │   ├── SpectorGraphException           (SPE-310-006..011)
- *   │   │   ├── SpectorHebbianException         (SPE-310-006)
- *   │   │   ├── SpectorTemporalChainException   (SPE-310-007)
- *   │   │   ├── SpectorEntityGraphException     (SPE-310-008)
- *   │   │   ├── SpectorCoActivationException    (SPE-310-009)
- *   │   │   ├── SpectorGraphPersistenceException(SPE-310-010)
- *   │   │   └── SpectorGraphDecayException      (SPE-310-011)
- *   │   ├── SpectorMemoryRecallException    (SPE-310-002)
- *   │   ├── SpectorMemoryConsolidationException (SPE-310-003)
- *   │   └── SpectorMemoryTierFullException  (SPE-310-001)
- *   ├── SpectorGpuException             (SPE-400-xxx)
- *   ├── SpectorServerException          (SPE-500-xxx)
- *   ├── SpectorClientException          (SPE-510-xxx)
- *   ├── SpectorIngestionException       (SPE-600-xxx)
- *   ├── SpectorClusterException         (SPE-700-xxx)
- *   └── SpectorInternalException        (SPE-900-xxx)
- * }</pre>
- *
- * <h3>Usage</h3>
- * <pre>{@code
- *   throw new SpectorValidationException(
- *       ErrorCode.DIMENSIONS_MISMATCH, 384, 768);
- *   // Message: "[SPE-100-002] Expected 384 dimensions but received 768"
- * }</pre>
- *
- * @see ErrorCode
- * @see ErrorCategory
- */
-public abstract class SpectorException extends RuntimeException {
-
-    private final ErrorCode errorCode;
-
-    /**
-     * Creates a new Spector exception with formatted message.
-     *
-     * @param errorCode the stable error code identifying this condition
-     * @param args      values to substitute into the message template's {@code {}} placeholders
-     */
-    protected SpectorException(ErrorCode errorCode, Object... args) {
-        super(errorCode.format(args));
-        this.errorCode = errorCode;
-    }
-
-    /**
-     * Internal constructor to reconstruct an exception on the client-side
-     * with a pre-formatted message, bypassing template formatting.
-     */
-    protected SpectorException(ErrorCode errorCode, String preformattedMessage, boolean isPreformatted) {
-        super(preformattedMessage);
-        this.errorCode = errorCode;
-    }
-
-    /**
-     * Creates a new Spector exception with a cause and formatted message.
-     *
-     * @param errorCode the stable error code identifying this condition
-     * @param cause     the underlying exception that triggered this error
-     * @param args      values to substitute into the message template's {@code {}} placeholders
-     */
-    protected SpectorException(ErrorCode errorCode, Throwable cause, Object... args) {
-        super(errorCode.format(args), cause);
-        this.errorCode = errorCode;
-    }
-
-    /**
-     * Returns the stable error code for this exception.
-     *
-     * <p>Error codes are immutable once assigned and follow the {@code SPE-XXX-YYY}
-     * schema. Users can safely build automation and alerts on these codes.</p>
-     *
-     * @return the error code, never null
-     */
-    public ErrorCode errorCode() {
-        return errorCode;
-    }
-
-    /**
-     * Returns the numeric error code for programmatic matching.
-     *
-     * @return the raw numeric code, e.g. {@code 100002}
-     */
-    public int code() {
-        return errorCode.code();
-    }
-
-    /**
-     * Returns the formatted error code string, e.g. {@code "SPE-100-002"}.
-     *
-     * @return the stable string identifier
-     */
-    public String codeId() {
-        return errorCode.id();
-    }
-
-    /**
-     * Returns the error category for broad classification.
-     *
-     * @return the category this error belongs to
-     */
-    public ErrorCategory category() {
-        return errorCode.category();
-    }
-}
diff --git a/spector-commons/src/main/java/com/spectrayan/spector/commons/error/SpectorGpuException.java b/spector-commons/src/main/java/com/spectrayan/spector/commons/error/SpectorGpuException.java
deleted file mode 100644
index 90171f4..0000000
--- a/spector-commons/src/main/java/com/spectrayan/spector/commons/error/SpectorGpuException.java
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.commons.error;
-
-/**
- * Exception for GPU and CUDA errors ({@code SPE-400-xxx}).
- *
- * <p>Thrown when CUDA driver is not found, GPU memory allocation fails,
- * kernel launches fail, or GPU device reports errors.</p>
- *
- * <p>Carries optional allocation context (requested bytes, available bytes)
- * for GPU memory exhaustion diagnostics.</p>
- *
- * @see ErrorCode#CUDA_DRIVER_NOT_FOUND
- * @see ErrorCode#GPU_MEMORY_EXHAUSTED
- */
-public class SpectorGpuException extends SpectorException {
-
-    private final long requestedBytes;
-    private final long availableBytes;
-
-    public SpectorGpuException(ErrorCode errorCode, Object... args) {
-        super(errorCode, args);
-        this.requestedBytes = -1;
-        this.availableBytes = -1;
-    }
-
-    public SpectorGpuException(ErrorCode errorCode, String preformattedMessage, boolean isPreformatted) {
-        super(errorCode, preformattedMessage, isPreformatted);
-        this.requestedBytes = -1;
-        this.availableBytes = -1;
-    }
-
-    public SpectorGpuException(ErrorCode errorCode, Throwable cause, Object... args) {
-        super(errorCode, cause, args);
-        this.requestedBytes = -1;
-        this.availableBytes = -1;
-    }
-
-    /**
-     * Creates a GPU exception with memory allocation context.
-     *
-     * @param errorCode      the GPU error code
-     * @param requestedBytes bytes that were requested
-     * @param availableBytes bytes that were available
-     */
-    public SpectorGpuException(ErrorCode errorCode, long requestedBytes, long availableBytes) {
-        super(errorCode, requestedBytes, availableBytes);
-        this.requestedBytes = requestedBytes;
-        this.availableBytes = availableBytes;
-    }
-
-    /** Returns the requested allocation size, or {@code -1} if not applicable. */
-    public long requestedBytes() {
-        return requestedBytes;
-    }
-
-    /** Returns the available memory at failure time, or {@code -1} if not applicable. */
-    public long availableBytes() {
-        return availableBytes;
-    }
-}
diff --git a/spector-commons/src/main/java/com/spectrayan/spector/commons/error/SpectorIndexException.java b/spector-commons/src/main/java/com/spectrayan/spector/commons/error/SpectorIndexException.java
deleted file mode 100644
index 9e9ef50..0000000
--- a/spector-commons/src/main/java/com/spectrayan/spector/commons/error/SpectorIndexException.java
+++ /dev/null
@@ -1,40 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.commons.error;
-
-/**
- * Exception for index construction, search, persistence, and integrity errors ({@code SPE-200-xxx}).
- *
- * <p>Covers HNSW graph building, IVF training, BM25 tokenization, index serialization,
- * and structural integrity violations.</p>
- *
- * @see ErrorCode#HNSW_BUILD_FAILED
- * @see ErrorCode#INDEX_FULL
- */
-public class SpectorIndexException extends SpectorException {
-
-    public SpectorIndexException(ErrorCode errorCode, Object... args) {
-        super(errorCode, args);
-    }
-
-    public SpectorIndexException(ErrorCode errorCode, String preformattedMessage, boolean isPreformatted) {
-        super(errorCode, preformattedMessage, isPreformatted);
-    }
-
-    public SpectorIndexException(ErrorCode errorCode, Throwable cause, Object... args) {
-        super(errorCode, cause, args);
-    }
-}
diff --git a/spector-commons/src/main/java/com/spectrayan/spector/commons/error/SpectorIngestionException.java b/spector-commons/src/main/java/com/spectrayan/spector/commons/error/SpectorIngestionException.java
deleted file mode 100644
index d196e06..0000000
--- a/spector-commons/src/main/java/com/spectrayan/spector/commons/error/SpectorIngestionException.java
+++ /dev/null
@@ -1,39 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.commons.error;
-
-/**
- * Exception for document ingestion pipeline errors ({@code SPE-600-xxx}).
- *
- * <p>Thrown when document parsing, chunking, or the ingestion pipeline fails.</p>
- *
- * @see ErrorCode#INGESTION_FORMAT_UNSUPPORTED
- * @see ErrorCode#INGESTION_PIPELINE_FAILED
- */
-public class SpectorIngestionException extends SpectorException {
-
-    public SpectorIngestionException(ErrorCode errorCode, Object... args) {
-        super(errorCode, args);
-    }
-
-    public SpectorIngestionException(ErrorCode errorCode, String preformattedMessage, boolean isPreformatted) {
-        super(errorCode, preformattedMessage, isPreformatted);
-    }
-
-    public SpectorIngestionException(ErrorCode errorCode, Throwable cause, Object... args) {
-        super(errorCode, cause, args);
-    }
-}
diff --git a/spector-commons/src/main/java/com/spectrayan/spector/commons/error/SpectorInternalException.java b/spector-commons/src/main/java/com/spectrayan/spector/commons/error/SpectorInternalException.java
deleted file mode 100644
index c5087bd..0000000
--- a/spector-commons/src/main/java/com/spectrayan/spector/commons/error/SpectorInternalException.java
+++ /dev/null
@@ -1,66 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.commons.error;
-
-/**
- * Exception for internal bugs and invariant violations ({@code SPE-900-xxx}).
- *
- * <p>Thrown when the system reaches a state that should be impossible — violated
- * assertions, unreachable code paths, concurrent execution failures, or any
- * condition that indicates a bug in Spector itself (not in user input).</p>
- *
- * <p>Replaces raw {@link IllegalStateException} and {@link UnsupportedOperationException}
- * throws with structured, identifiable error codes.</p>
- *
- * <h3>Usage</h3>
- * <pre>{@code
- *   default -> throw new SpectorInternalException(
- *       ErrorCode.UNREACHABLE_CODE, "switch on QuantType: " + type);
- *   // → "[SPE-900-003] Reached unreachable code path: switch on QuantType: SVASQ_16"
- * }</pre>
- *
- * <p>If a customer reports an {@code SPE-900-xxx} error, it always indicates a bug
- * in Spector that needs to be fixed — never a user configuration issue.</p>
- *
- * @see ErrorCode
- */
-public class SpectorInternalException extends SpectorException {
-
-    /**
-     * Creates an internal exception with a formatted message.
-     *
-     * @param errorCode the internal error code (must be in the SPE-900-xxx range)
-     * @param args      values to substitute into the message template
-     */
-    public SpectorInternalException(ErrorCode errorCode, Object... args) {
-        super(errorCode, args);
-    }
-
-    public SpectorInternalException(ErrorCode errorCode, String preformattedMessage, boolean isPreformatted) {
-        super(errorCode, preformattedMessage, isPreformatted);
-    }
-
-    /**
-     * Creates an internal exception with a cause and formatted message.
-     *
-     * @param errorCode the internal error code
-     * @param cause     the underlying exception
-     * @param args      values to substitute into the message template
-     */
-    public SpectorInternalException(ErrorCode errorCode, Throwable cause, Object... args) {
-        super(errorCode, cause, args);
-    }
-}
diff --git a/spector-commons/src/main/java/com/spectrayan/spector/commons/error/SpectorMemoryException.java b/spector-commons/src/main/java/com/spectrayan/spector/commons/error/SpectorMemoryException.java
deleted file mode 100644
index 8c0a9cc..0000000
--- a/spector-commons/src/main/java/com/spectrayan/spector/commons/error/SpectorMemoryException.java
+++ /dev/null
@@ -1,40 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.commons.error;
-
-/**
- * Exception for cognitive memory tier errors ({@code SPE-310-xxx}).
- *
- * <p>Covers memory tier capacity, recall pipeline failures, consolidation errors,
- * memory ID lookups, and WAL corruption in the memory subsystem.</p>
- *
- * @see ErrorCode#MEMORY_TIER_FULL
- * @see ErrorCode#MEMORY_RECALL_FAILED
- */
-public class SpectorMemoryException extends SpectorException {
-
-    public SpectorMemoryException(ErrorCode errorCode, Object... args) {
-        super(errorCode, args);
-    }
-
-    public SpectorMemoryException(ErrorCode errorCode, String preformattedMessage, boolean isPreformatted) {
-        super(errorCode, preformattedMessage, isPreformatted);
-    }
-
-    public SpectorMemoryException(ErrorCode errorCode, Throwable cause, Object... args) {
-        super(errorCode, cause, args);
-    }
-}
diff --git a/spector-commons/src/main/java/com/spectrayan/spector/commons/error/SpectorServerException.java b/spector-commons/src/main/java/com/spectrayan/spector/commons/error/SpectorServerException.java
deleted file mode 100644
index 8c65984..0000000
--- a/spector-commons/src/main/java/com/spectrayan/spector/commons/error/SpectorServerException.java
+++ /dev/null
@@ -1,41 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.commons.error;
-
-/**
- * Exception for server-side transport errors ({@code SPE-500-xxx}).
- *
- * <p>Base class for REST API, gRPC, and MCP server errors. The subclass
- * {@link SpectorApiException} adds HTTP status code mapping.</p>
- *
- * @see ErrorCode#API_BAD_REQUEST
- * @see ErrorCode#MCP_TOOL_FAILED
- * @see SpectorApiException
- */
-public class SpectorServerException extends SpectorException {
-
-    public SpectorServerException(ErrorCode errorCode, Object... args) {
-        super(errorCode, args);
-    }
-
-    public SpectorServerException(ErrorCode errorCode, String preformattedMessage, boolean isPreformatted) {
-        super(errorCode, preformattedMessage, isPreformatted);
-    }
-
-    public SpectorServerException(ErrorCode errorCode, Throwable cause, Object... args) {
-        super(errorCode, cause, args);
-    }
-}
diff --git a/spector-commons/src/main/java/com/spectrayan/spector/commons/error/SpectorStorageException.java b/spector-commons/src/main/java/com/spectrayan/spector/commons/error/SpectorStorageException.java
deleted file mode 100644
index 82ae03a..0000000
--- a/spector-commons/src/main/java/com/spectrayan/spector/commons/error/SpectorStorageException.java
+++ /dev/null
@@ -1,41 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.commons.error;
-
-/**
- * Exception for vector store, memory-mapped I/O, off-heap, and disk errors ({@code SPE-210-xxx}).
- *
- * <p>Covers memory segment lifecycle, mmap failures, store capacity, disk I/O,
- * WAL operations, and file format issues.</p>
- *
- * @see ErrorCode#SEGMENT_CLOSED
- * @see ErrorCode#MMAP_FAILED
- * @see ErrorCode#WAL_WRITE_FAILED
- */
-public class SpectorStorageException extends SpectorException {
-
-    public SpectorStorageException(ErrorCode errorCode, Object... args) {
-        super(errorCode, args);
-    }
-
-    public SpectorStorageException(ErrorCode errorCode, String preformattedMessage, boolean isPreformatted) {
-        super(errorCode, preformattedMessage, isPreformatted);
-    }
-
-    public SpectorStorageException(ErrorCode errorCode, Throwable cause, Object... args) {
-        super(errorCode, cause, args);
-    }
-}
diff --git a/spector-commons/src/main/java/com/spectrayan/spector/commons/error/SpectorValidationException.java b/spector-commons/src/main/java/com/spectrayan/spector/commons/error/SpectorValidationException.java
deleted file mode 100644
index 1f479b7..0000000
--- a/spector-commons/src/main/java/com/spectrayan/spector/commons/error/SpectorValidationException.java
+++ /dev/null
@@ -1,66 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.commons.error;
-
-/**
- * Exception for input validation failures ({@code SPE-100-xxx}).
- *
- * <p>Thrown when user-supplied arguments violate API contracts: null values,
- * out-of-range parameters, dimension mismatches, empty collections, etc.</p>
- *
- * <p>Replaces raw {@link IllegalArgumentException} throws at public API boundaries
- * with structured, identifiable error codes.</p>
- *
- * <h3>Usage</h3>
- * <pre>{@code
- *   if (dimensions < 1)
- *       throw new SpectorValidationException(ErrorCode.DIMENSIONS_INVALID, dimensions);
- *   // → "[SPE-100-001] Vector dimensions must be positive, got 0"
- *
- *   if (vector == null)
- *       throw new SpectorValidationException(ErrorCode.VECTOR_NULL);
- *   // → "[SPE-100-003] Vector must not be null"
- * }</pre>
- *
- * @see ErrorCode
- */
-public class SpectorValidationException extends SpectorException {
-
-    /**
-     * Creates a validation exception with a formatted message.
-     *
-     * @param errorCode the validation error code (must be in the SPE-100-xxx range)
-     * @param args      values to substitute into the message template
-     */
-    public SpectorValidationException(ErrorCode errorCode, Object... args) {
-        super(errorCode, args);
-    }
-
-    public SpectorValidationException(ErrorCode errorCode, String preformattedMessage, boolean isPreformatted) {
-        super(errorCode, preformattedMessage, isPreformatted);
-    }
-
-    /**
-     * Creates a validation exception with a cause and formatted message.
-     *
-     * @param errorCode the validation error code
-     * @param cause     the underlying exception
-     * @param args      values to substitute into the message template
-     */
-    public SpectorValidationException(ErrorCode errorCode, Throwable cause, Object... args) {
-        super(errorCode, cause, args);
-    }
-}
diff --git a/spector-commons/src/main/java/com/spectrayan/spector/commons/error/package-info.java b/spector-commons/src/main/java/com/spectrayan/spector/commons/error/package-info.java
deleted file mode 100644
index 7d1bdc1..0000000
--- a/spector-commons/src/main/java/com/spectrayan/spector/commons/error/package-info.java
+++ /dev/null
@@ -1,34 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-/**
- * Spector exception framework — structured error codes, exception hierarchy,
- * and categorized error handling.
- *
- * <p>This package provides the foundation for all Spector error handling:
- * <ul>
- *   <li>{@link com.spectrayan.spector.commons.error.ErrorCode} — central registry of all
- *       error codes ({@code SPE-XXX-YYY} schema)</li>
- *   <li>{@link com.spectrayan.spector.commons.error.ErrorCategory} — error category
- *       definitions with numeric ranges</li>
- *   <li>{@link com.spectrayan.spector.commons.error.SpectorException} — abstract
- *       base exception carrying an {@code ErrorCode}</li>
- * </ul>
- *
- * <p>Module-specific exception subclasses live in their respective module packages.
- *
- * @see com.spectrayan.spector.commons.error.ErrorCode
- */
-package com.spectrayan.spector.commons.error;
diff --git a/spector-commons/src/main/java/com/spectrayan/spector/commons/package-info.java b/spector-commons/src/main/java/com/spectrayan/spector/commons/package-info.java
index a460cef..3e2f3a2 100644
--- a/spector-commons/src/main/java/com/spectrayan/spector/commons/package-info.java
+++ b/spector-commons/src/main/java/com/spectrayan/spector/commons/package-info.java
@@ -1,20 +1,5 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 /**
- * Shared utilities for the Spector engine.
+ * Shared utilities for the Spector Search engine.
  *
  * <p>Contains framework-independent helpers for content extraction,
  * text chunking, and normalization that are used across multiple modules.</p>
diff --git a/spector-commons/src/main/java/com/spectrayan/spector/commons/valhalla/ValueCandidate.java b/spector-commons/src/main/java/com/spectrayan/spector/commons/valhalla/ValueCandidate.java
deleted file mode 100644
index 009961f..0000000
--- a/spector-commons/src/main/java/com/spectrayan/spector/commons/valhalla/ValueCandidate.java
+++ /dev/null
@@ -1,78 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.commons.valhalla;
-
-import java.lang.annotation.Documented;
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Marks a record or class as a candidate for migration to a
- * <a href="https://openjdk.org/jeps/401">JEP 401 Value Class</a>
- * when Project Valhalla lands in a GA JDK release.
- *
- * <h3>Requirements for Value Class Migration</h3>
- * <ul>
- *   <li>All instance fields must be {@code final} (records satisfy this by default)</li>
- *   <li>No {@code synchronized} blocks or use as a monitor</li>
- *   <li>No identity-sensitive operations ({@code ==} comparison, {@code System.identityHashCode})</li>
- *   <li>No subclasses (records are implicitly {@code final})</li>
- * </ul>
- *
- * <h3>Expected Benefits</h3>
- * <ul>
- *   <li><b>Heap flattening</b> — value arrays store fields contiguously, eliminating object headers</li>
- *   <li><b>Scalarization</b> — JIT can decompose value objects into registers, avoiding allocation</li>
- *   <li><b>Cache locality</b> — contiguous memory layout eliminates pointer chasing in arrays</li>
- * </ul>
- *
- * <p>On the {@code labs/valhalla} branch, annotated types are converted to {@code value record}.
- * On {@code main}, this annotation serves as documentation for future migration.</p>
- *
- * @see <a href="https://openjdk.org/jeps/401">JEP 401: Value Classes and Objects (Preview)</a>
- * @see <a href="https://openjdk.org/projects/valhalla/">Project Valhalla</a>
- */
-@Documented
-@Retention(RetentionPolicy.RUNTIME)
-@Target(ElementType.TYPE)
-public @interface ValueCandidate {
-
-    /**
-     * Brief rationale for why this type is a good value class candidate.
-     */
-    String reason() default "";
-
-    /**
-     * Estimated allocation frequency on the hot path.
-     */
-    Frequency hotPathFrequency() default Frequency.HIGH;
-
-    /**
-     * Allocation frequency categories.
-     */
-    enum Frequency {
-        /** Millions of allocations per search (e.g., HNSW neighbor candidates). */
-        CRITICAL,
-        /** Thousands of allocations per query (e.g., result sets). */
-        HIGH,
-        /** Tens of allocations per request (e.g., response wrappers). */
-        MEDIUM,
-        /** Rarely allocated on the hot path. */
-        LOW
-    }
-}
diff --git a/spector-commons/src/main/resources/spector-defaults.yml b/spector-commons/src/main/resources/spector-defaults.yml
deleted file mode 100644
index 0c404b8..0000000
--- a/spector-commons/src/main/resources/spector-defaults.yml
+++ /dev/null
@@ -1,110 +0,0 @@
-# ═══════════════════════════════════════════════════════════════════════
-# Spector — Default Configuration
-# ═══════════════════════════════════════════════════════════════════════
-#
-# This file is bundled inside the JAR and provides sensible defaults.
-# Override any value by placing a 'spector.yml' in the working directory,
-# using a profile file (spector-{profile}.yml), system properties
-# (-Dspector.engine.dimensions=768), or environment variables
-# (SPECTOR_ENGINE_DIMENSIONS=768).
-#
-# Resolution order (highest priority wins):
-#   1. Programmatic overrides
-#   2. System properties
-#   3. Environment variables
-#   4. spector-{profile}.yml
-#   5. spector.yml (working directory)
-#   6. spector-defaults.yml (this file, classpath)
-# ═══════════════════════════════════════════════════════════════════════
-
-spector:
-
-  # ─── Engine (core search engine) ───
-  engine:
-    dimensions: 384
-    capacity: 100000
-    similarity: COSINE
-    index-type: HNSW
-    quantization: NONE
-    persistence-mode: IN_MEMORY
-    data-directory: .spector/index
-    oversampling-factor: 0
-    gpu-enabled: false
-
-  # ─── HNSW Index Parameters ───
-  hnsw:
-    m: 16
-    ef-construction: 200
-    ef-search: 50
-
-  # ─── IVF/PQ Parameters ───
-  ivf:
-    nlist: 0
-    nprobe: 0
-    pq-subspaces: 0
-
-  # ─── SPECTRUM Adaptive Index ───
-  spectrum:
-    n-centroids: 256
-    n-probe: 16
-    shard-threshold: 20000
-    oversampling-factor: 3
-    kmeans-iterations: 25
-
-  # ─── Embedding Provider ───
-  embedding:
-    model: nomic-embed-text
-    base-url: http://localhost:11434
-    timeout: 30s
-    batch-size: 32
-    max-retries: 3
-
-  # ─── Text Chunking ───
-  chunking:
-    max-tokens: 512
-    overlap-tokens: 50
-
-  # ─── Reranker ───
-  reranker:
-    enabled: false
-    ollama-url: http://localhost:11434
-    model: llama3.2
-    max-candidates: 20
-
-  # ─── Persistence File Names ───
-  persistence:
-    files:
-      index: index.spct
-      vectors: vectors.mmap
-      documents: documents.dat
-      id-mappings: id-mappings.dat
-
-  # ─── RAG (Retrieval-Augmented Generation) ───
-  rag:
-    top-k: 5
-    similarity-threshold: 0.7
-    token-limit: 4096
-
-  # ─── Cognitive Memory Module ───
-  memory:
-    enabled: false
-    persistence-mode: DISK
-    persistence-path: .spector-memory
-    dimensions: 384
-    capacity: 100000
-    decay-enabled: true
-    consolidation-interval: 60s
-
-  # ─── File Ingestion ───
-  ingestion:
-    root-directory: .
-    file-pattern: "**/*.md"
-    skip-dirs: ".git,.idea,.mvn,target,node_modules,.github"
-    chunk-size: 800
-    chunk-overlap: 100
-
-  # ─── Cluster ───
-  cluster:
-    shard-count: 1
-    replica-count: 0
-    shard-strategy: HASH
diff --git a/spector-commons/src/test/java/com/spectrayan/spector/commons/ContentExtractorTest.java b/spector-commons/src/test/java/com/spectrayan/spector/commons/ContentExtractorTest.java
index 4d04f59..7fd0206 100644
--- a/spector-commons/src/test/java/com/spectrayan/spector/commons/ContentExtractorTest.java
+++ b/spector-commons/src/test/java/com/spectrayan/spector/commons/ContentExtractorTest.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.commons;
 
 import static org.assertj.core.api.Assertions.assertThat;
diff --git a/spector-commons/src/test/java/com/spectrayan/spector/commons/ResourceUtilsTest.java b/spector-commons/src/test/java/com/spectrayan/spector/commons/ResourceUtilsTest.java
deleted file mode 100644
index 2055d39..0000000
--- a/spector-commons/src/test/java/com/spectrayan/spector/commons/ResourceUtilsTest.java
+++ /dev/null
@@ -1,70 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.commons;
-
-import org.junit.jupiter.api.AfterEach;
-import org.junit.jupiter.api.Test;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.assertThatThrownBy;
-
-/**
- * Tests for {@link ResourceUtils}.
- */
-class ResourceUtilsTest {
-
-    @AfterEach
-    void tearDown() {
-        ResourceUtils.clearCache();
-    }
-
-    @Test
-    void loadResourceThrowsForMissing() {
-        assertThatThrownBy(() -> ResourceUtils.loadResource("nonexistent/file.txt"))
-                .isInstanceOf(IllegalArgumentException.class)
-                .hasMessageContaining("not found");
-    }
-
-    @Test
-    void loadResourceOrDefaultReturnsFallback() {
-        String result = ResourceUtils.loadResourceOrDefault("nonexistent.txt", "fallback");
-        assertThat(result).isEqualTo("fallback");
-    }
-
-    @Test
-    void existsReturnsFalseForMissing() {
-        assertThat(ResourceUtils.exists("nonexistent/resource.txt")).isFalse();
-    }
-
-    @Test
-    void evictRemovesFromCache() {
-        // Pre-populate cache via loadResourceOrDefault (it won't cache on miss)
-        ResourceUtils.clearCache();
-        assertThat(ResourceUtils.cacheSize()).isZero();
-    }
-
-    @Test
-    void clearCacheEmptiesAll() {
-        ResourceUtils.clearCache();
-        assertThat(ResourceUtils.cacheSize()).isZero();
-    }
-
-    @Test
-    void loadResourceReturnsNullForNullPath() {
-        assertThatThrownBy(() -> ResourceUtils.loadResource(null))
-                .isInstanceOf(NullPointerException.class);
-    }
-}
diff --git a/spector-commons/src/test/java/com/spectrayan/spector/commons/StreamingChunkerTest.java b/spector-commons/src/test/java/com/spectrayan/spector/commons/StreamingChunkerTest.java
index d1d356d..11b989b 100644
--- a/spector-commons/src/test/java/com/spectrayan/spector/commons/StreamingChunkerTest.java
+++ b/spector-commons/src/test/java/com/spectrayan/spector/commons/StreamingChunkerTest.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.commons;
 
 import static org.assertj.core.api.Assertions.assertThat;
diff --git a/spector-commons/src/test/java/com/spectrayan/spector/commons/TextChunkerTest.java b/spector-commons/src/test/java/com/spectrayan/spector/commons/TextChunkerTest.java
index b997b60..1727434 100644
--- a/spector-commons/src/test/java/com/spectrayan/spector/commons/TextChunkerTest.java
+++ b/spector-commons/src/test/java/com/spectrayan/spector/commons/TextChunkerTest.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.commons;
 
 import static org.assertj.core.api.Assertions.assertThat;
@@ -124,11 +109,11 @@ void defaultChunkSize() {
     @Test
     void invalidConfigThrows() {
         assertThatThrownBy(() -> new TextChunker(0, 0))
-                .isInstanceOf(com.spectrayan.spector.commons.error.SpectorValidationException.class);
+                .isInstanceOf(IllegalArgumentException.class);
         assertThatThrownBy(() -> new TextChunker(100, 100))
-                .isInstanceOf(com.spectrayan.spector.commons.error.SpectorValidationException.class);
+                .isInstanceOf(IllegalArgumentException.class);
         assertThatThrownBy(() -> new TextChunker(100, -1))
-                .isInstanceOf(com.spectrayan.spector.commons.error.SpectorValidationException.class);
+                .isInstanceOf(IllegalArgumentException.class);
     }
 
     @Test
diff --git a/spector-commons/src/test/java/com/spectrayan/spector/commons/TextUtilsTest.java b/spector-commons/src/test/java/com/spectrayan/spector/commons/TextUtilsTest.java
index fd13ff4..ea1e668 100644
--- a/spector-commons/src/test/java/com/spectrayan/spector/commons/TextUtilsTest.java
+++ b/spector-commons/src/test/java/com/spectrayan/spector/commons/TextUtilsTest.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.commons;
 
 import static org.assertj.core.api.Assertions.assertThat;
diff --git a/spector-commons/src/test/java/com/spectrayan/spector/commons/TokenAwareChunkerTest.java b/spector-commons/src/test/java/com/spectrayan/spector/commons/TokenAwareChunkerTest.java
index 13d5787..0cc0575 100644
--- a/spector-commons/src/test/java/com/spectrayan/spector/commons/TokenAwareChunkerTest.java
+++ b/spector-commons/src/test/java/com/spectrayan/spector/commons/TokenAwareChunkerTest.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.commons;
 
 import org.junit.jupiter.api.Test;
@@ -34,34 +19,34 @@ class TokenAwareChunkerTest {
     @Test
     void configRejectsZeroMaxTokens() {
         assertThatThrownBy(() -> new ChunkConfig(0, 0))
-                .isInstanceOf(com.spectrayan.spector.commons.error.SpectorValidationException.class)
+                .isInstanceOf(IllegalArgumentException.class)
                 .hasMessageContaining("maxTokens");
     }
 
     @Test
     void configRejectsNegativeMaxTokens() {
         assertThatThrownBy(() -> new ChunkConfig(-1, 0))
-                .isInstanceOf(com.spectrayan.spector.commons.error.SpectorValidationException.class);
+                .isInstanceOf(IllegalArgumentException.class);
     }
 
     @Test
     void configRejectsMaxTokensAbove8192() {
         assertThatThrownBy(() -> new ChunkConfig(8193, 0))
-                .isInstanceOf(com.spectrayan.spector.commons.error.SpectorValidationException.class)
+                .isInstanceOf(IllegalArgumentException.class)
                 .hasMessageContaining("8192");
     }
 
     @Test
     void configRejectsOverlapEqualToMaxTokens() {
         assertThatThrownBy(() -> new ChunkConfig(100, 100))
-                .isInstanceOf(com.spectrayan.spector.commons.error.SpectorValidationException.class)
+                .isInstanceOf(IllegalArgumentException.class)
                 .hasMessageContaining("overlap");
     }
 
     @Test
     void configRejectsNegativeOverlap() {
         assertThatThrownBy(() -> new ChunkConfig(100, -1))
-                .isInstanceOf(com.spectrayan.spector.commons.error.SpectorValidationException.class);
+                .isInstanceOf(IllegalArgumentException.class);
     }
 
     @Test
diff --git a/spector-commons/src/test/java/com/spectrayan/spector/commons/TokenChunkerTest.java b/spector-commons/src/test/java/com/spectrayan/spector/commons/TokenChunkerTest.java
index 2595f77..5dd4292 100644
--- a/spector-commons/src/test/java/com/spectrayan/spector/commons/TokenChunkerTest.java
+++ b/spector-commons/src/test/java/com/spectrayan/spector/commons/TokenChunkerTest.java
@@ -1,22 +1,5 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.commons;
 
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 
@@ -83,11 +66,11 @@ void defaultConfig() {
     @Test
     void invalidConfigThrows() {
         assertThatThrownBy(() -> new TokenChunker(0, 0))
-                .isInstanceOf(SpectorValidationException.class);
+                .isInstanceOf(IllegalArgumentException.class);
         assertThatThrownBy(() -> new TokenChunker(10, 10))
-                .isInstanceOf(SpectorValidationException.class);
+                .isInstanceOf(IllegalArgumentException.class);
         assertThatThrownBy(() -> new TokenChunker(10, -1))
-                .isInstanceOf(SpectorValidationException.class);
+                .isInstanceOf(IllegalArgumentException.class);
     }
 
     @Test
diff --git a/spector-commons/src/test/java/com/spectrayan/spector/commons/WordTokenizerTest.java b/spector-commons/src/test/java/com/spectrayan/spector/commons/WordTokenizerTest.java
index e41a1fc..f45d1e0 100644
--- a/spector-commons/src/test/java/com/spectrayan/spector/commons/WordTokenizerTest.java
+++ b/spector-commons/src/test/java/com/spectrayan/spector/commons/WordTokenizerTest.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.commons;
 
 import static org.assertj.core.api.Assertions.assertThat;
diff --git a/spector-commons/src/test/java/com/spectrayan/spector/commons/concurrent/MemoryPinningTest.java b/spector-commons/src/test/java/com/spectrayan/spector/commons/concurrent/MemoryPinningTest.java
deleted file mode 100644
index 904934e..0000000
--- a/spector-commons/src/test/java/com/spectrayan/spector/commons/concurrent/MemoryPinningTest.java
+++ /dev/null
@@ -1,69 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.commons.concurrent;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-import java.io.IOException;
-import java.io.RandomAccessFile;
-import java.lang.foreign.Arena;
-import java.lang.foreign.MemorySegment;
-import java.nio.channels.FileChannel;
-import java.nio.file.Files;
-import java.nio.file.Path;
-
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.io.TempDir;
-
-class MemoryPinningTest {
-
-    @Test
-    void nullSegmentReturnsFalse() {
-        assertThat(MemoryPinning.lock(null)).isFalse();
-        assertThat(MemoryPinning.unlock(null)).isFalse();
-    }
-
-    @Test
-    void nonMappedSegmentReturnsFalse() {
-        MemorySegment heapSegment = MemorySegment.ofArray(new byte[1024]);
-        assertThat(MemoryPinning.lock(heapSegment)).isFalse();
-        assertThat(MemoryPinning.unlock(heapSegment)).isFalse();
-    }
-
-    @Test
-    void mappedSegmentPinning(@TempDir Path tempDir) throws IOException {
-        Path file = tempDir.resolve("test_pinning.dat");
-        Files.write(file, new byte[1024]);
-
-        try (var raf = new RandomAccessFile(file.toFile(), "rw");
-             var channel = raf.getChannel();
-             var arena = Arena.ofConfined()) {
-            
-            MemorySegment mappedSegment = channel.map(FileChannel.MapMode.READ_WRITE, 0, 1024, arena);
-            
-            // Try locking. Even if locking fails due to insufficient system/ulimit privileges,
-            // the method must handle it gracefully, return false/true, and NEVER throw an exception.
-            boolean locked = MemoryPinning.lock(mappedSegment);
-            
-            // Unlocking should behave identically and securely
-            boolean unlocked = MemoryPinning.unlock(mappedSegment);
-            
-            if (locked) {
-                assertThat(unlocked).isTrue();
-            }
-        }
-    }
-}
diff --git a/spector-commons/src/test/java/com/spectrayan/spector/commons/concurrent/NativeOsMemoryTest.java b/spector-commons/src/test/java/com/spectrayan/spector/commons/concurrent/NativeOsMemoryTest.java
deleted file mode 100644
index 27039f2..0000000
--- a/spector-commons/src/test/java/com/spectrayan/spector/commons/concurrent/NativeOsMemoryTest.java
+++ /dev/null
@@ -1,65 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.commons.concurrent;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-import java.io.IOException;
-import java.io.RandomAccessFile;
-import java.lang.foreign.Arena;
-import java.lang.foreign.MemorySegment;
-import java.nio.channels.FileChannel;
-import java.nio.file.Files;
-import java.nio.file.Path;
-
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.io.TempDir;
-
-class NativeOsMemoryTest {
-
-    @Test
-    void nullSegmentReturnsFalse() {
-        assertThat(NativeOsMemory.advise(null, NativeOsMemory.MADV_WILLNEED)).isFalse();
-    }
-
-    @Test
-    void nonMappedSegmentReturnsFalse() {
-        MemorySegment heapSegment = MemorySegment.ofArray(new byte[1024]);
-        assertThat(NativeOsMemory.advise(heapSegment, NativeOsMemory.MADV_WILLNEED)).isFalse();
-    }
-
-    @Test
-    void mappedSegmentAdvice(@TempDir Path tempDir) throws IOException {
-        Path file = tempDir.resolve("test_advice.dat");
-        Files.write(file, new byte[1024]);
-
-        try (var raf = new RandomAccessFile(file.toFile(), "rw");
-             var channel = raf.getChannel();
-             var arena = Arena.ofConfined()) {
-            
-            MemorySegment mappedSegment = channel.map(FileChannel.MapMode.READ_WRITE, 0, 1024, arena);
-            assertThat(mappedSegment.isMapped()).isTrue();
-
-            // The core contract: advise() MUST NEVER throw exceptions, even if the
-            // underlying madvise(2) syscall is unavailable or fails (e.g. in sandboxed
-            // CI containers). On Windows it returns true (safe no-op), on Linux it
-            // returns true if madvise succeeds or false if the kernel rejects it.
-            // We do NOT assert the return value since it depends on OS/container config.
-            NativeOsMemory.advise(mappedSegment, NativeOsMemory.MADV_WILLNEED);
-            NativeOsMemory.advise(mappedSegment, NativeOsMemory.MADV_DONTNEED);
-        }
-    }
-}
diff --git a/spector-commons/src/test/java/com/spectrayan/spector/commons/document/DocumentReaderTest.java b/spector-commons/src/test/java/com/spectrayan/spector/commons/document/DocumentReaderTest.java
index 82d66e7..ccb5c3d 100644
--- a/spector-commons/src/test/java/com/spectrayan/spector/commons/document/DocumentReaderTest.java
+++ b/spector-commons/src/test/java/com/spectrayan/spector/commons/document/DocumentReaderTest.java
@@ -1,22 +1,5 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.commons.document;
 
-import com.spectrayan.spector.commons.error.SpectorDocumentReadException;
-
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.io.TempDir;
 
@@ -142,7 +125,7 @@ void pdfReader_corruptedFileThrowsException() throws IOException {
         Files.writeString(file, "This is not a real PDF", StandardCharsets.UTF_8);
 
         assertThatThrownBy(() -> new PdfDocumentReader().read(file))
-                .isInstanceOf(SpectorDocumentReadException.class)
+                .isInstanceOf(DocumentReadException.class)
                 .hasMessageContaining("corrupt.pdf");
     }
 
@@ -151,7 +134,7 @@ void pdfReader_nonExistentFileThrowsException() {
         Path file = tempDir.resolve("missing.pdf");
 
         assertThatThrownBy(() -> new PdfDocumentReader().read(file))
-                .isInstanceOf(SpectorDocumentReadException.class)
+                .isInstanceOf(DocumentReadException.class)
                 .hasMessageContaining("does not exist");
     }
 
@@ -163,7 +146,7 @@ void factory_unsupportedFormatThrows() throws IOException {
         Files.writeString(file, "some data", StandardCharsets.UTF_8);
 
         assertThatThrownBy(() -> DocumentReaderFactory.read(file))
-                .isInstanceOf(SpectorDocumentReadException.class)
+                .isInstanceOf(DocumentReadException.class)
                 .hasMessageContaining("unsupported format")
                 .hasMessageContaining("PDF")
                 .hasMessageContaining("HTML")
@@ -176,7 +159,7 @@ void factory_noExtensionThrows() throws IOException {
         Files.writeString(file, "some data", StandardCharsets.UTF_8);
 
         assertThatThrownBy(() -> DocumentReaderFactory.read(file))
-                .isInstanceOf(SpectorDocumentReadException.class)
+                .isInstanceOf(DocumentReadException.class)
                 .hasMessageContaining("unsupported format");
     }
 
@@ -210,7 +193,7 @@ void markdownReader_emptyFileThrows() throws IOException {
         Files.writeString(file, "   \n   \n  ", StandardCharsets.UTF_8);
 
         assertThatThrownBy(() -> new MarkdownDocumentReader().read(file))
-                .isInstanceOf(SpectorDocumentReadException.class)
+                .isInstanceOf(DocumentReadException.class)
                 .hasMessageContaining("no extractable text");
     }
 }
diff --git a/spector-commons/src/test/java/com/spectrayan/spector/commons/error/ErrorCodeTest.java b/spector-commons/src/test/java/com/spectrayan/spector/commons/error/ErrorCodeTest.java
deleted file mode 100644
index e274bd9..0000000
--- a/spector-commons/src/test/java/com/spectrayan/spector/commons/error/ErrorCodeTest.java
+++ /dev/null
@@ -1,252 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.commons.error;
-
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.EnumSource;
-
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Map;
-import java.util.Set;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.assertThatThrownBy;
-
-/**
- * Tests for the ErrorCode registry, ErrorCategory ranges, and SpectorException hierarchy.
- */
-class ErrorCodeTest {
-
-    // ─────────────── Uniqueness ───────────────
-
-    @Test
-    void allCodesAreUnique() {
-        Map<Integer, ErrorCode> seen = new HashMap<>();
-        for (ErrorCode ec : ErrorCode.values()) {
-            ErrorCode prev = seen.put(ec.code(), ec);
-            assertThat(prev)
-                    .describedAs("Duplicate code %d: %s and %s", ec.code(), ec.name(), prev)
-                    .isNull();
-        }
-    }
-
-    @Test
-    void allIdsAreUnique() {
-        Set<String> seen = new HashSet<>();
-        for (ErrorCode ec : ErrorCode.values()) {
-            boolean added = seen.add(ec.id());
-            assertThat(added)
-                    .describedAs("Duplicate id: %s (%s)", ec.id(), ec.name())
-                    .isTrue();
-        }
-    }
-
-    // ─────────────── Category Range ───────────────
-
-    @ParameterizedTest
-    @EnumSource(ErrorCode.class)
-    void everyCodeFallsWithinItsCategoryRange(ErrorCode ec) {
-        ErrorCategory cat = ec.category();
-        assertThat(cat.contains(ec.code()))
-                .describedAs("%s (code=%d) should be in %s range [%d000–%d999]",
-                        ec.name(), ec.code(), cat.name(), cat.rangeStart(), cat.rangeEnd())
-                .isTrue();
-    }
-
-    // ─────────────── ID Formatting ───────────────
-
-    @Test
-    void idFormatMatchesSpeXxxYyy() {
-        for (ErrorCode ec : ErrorCode.values()) {
-            assertThat(ec.id())
-                    .matches("SPE-\\d{3}-\\d{3}")
-                    .describedAs("ID for %s should match SPE-XXX-YYY", ec.name());
-        }
-    }
-
-    @Test
-    void specificIdValues() {
-        assertThat(ErrorCode.DIMENSIONS_INVALID.id()).isEqualTo("SPE-100-001");
-        assertThat(ErrorCode.CONFIG_FILE_NOT_FOUND.id()).isEqualTo("SPE-110-001");
-        assertThat(ErrorCode.HNSW_BUILD_FAILED.id()).isEqualTo("SPE-200-001");
-        assertThat(ErrorCode.SEGMENT_CLOSED.id()).isEqualTo("SPE-210-001");
-        assertThat(ErrorCode.EMBEDDING_UNAVAILABLE.id()).isEqualTo("SPE-300-001");
-        assertThat(ErrorCode.MEMORY_TIER_FULL.id()).isEqualTo("SPE-310-001");
-        assertThat(ErrorCode.CUDA_DRIVER_NOT_FOUND.id()).isEqualTo("SPE-400-001");
-        assertThat(ErrorCode.API_BAD_REQUEST.id()).isEqualTo("SPE-500-001");
-        assertThat(ErrorCode.CLIENT_CONNECTION_FAILED.id()).isEqualTo("SPE-510-001");
-        assertThat(ErrorCode.INGESTION_FORMAT_UNSUPPORTED.id()).isEqualTo("SPE-600-001");
-        assertThat(ErrorCode.SHARD_UNAVAILABLE.id()).isEqualTo("SPE-700-001");
-        assertThat(ErrorCode.INTERNAL_ERROR.id()).isEqualTo("SPE-900-001");
-    }
-
-    // ─────────────── Lookup ───────────────
-
-    @ParameterizedTest
-    @EnumSource(ErrorCode.class)
-    void fromCodeRoundTrips(ErrorCode ec) {
-        assertThat(ErrorCode.fromCode(ec.code())).isSameAs(ec);
-    }
-
-    @ParameterizedTest
-    @EnumSource(ErrorCode.class)
-    void fromIdRoundTrips(ErrorCode ec) {
-        assertThat(ErrorCode.fromId(ec.id())).isSameAs(ec);
-    }
-
-    @Test
-    void fromCodeReturnsNullForUnknown() {
-        assertThat(ErrorCode.fromCode(999_999)).isNull();
-    }
-
-    @Test
-    void fromIdReturnsNullForMalformed() {
-        assertThat(ErrorCode.fromId(null)).isNull();
-        assertThat(ErrorCode.fromId("")).isNull();
-        assertThat(ErrorCode.fromId("not-a-code")).isNull();
-        assertThat(ErrorCode.fromId("SPE-999-999")).isNull();
-        assertThat(ErrorCode.fromId("ABC-100-001")).isNull();
-    }
-
-    // ─────────────── Message Formatting ───────────────
-
-    @Test
-    void formatWithNoArgs() {
-        String msg = ErrorCode.VECTOR_NULL.format();
-        assertThat(msg).isEqualTo("[SPE-100-003] Vector must not be null");
-    }
-
-    @Test
-    void formatWithOneArg() {
-        String msg = ErrorCode.DIMENSIONS_INVALID.format(0);
-        assertThat(msg).isEqualTo("[SPE-100-001] Vector dimensions must be positive, got 0");
-    }
-
-    @Test
-    void formatWithTwoArgs() {
-        String msg = ErrorCode.DIMENSIONS_MISMATCH.format(384, 768);
-        assertThat(msg).isEqualTo("[SPE-100-002] Expected 384 dimensions but received 768");
-    }
-
-    @Test
-    void formatWithFourArgs() {
-        String msg = ErrorCode.ARGUMENT_OUT_OF_RANGE.format("topK", 1, 10000, 0);
-        assertThat(msg).isEqualTo("[SPE-100-008] topK must be between 1 and 10000, got 0");
-    }
-
-    @Test
-    void formatWithExtraArgsIgnoresExtras() {
-        String msg = ErrorCode.VECTOR_NULL.format("extra", "ignored");
-        assertThat(msg).isEqualTo("[SPE-100-003] Vector must not be null");
-    }
-
-    @Test
-    void formatWithFewerArgsThanPlaceholders() {
-        String msg = ErrorCode.DIMENSIONS_MISMATCH.format(384);
-        assertThat(msg).isEqualTo("[SPE-100-002] Expected 384 dimensions but received {}");
-    }
-
-    // ─────────────── Message Templates ───────────────
-
-    @ParameterizedTest
-    @EnumSource(ErrorCode.class)
-    void allMessageTemplatesAreNonEmpty(ErrorCode ec) {
-        assertThat(ec.messageTemplate())
-                .describedAs("Message template for %s", ec.name())
-                .isNotNull()
-                .isNotBlank();
-    }
-
-    // ─────────────── Exception Hierarchy ───────────────
-
-    @Test
-    void validationExceptionCarriesErrorCode() throws SpectorException {
-        var ex = new SpectorValidationException(ErrorCode.DIMENSIONS_MISMATCH, 384, 768);
-
-        assertThat(ex).isInstanceOf(SpectorException.class);
-        assertThat(ex).isInstanceOf(Exception.class);
-        assertThat(ex.errorCode()).isEqualTo(ErrorCode.DIMENSIONS_MISMATCH);
-        assertThat(ex.code()).isEqualTo(100_002);
-        assertThat(ex.codeId()).isEqualTo("SPE-100-002");
-        assertThat(ex.category()).isEqualTo(ErrorCategory.VALIDATION);
-        assertThat(ex.getMessage()).isEqualTo("[SPE-100-002] Expected 384 dimensions but received 768");
-    }
-
-    @Test
-    void internalExceptionCarriesErrorCode() throws SpectorException {
-        var ex = new SpectorInternalException(ErrorCode.UNREACHABLE_CODE, "switch on bits=16");
-
-        assertThat(ex).isInstanceOf(SpectorException.class);
-        assertThat(ex.errorCode()).isEqualTo(ErrorCode.UNREACHABLE_CODE);
-        assertThat(ex.code()).isEqualTo(900_003);
-        assertThat(ex.codeId()).isEqualTo("SPE-900-003");
-        assertThat(ex.category()).isEqualTo(ErrorCategory.INTERNAL);
-        assertThat(ex.getMessage()).contains("SPE-900-003");
-        assertThat(ex.getMessage()).contains("switch on bits=16");
-    }
-
-    @Test
-    void exceptionWithCausePreservesCause() {
-        var cause = new RuntimeException("disk full");
-        var ex = new SpectorInternalException(ErrorCode.INTERNAL_ERROR, cause, "write failed");
-
-        assertThat(ex.getCause()).isSameAs(cause);
-        assertThat(ex.getMessage()).contains("SPE-900-001");
-        assertThat(ex.getMessage()).contains("write failed");
-    }
-
-    @Test
-    void spectorExceptionHierarchy() {
-        // SpectorException extends RuntimeException
-        assertThat(Exception.class).isAssignableFrom(SpectorException.class);
-        assertThat(RuntimeException.class.isAssignableFrom(SpectorException.class))
-                .describedAs("SpectorException extends RuntimeException")
-                .isTrue();
-    }
-
-    // ─────────────── ErrorCategory ───────────────
-
-    @Test
-    void categoryContainsWorksCorrectly() {
-        assertThat(ErrorCategory.VALIDATION.contains(100_001)).isTrue();
-        assertThat(ErrorCategory.VALIDATION.contains(100_999)).isTrue();
-        assertThat(ErrorCategory.VALIDATION.contains(109_999)).isTrue();
-        assertThat(ErrorCategory.VALIDATION.contains(110_001)).isFalse(); // CONFIG range
-        assertThat(ErrorCategory.VALIDATION.contains(200_001)).isFalse();
-
-        assertThat(ErrorCategory.INTERNAL.contains(900_001)).isTrue();
-        assertThat(ErrorCategory.INTERNAL.contains(909_999)).isTrue();
-        assertThat(ErrorCategory.INTERNAL.contains(910_001)).isFalse();
-    }
-
-    @Test
-    void allCategoriesHaveDistinctRanges() {
-        ErrorCategory[] cats = ErrorCategory.values();
-        for (int i = 0; i < cats.length; i++) {
-            for (int j = i + 1; j < cats.length; j++) {
-                boolean overlap = cats[i].rangeStart() <= cats[j].rangeEnd()
-                        && cats[j].rangeStart() <= cats[i].rangeEnd();
-                assertThat(overlap)
-                        .describedAs("%s [%d–%d] overlaps with %s [%d–%d]",
-                                cats[i].name(), cats[i].rangeStart(), cats[i].rangeEnd(),
-                                cats[j].name(), cats[j].rangeStart(), cats[j].rangeEnd())
-                        .isFalse();
-            }
-        }
-    }
-}
diff --git a/spector-config/README.md b/spector-config/README.md
deleted file mode 100644
index e7d95ee..0000000
--- a/spector-config/README.md
+++ /dev/null
@@ -1,103 +0,0 @@
-# spector-config ⚙️
-
-> **Configuration system for Spector — YAML-driven, programmatic, and environment-aware.**
-
-`spector-config` defines all tuning parameters for the Spector engine, memory, ingestion, and persistence. It provides both programmatic builders and YAML file loading via `SpectorConfigFactory`.
-
----
-
-## 🏗️ Architecture
-
-```mermaid
-graph TD
-    subgraph "spector-config"
-        SC["SpectorConfig<br/><i>immutable engine config</i>"]
-        SP["SpectorProperties<br/><i>YAML-driven properties</i>"]
-        SCF["SpectorConfigFactory<br/><i>YAML → config builder</i>"]
-        HP["HnswParams<br/><i>HNSW tuning</i>"]
-        IT["IndexType<br/><i>HNSW, IVF_PQ, FLAT</i>"]
-        PM["PersistenceMode<br/><i>MEMORY, DISK</i>"]
-        PF["PersistenceFiles<br/><i>data directory paths</i>"]
-    end
-
-    SCF -->|parses| SP
-    SCF -->|builds| SC
-    SC --> HP
-    SC --> IT
-    SC --> PM
-```
-
----
-
-## 📦 Key Classes
-
-### `SpectorConfig`
-
-Immutable configuration record with fluent `with*()` builder methods:
-
-```java
-var config = SpectorConfig.DEFAULT
-    .withDimensions(384)
-    .withCapacity(100_000)
-    .withQuantization(QuantizationType.SVASQ)
-    .withRescore(3)
-    .withGpu(true);
-```
-
-### `SpectorProperties`
-
-Full YAML-mapped properties for all Spector subsystems:
-
-```yaml
-spector:
-  mode: search
-  engine:
-    dimensions: 768
-    similarity: COSINE
-    capacity: 100000
-    persistence-mode: DISK
-    data-directory: .spector/index
-  embedding:
-    model: nomic-embed-text
-    base-url: http://localhost:11434
-  memory:
-    enabled: true
-    persistence-mode: DISK
-  ingestion:
-    chunk-size: 800
-    chunk-overlap: 100
-```
-
-### `SpectorConfigFactory`
-
-Creates `SpectorConfig` and `SpectorProperties` from YAML:
-
-```java
-SpectorProperties props = SpectorConfigFactory.load(Path.of("spector.yml"));
-SpectorConfig config = SpectorConfigFactory.toEngineConfig(props);
-```
-
----
-
-## 📊 Configuration Parameters
-
-| Parameter | Default | Description |
-|-----------|---------|-------------|
-| `dimensions` | 384 | Vector dimensionality |
-| `capacity` | 100,000 | Max documents |
-| `similarity` | COSINE | Similarity function (COSINE, DOT_PRODUCT, EUCLIDEAN) |
-| `indexType` | HNSW | Index type (HNSW, IVF_PQ, FLAT) |
-| `quantization` | NONE | Quantization (NONE, SCALAR_INT8, SCALAR_INT4, SVASQ, SVASQ_4) |
-| `persistenceMode` | MEMORY | Persistence (MEMORY, DISK) |
-
----
-
-## ⚙️ Dependencies
-
-```xml
-<dependency>
-    <groupId>com.spectrayan</groupId>
-    <artifactId>spector-config</artifactId>
-    <version>0.1.0-SNAPSHOT</version>
-</dependency>
-```
diff --git a/spector-config/pom.xml b/spector-config/pom.xml
deleted file mode 100644
index d6a1f26..0000000
--- a/spector-config/pom.xml
+++ /dev/null
@@ -1,45 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0"
-         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
-    <modelVersion>4.0.0</modelVersion>
-
-    <parent>
-        <groupId>com.spectrayan</groupId>
-        <artifactId>spector</artifactId>
-        <version>0.1.0-SNAPSHOT</version>
-    </parent>
-
-    <artifactId>spector-config</artifactId>
-    <name>Spector Config</name>
-    <description>Centralized configuration: properties, typed config records, and parameter types (IndexType, HnswParams, PersistenceMode).</description>
-
-    <dependencies>
-        <!-- Error framework (ErrorCode, SpectorException) -->
-        <dependency>
-            <groupId>com.spectrayan</groupId>
-            <artifactId>spector-commons</artifactId>
-        </dependency>
-
-        <!-- Core types (SimilarityFunction, QuantizationType) -->
-        <dependency>
-            <groupId>com.spectrayan</groupId>
-            <artifactId>spector-core</artifactId>
-        </dependency>
-
-        <!-- Hierarchical configuration (YAML + properties + env override) -->
-        <dependency>
-            <groupId>org.apache.commons</groupId>
-            <artifactId>commons-configuration2</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>commons-beanutils</groupId>
-            <artifactId>commons-beanutils</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>org.yaml</groupId>
-            <artifactId>snakeyaml</artifactId>
-        </dependency>
-    </dependencies>
-
-</project>
diff --git a/spector-config/src/main/java/com/spectrayan/spector/config/IndexType.java b/spector-config/src/main/java/com/spectrayan/spector/config/IndexType.java
deleted file mode 100644
index 2c8e33c..0000000
--- a/spector-config/src/main/java/com/spectrayan/spector/config/IndexType.java
+++ /dev/null
@@ -1,41 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.config;
-
-/**
- * Selects the vector index implementation.
- *
- * <ul>
- *   <li>{@link #HNSW} — Default graph-based ANN index. Best for datasets up to ~5M vectors.</li>
- *   <li>{@link #IVF_PQ} — Inverted file with product quantization. Best for 1M+ vectors
- *       where memory is constrained. Requires a training step.</li>
- *   <li>{@link #SPECTRUM} — Adaptive IVF + SVASQ-HNSW hybrid index ({@code SpectorIndex}).
- *       Combines IVF coarse routing, per-shard adaptive flat/HNSW search, and SVASQ
- *       residual INT8 quantization. Best overall recall/throughput tradeoff for 100K–10M
- *       vectors. Requires a training step.</li>
- * </ul>
- */
-public enum IndexType {
-
-    /** HNSW (Hierarchical Navigable Small World) graph index. Default. */
-    HNSW,
-
-    /** IVF-PQ (Inverted File with Product Quantization) index. High compression. */
-    IVF_PQ,
-
-    /** Spectrum — Adaptive IVF + SVASQ-HNSW hybrid index. Best recall/throughput. */
-    SPECTRUM
-}
diff --git a/spector-config/src/main/java/com/spectrayan/spector/config/PersistenceFiles.java b/spector-config/src/main/java/com/spectrayan/spector/config/PersistenceFiles.java
deleted file mode 100644
index 8ca716d..0000000
--- a/spector-config/src/main/java/com/spectrayan/spector/config/PersistenceFiles.java
+++ /dev/null
@@ -1,141 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.config;
-
-import com.spectrayan.spector.commons.error.ErrorCode;
-import com.spectrayan.spector.config.error.SpectorConfigValueException;
-
-import java.nio.file.Path;
-
-/**
- * Centralized persistence file names for the Spector engine.
- *
- * <p>Replaces hardcoded file names like {@code "index.spct"}, {@code "vectors.mmap"},
- * etc. scattered across engine factories. File names are configurable via
- * {@link SpectorProperties} under the {@code spector.persistence.files} namespace.</p>
- *
- * <h3>Default File Names</h3>
- * <ul>
- *   <li>{@code index.spct} — HNSW graph structure</li>
- *   <li>{@code vectors.mmap} — Memory-mapped raw float32 vectors</li>
- *   <li>{@code documents.dat} — Document text content</li>
- *   <li>{@code id-mappings.dat} — String ID → integer index mappings</li>
- *   <li>{@code index_shards/} — Directory for sharded index + vector files</li>
- *   </ul>
- *
- * @param indexFile      HNSW index file name
- * @param vectorsFile    memory-mapped vectors file name
- * @param documentsFile  document store file name
- * @param idMappingsFile ID mappings file name
- * @param shardDirName   subdirectory for sharded index/vector files
- */
-public record PersistenceFiles(
-        String indexFile,
-        String vectorsFile,
-        String documentsFile,
-        String idMappingsFile,
-        String shardDirName
-) {
-
-    /** Default file names. */
-    public static final PersistenceFiles DEFAULTS = new PersistenceFiles(
-            "index.spct",
-            "vectors.mmap",
-            "documents.dat",
-            "id-mappings.dat",
-            "index_shards"
-    );
-
-    public PersistenceFiles {
-        if (indexFile == null || indexFile.isBlank())
-            throw new SpectorConfigValueException("indexFile", "must not be blank");
-        if (vectorsFile == null || vectorsFile.isBlank())
-            throw new SpectorConfigValueException("vectorsFile", "must not be blank");
-        if (documentsFile == null || documentsFile.isBlank())
-            throw new SpectorConfigValueException("documentsFile", "must not be blank");
-        if (idMappingsFile == null || idMappingsFile.isBlank())
-            throw new SpectorConfigValueException("idMappingsFile", "must not be blank");
-        if (shardDirName == null || shardDirName.isBlank())
-            throw new SpectorConfigValueException("shardDirName", "must not be blank");
-    }
-
-    /**
-     * Backward-compatible constructor (4-arg) — uses default shard directory name.
-     *
-     * @param indexFile      HNSW index file name
-     * @param vectorsFile    vectors file name
-     * @param documentsFile  document store file name
-     * @param idMappingsFile ID mappings file name
-     */
-    public PersistenceFiles(String indexFile, String vectorsFile,
-                             String documentsFile, String idMappingsFile) {
-        this(indexFile, vectorsFile, documentsFile, idMappingsFile, "index_shards");
-    }
-
-    /**
-     * Creates a {@link PersistenceFiles} from configuration properties.
-     *
-     * @param props the configuration properties
-     * @return persistence file names loaded from config or defaults
-     */
-    public static PersistenceFiles from(SpectorProperties props) {
-        return new PersistenceFiles(
-                props.getString("spector.persistence.files.index", DEFAULTS.indexFile),
-                props.getString("spector.persistence.files.vectors", DEFAULTS.vectorsFile),
-                props.getString("spector.persistence.files.documents", DEFAULTS.documentsFile),
-                props.getString("spector.persistence.files.id-mappings", DEFAULTS.idMappingsFile),
-                props.getString("spector.persistence.files.shard-dir", DEFAULTS.shardDirName)
-        );
-    }
-
-    /**
-     * Resolves the index file path within the given data directory.
-     */
-    public Path resolveIndex(Path dataDir) {
-        return dataDir.resolve(indexFile);
-    }
-
-    /**
-     * Resolves the vectors file path within the given data directory.
-     */
-    public Path resolveVectors(Path dataDir) {
-        return dataDir.resolve(vectorsFile);
-    }
-
-    /**
-     * Resolves the documents file path within the given data directory.
-     */
-    public Path resolveDocuments(Path dataDir) {
-        return dataDir.resolve(documentsFile);
-    }
-
-    /**
-     * Resolves the ID mappings file path within the given data directory.
-     */
-    public Path resolveIdMappings(Path dataDir) {
-        return dataDir.resolve(idMappingsFile);
-    }
-
-    /**
-     * Resolves the shard directory within the given data directory.
-     *
-     * @param dataDir the engine data directory
-     * @return path to the shard directory
-     */
-    public Path resolveShardDir(Path dataDir) {
-        return dataDir.resolve(shardDirName);
-    }
-}
diff --git a/spector-config/src/main/java/com/spectrayan/spector/config/PersistenceMode.java b/spector-config/src/main/java/com/spectrayan/spector/config/PersistenceMode.java
deleted file mode 100644
index c19251f..0000000
--- a/spector-config/src/main/java/com/spectrayan/spector/config/PersistenceMode.java
+++ /dev/null
@@ -1,28 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.config;
-
-/**
- * Supported persistence modes for the search engine.
- */
-public enum PersistenceMode {
-
-    /** All data in memory — lost on shutdown. */
-    IN_MEMORY,
-
-    /** Data persisted to disk via memory-mapped files. Survives restarts. */
-    DISK
-}
diff --git a/spector-config/src/main/java/com/spectrayan/spector/config/SpectorConfigException.java b/spector-config/src/main/java/com/spectrayan/spector/config/SpectorConfigException.java
deleted file mode 100644
index 48b72d0..0000000
--- a/spector-config/src/main/java/com/spectrayan/spector/config/SpectorConfigException.java
+++ /dev/null
@@ -1,72 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.config;
-
-import com.spectrayan.spector.commons.error.ErrorCode;
-
-/**
- * Thrown when Spector configuration loading or validation fails.
- *
- * @deprecated Use {@link com.spectrayan.spector.commons.error.SpectorConfigException} instead.
- *             This class is retained for backward compatibility and will be removed in v0.2.0.
- */
-@Deprecated(since = "0.1.0", forRemoval = true)
-public class SpectorConfigException extends RuntimeException {
-
-    private final ErrorCode errorCode;
-
-    /** @deprecated Use the ErrorCode constructor instead. */
-    @Deprecated
-    public SpectorConfigException(String message) {
-        super(message);
-        this.errorCode = null;
-    }
-
-    /** @deprecated Use the ErrorCode constructor instead. */
-    @Deprecated
-    public SpectorConfigException(String message, Throwable cause) {
-        super(message, cause);
-        this.errorCode = null;
-    }
-
-    /**
-     * Creates a config exception with a structured error code.
-     *
-     * @param errorCode the config error code (SPE-110-xxx)
-     * @param args      values for message template placeholders
-     */
-    public SpectorConfigException(ErrorCode errorCode, Object... args) {
-        super(errorCode.format(args));
-        this.errorCode = errorCode;
-    }
-
-    /**
-     * Creates a config exception with a structured error code and cause.
-     *
-     * @param errorCode the config error code
-     * @param cause     the underlying exception
-     * @param args      values for message template placeholders
-     */
-    public SpectorConfigException(ErrorCode errorCode, Throwable cause, Object... args) {
-        super(errorCode.format(args), cause);
-        this.errorCode = errorCode;
-    }
-
-    /** Returns the error code, or {@code null} for legacy exceptions. */
-    public ErrorCode errorCode() {
-        return errorCode;
-    }
-}
diff --git a/spector-config/src/main/java/com/spectrayan/spector/config/SpectorConfigFactory.java b/spector-config/src/main/java/com/spectrayan/spector/config/SpectorConfigFactory.java
deleted file mode 100644
index b0913b6..0000000
--- a/spector-config/src/main/java/com/spectrayan/spector/config/SpectorConfigFactory.java
+++ /dev/null
@@ -1,352 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.config;
-
-import java.nio.file.Path;
-import java.time.Duration;
-
-/**
- * Central factory for building typed configuration objects from {@link SpectorProperties}.
- *
- * <p>This is the bridge between the hierarchical property file system and the
- * strongly-typed config records used by each Spector module. Each factory method
- * reads from the unified property namespace and produces the corresponding
- * module-level configuration.</p>
- *
- * <h3>Usage</h3>
- * <pre>{@code
- *   SpectorProperties props = SpectorProperties.load();
- *
- *   // Get individual config sections as Maps
- *   int dims = SpectorConfigFactory.engineDimensions(props);
- *   String model = SpectorConfigFactory.embeddingModel(props);
- *
- *   // Or use the full config accessor
- *   EngineDefaults engine = SpectorConfigFactory.engineDefaults(props);
- * }</pre>
- *
- * <p>Module-level config records (SpectorConfig, EmbeddingConfig, etc.)
- * can use these factory methods to construct themselves from properties,
- * keeping the dependency on commons lightweight.</p>
- */
-public final class SpectorConfigFactory {
-
-    private SpectorConfigFactory() {}
-
-    // ─────────────── Engine Defaults ───────────────
-
-    /**
-     * Default values for the Spector engine, loaded from properties.
-     *
-     * @param dimensions      vector dimensionality
-     * @param capacity        maximum document count
-     * @param similarity      similarity function name (COSINE, EUCLIDEAN, DOT_PRODUCT)
-     * @param indexType        vector index type name (HNSW, IVF_PQ, SPECTRUM)
-     * @param quantization    quantization type name (NONE, BINARY, INT8, SVASQ4, SVASQ8)
-     * @param persistenceMode persistence mode name (IN_MEMORY, DISK)
-     * @param dataDirectory   data directory path
-     * @param gpuEnabled      whether GPU acceleration is enabled
-     * @param oversamplingFactor  rescore oversampling factor
-     */
-    public record EngineDefaults(
-            int dimensions,
-            int capacity,
-            String similarity,
-            String indexType,
-            String quantization,
-            String persistenceMode,
-            Path dataDirectory,
-            boolean gpuEnabled,
-            int oversamplingFactor
-    ) {}
-
-    /**
-     * Loads engine defaults from properties.
-     */
-    public static EngineDefaults engineDefaults(SpectorProperties props) {
-        return new EngineDefaults(
-                props.getInt("spector.engine.dimensions", 384),
-                props.getInt("spector.engine.capacity", 100_000),
-                props.getString("spector.engine.similarity", "COSINE"),
-                props.getString("spector.engine.index-type", "HNSW"),
-                props.getString("spector.engine.quantization", "NONE"),
-                props.getString("spector.engine.persistence-mode", "IN_MEMORY"),
-                props.getPath("spector.engine.data-directory", Path.of(".spector", "index")),
-                props.getBoolean("spector.engine.gpu-enabled", false),
-                props.getInt("spector.engine.oversampling-factor", 0)
-        );
-    }
-
-    // ─────────────── HNSW Defaults ───────────────
-
-    /**
-     * Default values for HNSW index parameters.
-     *
-     * @param m              max bi-directional connections per node per layer
-     * @param efConstruction beam width during index construction
-     * @param efSearch       beam width during search
-     */
-    public record HnswDefaults(int m, int efConstruction, int efSearch) {}
-
-    /**
-     * Loads HNSW defaults from properties.
-     */
-    public static HnswDefaults hnswDefaults(SpectorProperties props) {
-        return new HnswDefaults(
-                props.getInt("spector.hnsw.m", 16),
-                props.getInt("spector.hnsw.ef-construction", 200),
-                props.getInt("spector.hnsw.ef-search", 50)
-        );
-    }
-
-    // ─────────────── IVF/PQ Defaults ───────────────
-
-    /**
-     * Default values for IVF/PQ index parameters.
-     */
-    public record IvfDefaults(int nlist, int nprobe, int pqSubspaces) {}
-
-    /**
-     * Loads IVF defaults from properties.
-     */
-    public static IvfDefaults ivfDefaults(SpectorProperties props) {
-        return new IvfDefaults(
-                props.getInt("spector.ivf.nlist", 0),
-                props.getInt("spector.ivf.nprobe", 0),
-                props.getInt("spector.ivf.pq-subspaces", 0)
-        );
-    }
-
-    // ─────────────── Spectrum Defaults ───────────────
-
-    /**
-     * Default values for the SPECTRUM adaptive index.
-     */
-    public record SpectrumDefaults(
-            int nCentroids, int nProbe, int shardThreshold,
-            int oversamplingFactor, int kmeansIterations
-    ) {}
-
-    /**
-     * Loads Spectrum defaults from properties.
-     */
-    public static SpectrumDefaults spectrumDefaults(SpectorProperties props) {
-        return new SpectrumDefaults(
-                props.getInt("spector.spectrum.n-centroids", 256),
-                props.getInt("spector.spectrum.n-probe", 16),
-                props.getInt("spector.spectrum.shard-threshold", 20_000),
-                props.getInt("spector.spectrum.oversampling-factor", 3),
-                props.getInt("spector.spectrum.kmeans-iterations", 25)
-        );
-    }
-
-    // ─────────────── Embedding Defaults ───────────────
-
-    /**
-     * Default values for the embedding provider.
-     *
-     * @param model      embedding model name
-     * @param baseUrl    API base URL
-     * @param timeout    HTTP request timeout
-     * @param batchSize  maximum texts per batch request
-     * @param maxRetries maximum retry attempts
-     */
-    public record EmbeddingDefaults(
-            String model, String baseUrl, Duration timeout,
-            int batchSize, int maxRetries
-    ) {}
-
-    /**
-     * Loads embedding defaults from properties.
-     */
-    public static EmbeddingDefaults embeddingDefaults(SpectorProperties props) {
-        return new EmbeddingDefaults(
-                props.getString("spector.embedding.model", "nomic-embed-text"),
-                props.getString("spector.embedding.base-url", "http://localhost:11434"),
-                props.getDuration("spector.embedding.timeout", Duration.ofSeconds(30)),
-                props.getInt("spector.embedding.batch-size", 32),
-                props.getInt("spector.embedding.max-retries", 3)
-        );
-    }
-
-    // ─────────────── Chunking Defaults ───────────────
-
-    /**
-     * Default values for text chunking.
-     *
-     * @param maxTokens      maximum token count per chunk
-     * @param overlapTokens  overlapping tokens between consecutive chunks
-     */
-    public record ChunkingDefaults(int maxTokens, int overlapTokens) {}
-
-    /**
-     * Loads chunking defaults from properties.
-     */
-    public static ChunkingDefaults chunkingDefaults(SpectorProperties props) {
-        return new ChunkingDefaults(
-                props.getInt("spector.chunking.max-tokens", 512),
-                props.getInt("spector.chunking.overlap-tokens", 50)
-        );
-    }
-
-    // ─────────────── Reranker Defaults ───────────────
-
-    /**
-     * Default values for the LLM reranker.
-     */
-    public record RerankerDefaults(
-            boolean enabled, String ollamaUrl, String model, int maxCandidates
-    ) {}
-
-    /**
-     * Loads reranker defaults from properties.
-     */
-    public static RerankerDefaults rerankerDefaults(SpectorProperties props) {
-        return new RerankerDefaults(
-                props.getBoolean("spector.reranker.enabled", false),
-                props.getString("spector.reranker.ollama-url", "http://localhost:11434"),
-                props.getString("spector.reranker.model", "llama3.2"),
-                props.getInt("spector.reranker.max-candidates", 20)
-        );
-    }
-
-    // ─────────────── RAG Defaults ───────────────
-
-    /**
-     * Default values for RAG retrieval.
-     */
-    public record RagDefaults(int topK, float similarityThreshold, int tokenLimit) {}
-
-    /**
-     * Loads RAG defaults from properties.
-     */
-    public static RagDefaults ragDefaults(SpectorProperties props) {
-        return new RagDefaults(
-                props.getInt("spector.rag.top-k", 5),
-                props.getFloat("spector.rag.similarity-threshold", 0.7f),
-                props.getInt("spector.rag.token-limit", 4096)
-        );
-    }
-
-    // ─────────────── Cluster Defaults ───────────────
-
-    /**
-     * Default values for clustering.
-     */
-    public record ClusterDefaults(int shardCount, int replicaCount, String shardStrategy) {}
-
-    /**
-     * Loads cluster defaults from properties.
-     */
-    public static ClusterDefaults clusterDefaults(SpectorProperties props) {
-        return new ClusterDefaults(
-                props.getInt("spector.cluster.shard-count", 1),
-                props.getInt("spector.cluster.replica-count", 0),
-                props.getString("spector.cluster.shard-strategy", "HASH")
-        );
-    }
-
-    // ─────────────── Memory Defaults ───────────────
-
-    /**
-     * Default values for the cognitive memory module.
-     *
-     * @param enabled          whether cognitive memory is enabled
-     * @param persistenceMode  DISK or IN_MEMORY
-     * @param persistencePath  directory for memory tier persistence files
-     * @param dimensions       vector dimensionality for memory embeddings
-     * @param capacity         maximum memory entries
-     * @param decayEnabled     whether temporal decay is enabled
-     * @param consolidationInterval  time between memory consolidation runs
-     * @param defaultIngestionTier   default memory tier for ingestion (e.g., "SEMANTIC")
-     * @param hnswPrefilter          HNSW pre-filter mode ("auto", "enabled", "disabled")
-     */
-    public record MemoryDefaults(
-            boolean enabled,
-            String persistenceMode, Path persistencePath,
-            int dimensions, int capacity,
-            boolean decayEnabled, Duration consolidationInterval,
-            String defaultIngestionTier, String hnswPrefilter
-    ) {}
-
-    /**
-     * Loads memory defaults from properties.
-     */
-    public static MemoryDefaults memoryDefaults(SpectorProperties props) {
-        return new MemoryDefaults(
-                props.getBoolean("spector.memory.enabled", false),
-                props.getString("spector.memory.persistence-mode", "DISK"),
-                props.getPath("spector.memory.persistence-path", Path.of(".spector", "memory")),
-                props.getInt("spector.memory.dimensions", 384),
-                props.getInt("spector.memory.capacity", 100_000),
-                props.getBoolean("spector.memory.decay-enabled", true),
-                props.getDuration("spector.memory.consolidation-interval", Duration.ofSeconds(60)),
-                props.getString("spector.memory.default-ingestion-tier", "SEMANTIC"),
-                props.getString("spector.memory.hnsw-prefilter", "auto")
-        );
-    }
-
-    // ─────────────── Global Mode ───────────────
-
-    /**
-     * Resolves the global operating mode: {@code SEARCH} or {@code MEMORY}.
-     *
-     * <p>Reads {@code spector.mode} from properties (default: {@code "search"}).
-     * In MEMORY mode, the runtime auto-enables cognitive memory and routes
-     * ingestion/search through the unified memory pipeline.</p>
-     *
-     * @param props hierarchical configuration
-     * @return the resolved mode
-     */
-    public static SpectorMode mode(SpectorProperties props) {
-        String raw = props.getString("spector.mode", "search");
-        return SpectorMode.valueOf(raw.toUpperCase());
-    }
-
-    // ─────────────── Ingestion Defaults ───────────────
-
-    /**
-     * Default values for file ingestion.
-     *
-     * @param rootDirectory root directory for file discovery (default: .)
-     * @param filePattern   glob pattern for file discovery (e.g., "**\/*.md")
-     * @param skipDirs      comma-separated directories to skip
-     * @param chunkSize     target chunk size in characters
-     * @param chunkOverlap  overlap between consecutive chunks
-     */
-    public record IngestionDefaults(
-            Path rootDirectory, String filePattern, String skipDirs,
-            int chunkSize, int chunkOverlap,
-            int parallelism, int maxRetries, int retryDelayMs
-    ) {}
-
-    /**
-     * Loads ingestion defaults from properties.
-     */
-    public static IngestionDefaults ingestionDefaults(SpectorProperties props) {
-        return new IngestionDefaults(
-                props.getPath("spector.ingestion.root-directory", Path.of(".")),
-                props.getString("spector.ingestion.file-pattern", "**/*.md"),
-                props.getString("spector.ingestion.skip-dirs", ".git,.idea,.mvn,target,node_modules,.github"),
-                props.getInt("spector.ingestion.chunk-size", 800),
-                props.getInt("spector.ingestion.chunk-overlap", 100),
-                props.getInt("spector.ingestion.parallelism", 4),
-                props.getInt("spector.ingestion.max-retries", 3),
-                props.getInt("spector.ingestion.retry-delay-ms", 2000)
-        );
-    }
-}
-
diff --git a/spector-config/src/main/java/com/spectrayan/spector/config/SpectorMode.java b/spector-config/src/main/java/com/spectrayan/spector/config/SpectorMode.java
deleted file mode 100644
index 0bccd80..0000000
--- a/spector-config/src/main/java/com/spectrayan/spector/config/SpectorMode.java
+++ /dev/null
@@ -1,36 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.config;
-
-/**
- * Global operating mode for a Spector instance.
- *
- * <ul>
- *   <li>{@link #SEARCH} — traditional vector search engine (default)</li>
- *   <li>{@link #MEMORY} — cognitive memory mode with biological mechanisms
- *       (auto-enables memory, routes ingestion/search through memory pipeline)</li>
- * </ul>
- *
- * <p>Set via {@code spector.mode} in configuration (default: {@code search}).</p>
- */
-public enum SpectorMode {
-
-    /** Traditional vector search engine. */
-    SEARCH,
-
-    /** Cognitive memory mode with decay, consolidation, and importance scoring. */
-    MEMORY
-}
diff --git a/spector-config/src/main/java/com/spectrayan/spector/config/SpectorProperties.java b/spector-config/src/main/java/com/spectrayan/spector/config/SpectorProperties.java
deleted file mode 100644
index 6040191..0000000
--- a/spector-config/src/main/java/com/spectrayan/spector/config/SpectorProperties.java
+++ /dev/null
@@ -1,505 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.config;
-
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-import com.spectrayan.spector.commons.error.ErrorCode;
-import com.spectrayan.spector.config.error.SpectorConfigNotFoundException;
-
-import org.apache.commons.configuration2.CombinedConfiguration;
-import org.apache.commons.configuration2.Configuration;
-import org.apache.commons.configuration2.MapConfiguration;
-import org.apache.commons.configuration2.PropertiesConfiguration;
-import org.apache.commons.configuration2.YAMLConfiguration;
-import org.apache.commons.configuration2.ex.ConfigurationException;
-import org.apache.commons.configuration2.tree.OverrideCombiner;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.Reader;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.time.Duration;
-import java.util.Iterator;
-import java.util.Map;
-import java.util.Objects;
-import java.util.Properties;
-import com.spectrayan.spector.commons.error.ErrorCode;
-
-/**
- * Spring Boot-style hierarchical configuration loader for Spector.
- *
- * <p>Provides a single point of entry for all configuration across modules.
- * Uses Apache Commons Configuration 2 under the hood with a
- * {@link CombinedConfiguration} and {@link OverrideCombiner} to layer
- * multiple configuration sources.</p>
- *
- * <h3>Resolution Order (highest priority wins)</h3>
- * <ol>
- *   <li>Programmatic overrides (via {@link Builder#override(String, Object)})</li>
- *   <li>System properties ({@code -Dspector.engine.dimensions=768})</li>
- *   <li>Environment variables ({@code SPECTOR_ENGINE_DIMENSIONS=768})</li>
- *   <li>Profile-specific file ({@code spector-{profile}.yml})</li>
- *   <li>User config file ({@code spector.yml} in working directory)</li>
- *   <li>Classpath defaults ({@code spector-defaults.yml} in JAR)</li>
- * </ol>
- *
- * <h3>Usage</h3>
- * <pre>{@code
- *   // Auto-detect (loads from working dir + classpath defaults)
- *   SpectorProperties props = SpectorProperties.load();
- *
- *   // With profile
- *   SpectorProperties props = SpectorProperties.load("production");
- *
- *   // From explicit file
- *   SpectorProperties props = SpectorProperties.load(Path.of("/etc/spector/spector.yml"));
- *
- *   // Typed access
- *   int dims = props.getInt("spector.engine.dimensions", 384);
- *   String model = props.getString("spector.embedding.model", "nomic-embed-text");
- *   Duration timeout = props.getDuration("spector.embedding.timeout", Duration.ofSeconds(30));
- * }</pre>
- *
- * <h3>Environment Variable Mapping</h3>
- * <p>Dot-notation keys are mapped to environment variables by uppercasing and
- * replacing dots/hyphens with underscores:</p>
- * <ul>
- *   <li>{@code spector.engine.dimensions} → {@code SPECTOR_ENGINE_DIMENSIONS}</li>
- *   <li>{@code spector.hnsw.ef-construction} → {@code SPECTOR_HNSW_EF_CONSTRUCTION}</li>
- * </ul>
- */
-public final class SpectorProperties {
-
-    private static final Logger log = LoggerFactory.getLogger(SpectorProperties.class);
-
-    /** Default config file name in working directory. */
-    private static final String DEFAULT_CONFIG_FILE = "spector.yml";
-
-    /** Default config file name on classpath (bundled in JAR). */
-    private static final String CLASSPATH_DEFAULTS = "spector-defaults.yml";
-
-    /** Profile config file pattern. */
-    private static final String PROFILE_PATTERN = "spector-%s.yml";
-
-    private final CombinedConfiguration config;
-
-    private SpectorProperties(CombinedConfiguration config) {
-        if (config == null) { throw new SpectorValidationException(ErrorCode.ARGUMENT_NULL, "config"); } this.config = config;
-    }
-
-    // ─────────────── Static Factory Methods ───────────────
-
-    /**
-     * Loads configuration with auto-detection.
-     * <p>Checks for a {@code spector.profile} system property or
-     * {@code SPECTOR_PROFILE} environment variable to determine the active profile.</p>
-     */
-    public static SpectorProperties load() {
-        String profile = System.getProperty("spector.profile",
-                System.getenv().getOrDefault("SPECTOR_PROFILE", null));
-        return new Builder().profile(profile).build();
-    }
-
-    /**
-     * Loads configuration from classpath defaults only — no filesystem discovery.
-     * <p>Useful for tests that should not be affected by a {@code spector.yml}
-     * file in the working directory.</p>
-     */
-    public static SpectorProperties loadClasspathOnly() {
-        return new Builder().skipFilesystemDiscovery(true).build();
-    }
-
-    /**
-     * Loads configuration with the specified profile.
-     *
-     * @param profile the active profile name (e.g., "dev", "production"), or null for none
-     */
-    public static SpectorProperties load(String profile) {
-        return new Builder().profile(profile).build();
-    }
-
-    /**
-     * Loads configuration from an explicit file path.
-     *
-     * @param configFile path to the primary configuration file
-     */
-    public static SpectorProperties load(Path configFile) {
-        return new Builder().configFile(configFile).build();
-    }
-
-    /**
-     * Creates a new builder for fine-grained control over configuration loading.
-     */
-    public static Builder builder() {
-        return new Builder();
-    }
-
-    // ─────────────── Typed Accessors ───────────────
-
-    /**
-     * Returns the string value for the given key, or {@code null} if not found.
-     */
-    public String getString(String key) {
-        return resolveWithEnv(key, null);
-    }
-
-    /**
-     * Returns the string value for the given key, or the default if not found.
-     */
-    public String getString(String key, String defaultValue) {
-        String value = resolveWithEnv(key, null);
-        return value != null ? value : defaultValue;
-    }
-
-    /**
-     * Returns the integer value for the given key, or the default if not found.
-     */
-    public int getInt(String key, int defaultValue) {
-        String value = resolveWithEnv(key, null);
-        if (value != null) {
-            try {
-                return Integer.parseInt(value);
-            } catch (NumberFormatException e) {
-                log.warn("Invalid integer for key '{}': '{}', using default {}", key, value, defaultValue);
-            }
-        }
-        return config.getInt(key, defaultValue);
-    }
-
-    /**
-     * Returns the long value for the given key, or the default if not found.
-     */
-    public long getLong(String key, long defaultValue) {
-        String value = resolveWithEnv(key, null);
-        if (value != null) {
-            try {
-                return Long.parseLong(value);
-            } catch (NumberFormatException e) {
-                log.warn("Invalid long for key '{}': '{}', using default {}", key, value, defaultValue);
-            }
-        }
-        return config.getLong(key, defaultValue);
-    }
-
-    /**
-     * Returns the boolean value for the given key, or the default if not found.
-     */
-    public boolean getBoolean(String key, boolean defaultValue) {
-        String value = resolveWithEnv(key, null);
-        if (value != null) {
-            return Boolean.parseBoolean(value);
-        }
-        return config.getBoolean(key, defaultValue);
-    }
-
-    /**
-     * Returns the double value for the given key, or the default if not found.
-     */
-    public double getDouble(String key, double defaultValue) {
-        String value = resolveWithEnv(key, null);
-        if (value != null) {
-            try {
-                return Double.parseDouble(value);
-            } catch (NumberFormatException e) {
-                log.warn("Invalid double for key '{}': '{}', using default {}", key, value, defaultValue);
-            }
-        }
-        return config.getDouble(key, defaultValue);
-    }
-
-    /**
-     * Returns the float value for the given key, or the default if not found.
-     */
-    public float getFloat(String key, float defaultValue) {
-        String value = resolveWithEnv(key, null);
-        if (value != null) {
-            try {
-                return Float.parseFloat(value);
-            } catch (NumberFormatException e) {
-                log.warn("Invalid float for key '{}': '{}', using default {}", key, value, defaultValue);
-            }
-        }
-        return config.getFloat(key, defaultValue);
-    }
-
-    /**
-     * Returns a {@link Duration} parsed from the given key.
-     * <p>Supports formats: {@code 30s}, {@code 5m}, {@code 1h}, {@code 500ms},
-     * or ISO-8601 ({@code PT30S}).</p>
-     */
-    public Duration getDuration(String key, Duration defaultValue) {
-        String value = getString(key);
-        if (value == null || value.isBlank()) return defaultValue;
-        return parseDuration(value, key, defaultValue);
-    }
-
-    /**
-     * Returns a {@link Path} for the given key, or the default if not found.
-     */
-    public Path getPath(String key, Path defaultValue) {
-        String value = getString(key);
-        if (value == null || value.isBlank()) return defaultValue;
-        return Path.of(value);
-    }
-
-    /**
-     * Returns an enum value for the given key, or the default if not found.
-     */
-    public <E extends Enum<E>> E getEnum(String key, Class<E> enumType, E defaultValue) {
-        String value = getString(key);
-        if (value == null || value.isBlank()) return defaultValue;
-        try {
-            return Enum.valueOf(enumType, value.toUpperCase().replace('-', '_'));
-        } catch (IllegalArgumentException e) {
-            log.warn("Invalid {} value for key '{}': '{}', using default {}",
-                    enumType.getSimpleName(), key, value, defaultValue);
-            return defaultValue;
-        }
-    }
-
-    /**
-     * Returns a view of this configuration scoped to the given prefix.
-     * <p>Example: {@code subset("spector.embedding")} returns a view where
-     * the key {@code "model"} maps to {@code "spector.embedding.model"}.</p>
-     */
-    public SpectorProperties subset(String prefix) {
-        CombinedConfiguration sub = new CombinedConfiguration(new OverrideCombiner());
-        sub.addConfiguration(config.subset(prefix));
-        return new SpectorProperties(sub);
-    }
-
-    /**
-     * Checks if the configuration contains the given key.
-     */
-    public boolean containsKey(String key) {
-        return resolveWithEnv(key, null) != null || config.containsKey(key);
-    }
-
-    /**
-     * Returns all keys in the configuration.
-     */
-    public Iterator<String> getKeys() {
-        return config.getKeys();
-    }
-
-    // ─────────────── Environment Variable Resolution ───────────────
-
-    /**
-     * Resolves a key by first checking system properties, then environment
-     * variables (with dot-to-underscore mapping), then the configuration.
-     */
-    private String resolveWithEnv(String key, String defaultValue) {
-        // 1. System property
-        String sysProp = System.getProperty(key);
-        if (sysProp != null) return sysProp;
-
-        // 2. Environment variable (spector.engine.dimensions → SPECTOR_ENGINE_DIMENSIONS)
-        String envKey = key.toUpperCase().replace('.', '_').replace('-', '_');
-        String envValue = System.getenv(envKey);
-        if (envValue != null) return envValue;
-
-        // 3. Configuration file
-        String configValue = config.getString(key, null);
-        return configValue != null ? configValue : defaultValue;
-    }
-
-    // ─────────────── Duration Parsing ───────────────
-
-    private static Duration parseDuration(String value, String key, Duration defaultValue) {
-        try {
-            // Try ISO-8601 first (PT30S, PT5M, etc.)
-            if (value.startsWith("PT") || value.startsWith("pt")) {
-                return Duration.parse(value);
-            }
-
-            // Human-readable: 30s, 5m, 1h, 500ms
-            String trimmed = value.trim().toLowerCase();
-            if (trimmed.endsWith("ms")) {
-                return Duration.ofMillis(Long.parseLong(trimmed.substring(0, trimmed.length() - 2).trim()));
-            } else if (trimmed.endsWith("s")) {
-                return Duration.ofSeconds(Long.parseLong(trimmed.substring(0, trimmed.length() - 1).trim()));
-            } else if (trimmed.endsWith("m")) {
-                return Duration.ofMinutes(Long.parseLong(trimmed.substring(0, trimmed.length() - 1).trim()));
-            } else if (trimmed.endsWith("h")) {
-                return Duration.ofHours(Long.parseLong(trimmed.substring(0, trimmed.length() - 1).trim()));
-            }
-
-            // Try as seconds if just a number
-            return Duration.ofSeconds(Long.parseLong(trimmed));
-        } catch (Exception e) {
-            log.warn("Invalid duration for key '{}': '{}', using default {}", key, value, defaultValue);
-            return defaultValue;
-        }
-    }
-
-    // ─────────────── Builder ───────────────
-
-    /**
-     * Builder for fine-grained control over {@link SpectorProperties} construction.
-     */
-    public static class Builder {
-        private String profile;
-        private Path configFile;
-        private boolean skipFilesystem;
-        private final Properties overrides = new Properties();
-
-        private Builder() {}
-
-        /** Sets the active profile (e.g., "dev", "production"). */
-        public Builder profile(String profile) {
-            this.profile = profile;
-            return this;
-        }
-
-        /** Sets an explicit configuration file path. */
-        public Builder configFile(Path configFile) {
-            this.configFile = configFile;
-            return this;
-        }
-
-        /** If true, skip loading from working-directory files (spector.yml, spector.properties). */
-        Builder skipFilesystemDiscovery(boolean skip) {
-            this.skipFilesystem = skip;
-            return this;
-        }
-
-        /** Adds a programmatic override. */
-        public Builder override(String key, Object value) {
-            overrides.setProperty(key, String.valueOf(value));
-            return this;
-        }
-
-        /** Adds multiple programmatic overrides. */
-        public Builder overrides(Map<String, ?> overrides) {
-            overrides.forEach((k, v) -> this.overrides.setProperty(k, String.valueOf(v)));
-            return this;
-        }
-
-        /**
-         * Builds the {@link SpectorProperties} instance.
-         *
-         * <p>Layer order (first added = highest priority with OverrideCombiner):</p>
-         * <ol>
-         *   <li>Programmatic overrides</li>
-         *   <li>Profile-specific YAML (if profile set)</li>
-         *   <li>User config file (explicit path or spector.yml in working dir)</li>
-         *   <li>Classpath defaults (spector-defaults.yml)</li>
-         * </ol>
-         */
-        public SpectorProperties build() {
-            CombinedConfiguration combined = new CombinedConfiguration(new OverrideCombiner());
-
-            // 1. Programmatic overrides (highest priority)
-            if (!overrides.isEmpty()) {
-                @SuppressWarnings({"unchecked", "rawtypes"})
-                MapConfiguration overrideConfig = new MapConfiguration((Map) overrides);
-                combined.addConfiguration(overrideConfig, "overrides");
-                log.debug("[SpectorProperties] Added {} programmatic overrides", overrides.size());
-            }
-
-            // 2. Profile-specific file
-            if (profile != null && !profile.isBlank()) {
-                String profileFileName = String.format(PROFILE_PATTERN, profile);
-                loadFileIfExists(combined, Path.of(profileFileName), "profile-" + profile);
-                loadClasspathYaml(combined, profileFileName, "classpath-profile-" + profile);
-            }
-
-            // 3. User config file
-            if (configFile != null) {
-                loadFileOrFail(combined, configFile, "user-config");
-            } else if (!skipFilesystem) {
-                // Try spector.yml in working directory
-                loadFileIfExists(combined, Path.of(DEFAULT_CONFIG_FILE), "user-config");
-                // Also try spector.properties as fallback
-                loadPropertiesIfExists(combined, Path.of("spector.properties"), "user-properties");
-            }
-
-            // 4. Classpath defaults (lowest priority)
-            loadClasspathYaml(combined, CLASSPATH_DEFAULTS, "classpath-defaults");
-
-            log.info("[SpectorProperties] Loaded {} configuration sources{}",
-                    combined.getNumberOfConfigurations(),
-                    profile != null ? " (profile: " + profile + ")" : "");
-
-            return new SpectorProperties(combined);
-        }
-
-        // ─── File Loading Helpers ───
-
-        private void loadFileIfExists(CombinedConfiguration combined, Path path, String name) {
-            if (Files.isRegularFile(path)) {
-                try {
-                    String fileName = path.getFileName().toString();
-                    if (fileName.endsWith(".yml") || fileName.endsWith(".yaml")) {
-                        YAMLConfiguration yaml = new YAMLConfiguration();
-                        try (Reader reader = Files.newBufferedReader(path)) {
-                            yaml.read(reader);
-                        }
-                        combined.addConfiguration(yaml, name);
-                        log.debug("[SpectorProperties] Loaded YAML: {}", path.toAbsolutePath());
-                    } else if (fileName.endsWith(".properties")) {
-                        PropertiesConfiguration props = new PropertiesConfiguration();
-                        try (Reader reader = Files.newBufferedReader(path)) {
-                            props.read(reader);
-                        }
-                        combined.addConfiguration(props, name);
-                        log.debug("[SpectorProperties] Loaded properties: {}", path.toAbsolutePath());
-                    }
-                } catch (ConfigurationException | IOException e) {
-                    log.warn("[SpectorProperties] Failed to load {}: {}", path, e.getMessage());
-                }
-            }
-        }
-
-        private void loadFileOrFail(CombinedConfiguration combined, Path path, String name) {
-            if (!Files.isRegularFile(path)) {
-                throw new SpectorConfigNotFoundException(path.toAbsolutePath().toString());
-            }
-            loadFileIfExists(combined, path, name);
-        }
-
-        private void loadPropertiesIfExists(CombinedConfiguration combined, Path path, String name) {
-            if (Files.isRegularFile(path)) {
-                try {
-                    PropertiesConfiguration props = new PropertiesConfiguration();
-                    try (Reader reader = Files.newBufferedReader(path)) {
-                        props.read(reader);
-                    }
-                    combined.addConfiguration(props, name);
-                    log.debug("[SpectorProperties] Loaded properties: {}", path.toAbsolutePath());
-                } catch (ConfigurationException | IOException e) {
-                    log.warn("[SpectorProperties] Failed to load {}: {}", path, e.getMessage());
-                }
-            }
-        }
-
-        private void loadClasspathYaml(CombinedConfiguration combined, String resource, String name) {
-            try (InputStream is = SpectorProperties.class.getClassLoader().getResourceAsStream(resource)) {
-                if (is != null) {
-                    YAMLConfiguration yaml = new YAMLConfiguration();
-                    yaml.read(new java.io.InputStreamReader(is));
-                    combined.addConfiguration(yaml, name);
-                    log.debug("[SpectorProperties] Loaded classpath: {}", resource);
-                }
-            } catch (ConfigurationException | IOException e) {
-                log.warn("[SpectorProperties] Failed to load classpath {}: {}", resource, e.getMessage());
-            }
-        }
-    }
-}
diff --git a/spector-config/src/main/java/com/spectrayan/spector/config/error/SpectorConfigNotFoundException.java b/spector-config/src/main/java/com/spectrayan/spector/config/error/SpectorConfigNotFoundException.java
deleted file mode 100644
index aba0b7f..0000000
--- a/spector-config/src/main/java/com/spectrayan/spector/config/error/SpectorConfigNotFoundException.java
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.config.error;
-
-import com.spectrayan.spector.commons.error.*;
-
-/**
- * Exception thrown when a configuration file cannot be found at the specified path.
- *
- * @see SpectorConfigException
- */
-public class SpectorConfigNotFoundException extends SpectorConfigException {
-
-    private final String path;
-
-    public SpectorConfigNotFoundException(String path) {
-        super(ErrorCode.CONFIG_FILE_NOT_FOUND, path);
-        this.path = path;
-    }
-
-    public SpectorConfigNotFoundException(String path, Throwable cause) {
-        super(ErrorCode.CONFIG_FILE_NOT_FOUND, cause, path);
-        this.path = path;
-    }
-
-    /** Returns the path to the configuration file that was not found. */
-    public String getPath() {
-        return path;
-    }
-}
diff --git a/spector-config/src/main/java/com/spectrayan/spector/config/error/SpectorConfigParseException.java b/spector-config/src/main/java/com/spectrayan/spector/config/error/SpectorConfigParseException.java
deleted file mode 100644
index 98d5ec7..0000000
--- a/spector-config/src/main/java/com/spectrayan/spector/config/error/SpectorConfigParseException.java
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.config.error;
-
-import com.spectrayan.spector.commons.error.*;
-
-/**
- * Exception thrown when configuration parsing fails.
- *
- * @see SpectorConfigException
- */
-public class SpectorConfigParseException extends SpectorConfigException {
-
-    private final String details;
-
-    public SpectorConfigParseException(String details) {
-        super(ErrorCode.CONFIG_PARSE_FAILED, details);
-        this.details = details;
-    }
-
-    public SpectorConfigParseException(String details, Throwable cause) {
-        super(ErrorCode.CONFIG_PARSE_FAILED, cause, details);
-        this.details = details;
-    }
-
-    /** Returns the details of the parsing failure. */
-    public String getDetails() {
-        return details;
-    }
-}
diff --git a/spector-config/src/main/java/com/spectrayan/spector/config/error/SpectorConfigValueException.java b/spector-config/src/main/java/com/spectrayan/spector/config/error/SpectorConfigValueException.java
deleted file mode 100644
index 17361b2..0000000
--- a/spector-config/src/main/java/com/spectrayan/spector/config/error/SpectorConfigValueException.java
+++ /dev/null
@@ -1,63 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.config.error;
-
-import com.spectrayan.spector.commons.error.*;
-
-/**
- * Exception thrown when a configuration value is invalid or a required key is missing.
- *
- * @see SpectorConfigException
- */
-public class SpectorConfigValueException extends SpectorConfigException {
-
-    private final String key;
-    private final Object value;
-
-    public SpectorConfigValueException(String key, Object value) {
-        super(ErrorCode.CONFIG_VALUE_INVALID, key, value);
-        this.key = key;
-        this.value = value;
-    }
-
-    public SpectorConfigValueException(String key, Object value, Throwable cause) {
-        super(ErrorCode.CONFIG_VALUE_INVALID, cause, key, value);
-        this.key = key;
-        this.value = value;
-    }
-
-    public SpectorConfigValueException(ErrorCode errorCode, String key, Object value) {
-        super(errorCode, key, value);
-        this.key = key;
-        this.value = value;
-    }
-
-    public SpectorConfigValueException(ErrorCode errorCode, Throwable cause, String key, Object value) {
-        super(errorCode, cause, key, value);
-        this.key = key;
-        this.value = value;
-    }
-
-    /** Returns the configuration key that has an invalid or missing value. */
-    public String getKey() {
-        return key;
-    }
-
-    /** Returns the invalid value, or null if the key was missing. */
-    public Object getValue() {
-        return value;
-    }
-}
diff --git a/spector-config/src/main/resources/spector-defaults.yml b/spector-config/src/main/resources/spector-defaults.yml
deleted file mode 100644
index 438d10f..0000000
--- a/spector-config/src/main/resources/spector-defaults.yml
+++ /dev/null
@@ -1,116 +0,0 @@
-# ═══════════════════════════════════════════════════════════════════════
-# Spector — Default Configuration
-# ═══════════════════════════════════════════════════════════════════════
-#
-# This file is bundled inside the JAR and provides sensible defaults.
-# Override any value by placing a 'spector.yml' in the working directory,
-# using a profile file (spector-{profile}.yml), system properties
-# (-Dspector.engine.dimensions=768), or environment variables
-# (SPECTOR_ENGINE_DIMENSIONS=768).
-#
-# Resolution order (highest priority wins):
-#   1. Programmatic overrides
-#   2. System properties
-#   3. Environment variables
-#   4. spector-{profile}.yml
-#   5. spector.yml (working directory)
-#   6. spector-defaults.yml (this file, classpath)
-# ═══════════════════════════════════════════════════════════════════════
-
-spector:
-
-  # ─── Engine (core search engine) ───
-  engine:
-    dimensions: 384
-    capacity: 100000
-    similarity: COSINE
-    index-type: HNSW
-    quantization: NONE
-    persistence-mode: IN_MEMORY
-    data-directory: .spector/index
-    oversampling-factor: 0
-    gpu-enabled: false
-
-  # ─── HNSW Index Parameters ───
-  hnsw:
-    m: 16
-    ef-construction: 200
-    ef-search: 50
-
-  # ─── IVF/PQ Parameters ───
-  ivf:
-    nlist: 0
-    nprobe: 0
-    pq-subspaces: 0
-
-  # ─── SPECTRUM Adaptive Index ───
-  spectrum:
-    n-centroids: 256
-    n-probe: 16
-    shard-threshold: 20000
-    oversampling-factor: 3
-    kmeans-iterations: 25
-
-  # ─── Embedding Provider ───
-  embedding:
-    model: nomic-embed-text
-    base-url: http://localhost:11434
-    timeout: 30s
-    batch-size: 32
-    max-retries: 3
-
-  # ─── Text Chunking ───
-  chunking:
-    max-tokens: 512
-    overlap-tokens: 50
-
-  # ─── Reranker ───
-  reranker:
-    enabled: false
-    ollama-url: http://localhost:11434
-    model: llama3.2
-    max-candidates: 20
-
-  # ─── Persistence File Names ───
-  persistence:
-    files:
-      index: index.spct
-      vectors: vectors.mmap
-      documents: documents.dat
-      id-mappings: id-mappings.dat
-
-  # ─── RAG (Retrieval-Augmented Generation) ───
-  rag:
-    top-k: 5
-    similarity-threshold: 0.7
-    token-limit: 4096
-
-  # ─── Cognitive Memory Module ───
-  memory:
-    enabled: false
-    persistence-mode: DISK
-    persistence-path: .spector/memory
-    dimensions: 384
-    capacity: 100000
-    decay-enabled: true
-    consolidation-interval: 60s
-    # Cognitive profile configuration (operational feature flags).
-    # Controls which profiles are available at runtime.
-    # Valid values: ALL, CORE_ONLY, WITH_NEURODIVERGENT, or a comma-separated
-    # list of profile names (e.g., "BALANCED,DEBUGGING,HYPERFOCUS").
-    # Default: ALL — BSL license governs commercial use, not this config.
-    cognitive-profiles: ALL
-
-  # ─── File Ingestion ───
-  ingestion:
-    root-directory: .
-    file-pattern: "**/*.md"
-    skip-dirs: ".git,.idea,.mvn,target,node_modules,.github"
-    chunk-size: 800
-    chunk-overlap: 100
-
-  # ─── Cluster ───
-  cluster:
-    shard-count: 1
-    replica-count: 0
-    shard-strategy: HASH
diff --git a/spector-config/src/test/java/com/spectrayan/spector/config/SpectorConfigFactoryTest.java b/spector-config/src/test/java/com/spectrayan/spector/config/SpectorConfigFactoryTest.java
deleted file mode 100644
index e9fb381..0000000
--- a/spector-config/src/test/java/com/spectrayan/spector/config/SpectorConfigFactoryTest.java
+++ /dev/null
@@ -1,161 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.config;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-import org.junit.jupiter.api.Test;
-
-import java.nio.file.Path;
-import java.time.Duration;
-
-/**
- * Tests for {@link SpectorConfigFactory} — verifies property-to-config mapping.
- */
-class SpectorConfigFactoryTest {
-
-    @Test
-    void engineDefaults_fromClasspathDefaults() {
-        SpectorProperties props = SpectorProperties.load();
-        var engine = SpectorConfigFactory.engineDefaults(props);
-
-        assertThat(engine.dimensions()).isEqualTo(384);
-        assertThat(engine.capacity()).isEqualTo(100_000);
-        assertThat(engine.similarity()).isEqualTo("COSINE");
-        assertThat(engine.indexType()).isEqualTo("HNSW");
-        assertThat(engine.quantization()).isEqualTo("NONE");
-        assertThat(engine.persistenceMode()).isEqualTo("IN_MEMORY");
-        assertThat(engine.dataDirectory()).isEqualTo(Path.of(".spector", "index"));
-        assertThat(engine.gpuEnabled()).isFalse();
-        assertThat(engine.oversamplingFactor()).isEqualTo(0);
-    }
-
-    @Test
-    void engineDefaults_withOverrides() {
-        SpectorProperties props = SpectorProperties.builder()
-                .override("spector.engine.dimensions", "1024")
-                .override("spector.engine.capacity", "500000")
-                .override("spector.engine.similarity", "EUCLIDEAN")
-                .override("spector.engine.persistence-mode", "DISK")
-                .build();
-
-        var engine = SpectorConfigFactory.engineDefaults(props);
-        assertThat(engine.dimensions()).isEqualTo(1024);
-        assertThat(engine.capacity()).isEqualTo(500_000);
-        assertThat(engine.similarity()).isEqualTo("EUCLIDEAN");
-        assertThat(engine.persistenceMode()).isEqualTo("DISK");
-    }
-
-    @Test
-    void hnswDefaults_fromClasspath() {
-        var hnsw = SpectorConfigFactory.hnswDefaults(SpectorProperties.load());
-
-        assertThat(hnsw.m()).isEqualTo(16);
-        assertThat(hnsw.efConstruction()).isEqualTo(200);
-        assertThat(hnsw.efSearch()).isEqualTo(50);
-    }
-
-    @Test
-    void ivfDefaults_fromClasspath() {
-        var ivf = SpectorConfigFactory.ivfDefaults(SpectorProperties.load());
-
-        assertThat(ivf.nlist()).isEqualTo(0);
-        assertThat(ivf.nprobe()).isEqualTo(0);
-        assertThat(ivf.pqSubspaces()).isEqualTo(0);
-    }
-
-    @Test
-    void spectrumDefaults_fromClasspath() {
-        var spectrum = SpectorConfigFactory.spectrumDefaults(SpectorProperties.load());
-
-        assertThat(spectrum.nCentroids()).isEqualTo(256);
-        assertThat(spectrum.nProbe()).isEqualTo(16);
-        assertThat(spectrum.shardThreshold()).isEqualTo(20_000);
-        assertThat(spectrum.oversamplingFactor()).isEqualTo(3);
-        assertThat(spectrum.kmeansIterations()).isEqualTo(25);
-    }
-
-    @Test
-    void embeddingDefaults_fromClasspath() {
-        var embed = SpectorConfigFactory.embeddingDefaults(SpectorProperties.load());
-
-        assertThat(embed.model()).isEqualTo("nomic-embed-text");
-        assertThat(embed.baseUrl()).isEqualTo("http://localhost:11434");
-        assertThat(embed.timeout()).isEqualTo(Duration.ofSeconds(30));
-        assertThat(embed.batchSize()).isEqualTo(32);
-        assertThat(embed.maxRetries()).isEqualTo(3);
-    }
-
-    @Test
-    void chunkingDefaults_fromClasspath() {
-        var chunking = SpectorConfigFactory.chunkingDefaults(SpectorProperties.load());
-
-        assertThat(chunking.maxTokens()).isEqualTo(512);
-        assertThat(chunking.overlapTokens()).isEqualTo(50);
-    }
-
-    @Test
-    void rerankerDefaults_fromClasspath() {
-        var reranker = SpectorConfigFactory.rerankerDefaults(SpectorProperties.load());
-
-        assertThat(reranker.enabled()).isFalse();
-        assertThat(reranker.ollamaUrl()).isEqualTo("http://localhost:11434");
-        assertThat(reranker.model()).isEqualTo("llama3.2");
-        assertThat(reranker.maxCandidates()).isEqualTo(20);
-    }
-
-    @Test
-    void ragDefaults_fromClasspath() {
-        var rag = SpectorConfigFactory.ragDefaults(SpectorProperties.load());
-
-        assertThat(rag.topK()).isEqualTo(5);
-        assertThat(rag.similarityThreshold()).isEqualTo(0.7f);
-        assertThat(rag.tokenLimit()).isEqualTo(4096);
-    }
-
-    @Test
-    void clusterDefaults_fromClasspath() {
-        var cluster = SpectorConfigFactory.clusterDefaults(SpectorProperties.load());
-
-        assertThat(cluster.shardCount()).isEqualTo(1);
-        assertThat(cluster.replicaCount()).isEqualTo(0);
-        assertThat(cluster.shardStrategy()).isEqualTo("HASH");
-    }
-
-    @Test
-    void memoryDefaults_fromClasspath() {
-        var memory = SpectorConfigFactory.memoryDefaults(SpectorProperties.load());
-
-        assertThat(memory.enabled()).isFalse();
-        assertThat(memory.persistenceMode()).isEqualTo("DISK");
-        assertThat(memory.persistencePath()).isEqualTo(Path.of(".spector", "memory"));
-        assertThat(memory.dimensions()).isEqualTo(384);
-        assertThat(memory.capacity()).isEqualTo(100_000);
-        assertThat(memory.decayEnabled()).isTrue();
-        assertThat(memory.consolidationInterval()).isEqualTo(Duration.ofSeconds(60));
-    }
-
-    @Test
-    void ingestionDefaults_fromClasspath() {
-        var ingestion = SpectorConfigFactory.ingestionDefaults(SpectorProperties.load());
-
-        assertThat(ingestion.rootDirectory()).isEqualTo(Path.of("."));
-        assertThat(ingestion.filePattern()).isEqualTo("**/*.md");
-        assertThat(ingestion.skipDirs()).contains(".git");
-        assertThat(ingestion.chunkSize()).isEqualTo(800);
-        assertThat(ingestion.chunkOverlap()).isEqualTo(100);
-    }
-}
diff --git a/spector-config/src/test/java/com/spectrayan/spector/config/SpectorPropertiesTest.java b/spector-config/src/test/java/com/spectrayan/spector/config/SpectorPropertiesTest.java
deleted file mode 100644
index d8e88a5..0000000
--- a/spector-config/src/test/java/com/spectrayan/spector/config/SpectorPropertiesTest.java
+++ /dev/null
@@ -1,273 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.config;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.assertThatThrownBy;
-
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.io.TempDir;
-
-import java.io.IOException;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.time.Duration;
-
-/**
- * Tests for {@link SpectorProperties} hierarchical configuration loading.
- */
-class SpectorPropertiesTest {
-
-    @Test
-    void loadDefaults_returnsClasspathValues() {
-        SpectorProperties props = SpectorProperties.load();
-
-        // Verify values from spector-defaults.yml
-        assertThat(props.getInt("spector.engine.dimensions", -1)).isEqualTo(384);
-        assertThat(props.getInt("spector.engine.capacity", -1)).isEqualTo(100_000);
-        assertThat(props.getString("spector.engine.similarity", "")).isEqualTo("COSINE");
-        assertThat(props.getString("spector.engine.index-type", "")).isEqualTo("HNSW");
-        assertThat(props.getString("spector.engine.quantization", "")).isEqualTo("NONE");
-        assertThat(props.getString("spector.engine.persistence-mode", "")).isEqualTo("IN_MEMORY");
-    }
-
-    @Test
-    void loadDefaults_hnswParams() {
-        SpectorProperties props = SpectorProperties.load();
-
-        assertThat(props.getInt("spector.hnsw.m", -1)).isEqualTo(16);
-        assertThat(props.getInt("spector.hnsw.ef-construction", -1)).isEqualTo(200);
-        assertThat(props.getInt("spector.hnsw.ef-search", -1)).isEqualTo(50);
-    }
-
-    @Test
-    void loadDefaults_embeddingConfig() {
-        SpectorProperties props = SpectorProperties.load();
-
-        assertThat(props.getString("spector.embedding.model")).isEqualTo("nomic-embed-text");
-        assertThat(props.getString("spector.embedding.base-url")).isEqualTo("http://localhost:11434");
-        assertThat(props.getInt("spector.embedding.batch-size", -1)).isEqualTo(32);
-        assertThat(props.getInt("spector.embedding.max-retries", -1)).isEqualTo(3);
-    }
-
-    @Test
-    void loadDefaults_persistenceFiles() {
-        SpectorProperties props = SpectorProperties.load();
-
-        assertThat(props.getString("spector.persistence.files.index")).isEqualTo("index.spct");
-        assertThat(props.getString("spector.persistence.files.vectors")).isEqualTo("vectors.mmap");
-        assertThat(props.getString("spector.persistence.files.documents")).isEqualTo("documents.dat");
-        assertThat(props.getString("spector.persistence.files.id-mappings")).isEqualTo("id-mappings.dat");
-    }
-
-    @Test
-    void loadDefaults_ragConfig() {
-        SpectorProperties props = SpectorProperties.load();
-
-        assertThat(props.getInt("spector.rag.top-k", -1)).isEqualTo(5);
-        assertThat(props.getFloat("spector.rag.similarity-threshold", -1f)).isEqualTo(0.7f);
-        assertThat(props.getInt("spector.rag.token-limit", -1)).isEqualTo(4096);
-    }
-
-    @Test
-    void duration_humanReadable() {
-        SpectorProperties props = SpectorProperties.builder()
-                .override("timeout.seconds", "30s")
-                .override("timeout.millis", "500ms")
-                .override("timeout.minutes", "5m")
-                .override("timeout.hours", "1h")
-                .build();
-
-        assertThat(props.getDuration("timeout.seconds", Duration.ZERO)).isEqualTo(Duration.ofSeconds(30));
-        assertThat(props.getDuration("timeout.millis", Duration.ZERO)).isEqualTo(Duration.ofMillis(500));
-        assertThat(props.getDuration("timeout.minutes", Duration.ZERO)).isEqualTo(Duration.ofMinutes(5));
-        assertThat(props.getDuration("timeout.hours", Duration.ZERO)).isEqualTo(Duration.ofHours(1));
-    }
-
-    @Test
-    void duration_iso8601() {
-        SpectorProperties props = SpectorProperties.builder()
-                .override("timeout", "PT45S")
-                .build();
-
-        assertThat(props.getDuration("timeout", Duration.ZERO)).isEqualTo(Duration.ofSeconds(45));
-    }
-
-    @Test
-    void enum_resolution() {
-        SpectorProperties props = SpectorProperties.builder()
-                .override("mode", "COSINE")
-                .build();
-
-        assertThat(props.getEnum("mode", TestEnum.class, TestEnum.EUCLIDEAN))
-                .isEqualTo(TestEnum.COSINE);
-    }
-
-    @Test
-    void enum_caseInsensitiveWithHyphen() {
-        SpectorProperties props = SpectorProperties.builder()
-                .override("mode", "in-memory")
-                .build();
-
-        assertThat(props.getEnum("mode", TestPersistence.class, TestPersistence.DISK))
-                .isEqualTo(TestPersistence.IN_MEMORY);
-    }
-
-    @Test
-    void enum_invalidFallsBackToDefault() {
-        SpectorProperties props = SpectorProperties.builder()
-                .override("mode", "INVALID")
-                .build();
-
-        assertThat(props.getEnum("mode", TestEnum.class, TestEnum.EUCLIDEAN))
-                .isEqualTo(TestEnum.EUCLIDEAN);
-    }
-
-    @Test
-    void programmaticOverrides_winOverDefaults() {
-        SpectorProperties props = SpectorProperties.builder()
-                .override("spector.engine.dimensions", "768")
-                .build();
-
-        assertThat(props.getInt("spector.engine.dimensions", -1)).isEqualTo(768);
-    }
-
-    @Test
-    void systemProperties_winOverFileConfig() {
-        String key = "spector.test.sysprop.key";
-        System.setProperty(key, "from-system");
-        try {
-            SpectorProperties props = SpectorProperties.builder()
-                    .override(key, "from-override")
-                    .build();
-
-            // System properties win over everything in resolveWithEnv
-            assertThat(props.getString(key)).isEqualTo("from-system");
-        } finally {
-            System.clearProperty(key);
-        }
-    }
-
-    @Test
-    void yamlFileOverride(@TempDir Path tempDir) throws IOException {
-        Path configFile = tempDir.resolve("spector.yml");
-        Files.writeString(configFile, """
-                spector:
-                  engine:
-                    dimensions: 1024
-                    capacity: 500000
-                """);
-
-        SpectorProperties props = SpectorProperties.load(configFile);
-
-        assertThat(props.getInt("spector.engine.dimensions", -1)).isEqualTo(1024);
-        assertThat(props.getInt("spector.engine.capacity", -1)).isEqualTo(500_000);
-        // Other values still come from classpath defaults
-        assertThat(props.getString("spector.engine.similarity", "")).isEqualTo("COSINE");
-    }
-
-    @Test
-    void propertiesFileOverride(@TempDir Path tempDir) throws IOException {
-        Path configFile = tempDir.resolve("custom.properties");
-        Files.writeString(configFile, """
-                spector.engine.dimensions=2048
-                spector.embedding.model=mxbai-embed-large
-                """);
-
-        SpectorProperties props = SpectorProperties.builder()
-                .configFile(configFile)
-                .build();
-
-        assertThat(props.getInt("spector.engine.dimensions", -1)).isEqualTo(2048);
-        assertThat(props.getString("spector.embedding.model")).isEqualTo("mxbai-embed-large");
-    }
-
-    @Test
-    void missingKey_returnsDefault() {
-        SpectorProperties props = SpectorProperties.load();
-
-        assertThat(props.getString("nonexistent.key")).isNull();
-        assertThat(props.getString("nonexistent.key", "fallback")).isEqualTo("fallback");
-        assertThat(props.getInt("nonexistent.key", 42)).isEqualTo(42);
-        assertThat(props.getBoolean("nonexistent.key", true)).isTrue();
-    }
-
-    @Test
-    void containsKey() {
-        SpectorProperties props = SpectorProperties.load();
-
-        assertThat(props.containsKey("spector.engine.dimensions")).isTrue();
-        assertThat(props.containsKey("nonexistent.key")).isFalse();
-    }
-
-    @Test
-    void path_resolution() {
-        SpectorProperties props = SpectorProperties.builder()
-                .override("data.dir", "/tmp/spector")
-                .build();
-
-        assertThat(props.getPath("data.dir", null)).isEqualTo(Path.of("/tmp/spector"));
-        assertThat(props.getPath("missing.key", Path.of("/default"))).isEqualTo(Path.of("/default"));
-    }
-
-    @Test
-    void persistenceFiles_fromProperties() {
-        SpectorProperties props = SpectorProperties.builder()
-                .override("spector.persistence.files.index", "custom-index.bin")
-                .override("spector.persistence.files.vectors", "custom-vectors.bin")
-                .build();
-
-        PersistenceFiles files = PersistenceFiles.from(props);
-
-        assertThat(files.indexFile()).isEqualTo("custom-index.bin");
-        assertThat(files.vectorsFile()).isEqualTo("custom-vectors.bin");
-        // Non-overridden use defaults
-        assertThat(files.documentsFile()).isEqualTo("documents.dat");
-        assertThat(files.idMappingsFile()).isEqualTo("id-mappings.dat");
-    }
-
-    @Test
-    void persistenceFiles_defaultValues() {
-        PersistenceFiles files = PersistenceFiles.DEFAULTS;
-
-        assertThat(files.indexFile()).isEqualTo("index.spct");
-        assertThat(files.vectorsFile()).isEqualTo("vectors.mmap");
-        assertThat(files.documentsFile()).isEqualTo("documents.dat");
-        assertThat(files.idMappingsFile()).isEqualTo("id-mappings.dat");
-    }
-
-    @Test
-    void persistenceFiles_resolvePaths() {
-        Path dataDir = Path.of("/data/spector");
-        PersistenceFiles files = PersistenceFiles.DEFAULTS;
-
-        assertThat(files.resolveIndex(dataDir)).isEqualTo(Path.of("/data/spector/index.spct"));
-        assertThat(files.resolveVectors(dataDir)).isEqualTo(Path.of("/data/spector/vectors.mmap"));
-        assertThat(files.resolveDocuments(dataDir)).isEqualTo(Path.of("/data/spector/documents.dat"));
-        assertThat(files.resolveIdMappings(dataDir)).isEqualTo(Path.of("/data/spector/id-mappings.dat"));
-    }
-
-    @Test
-    void configFile_notFound_throws() {
-        assertThatThrownBy(() -> SpectorProperties.load(Path.of("/nonexistent/config.yml")))
-                .isInstanceOf(com.spectrayan.spector.config.error.SpectorConfigNotFoundException.class)
-                .hasMessageContaining("not found");
-    }
-
-    // Test enums
-    enum TestEnum { COSINE, EUCLIDEAN }
-    enum TestPersistence { IN_MEMORY, DISK }
-}
diff --git a/spector-config/src/test/resources/spector-defaults.yml b/spector-config/src/test/resources/spector-defaults.yml
deleted file mode 100644
index 6cfdad5..0000000
--- a/spector-config/src/test/resources/spector-defaults.yml
+++ /dev/null
@@ -1,99 +0,0 @@
-# ═══════════════════════════════════════════════════════════════════════
-# Spector — Test Defaults
-# ═══════════════════════════════════════════════════════════════════════
-# Minimal test-only defaults matching the values expected by
-# SpectorPropertiesTest. Decoupled from the production defaults file
-# so CI tests are self-contained.
-# ═══════════════════════════════════════════════════════════════════════
-
-spector:
-
-  # ─── Engine ───
-  engine:
-    dimensions: 384
-    capacity: 100000
-    similarity: COSINE
-    index-type: HNSW
-    quantization: NONE
-    persistence-mode: IN_MEMORY
-    data-directory: .spector/index
-    oversampling-factor: 0
-    gpu-enabled: false
-
-  # ─── HNSW ───
-  hnsw:
-    m: 16
-    ef-construction: 200
-    ef-search: 50
-
-  # ─── IVF/PQ ───
-  ivf:
-    nlist: 0
-    nprobe: 0
-    pq-subspaces: 0
-
-  # ─── SPECTRUM ───
-  spectrum:
-    n-centroids: 256
-    n-probe: 16
-    shard-threshold: 20000
-    oversampling-factor: 3
-    kmeans-iterations: 25
-
-  # ─── Embedding ───
-  embedding:
-    model: nomic-embed-text
-    base-url: http://localhost:11434
-    timeout: 30s
-    batch-size: 32
-    max-retries: 3
-
-  # ─── Chunking ───
-  chunking:
-    max-tokens: 512
-    overlap-tokens: 50
-
-  # ─── Reranker ───
-  reranker:
-    enabled: false
-    ollama-url: http://localhost:11434
-    model: llama3.2
-    max-candidates: 20
-
-  # ─── Persistence Files ───
-  persistence:
-    files:
-      index: index.spct
-      vectors: vectors.mmap
-      documents: documents.dat
-      id-mappings: id-mappings.dat
-
-  # ─── RAG ───
-  rag:
-    top-k: 5
-    similarity-threshold: 0.7
-    token-limit: 4096
-
-  # ─── Memory ───
-  memory:
-    enabled: false
-    persistence-mode: DISK
-    persistence-path: .spector/memory
-    dimensions: 384
-    capacity: 100000
-    decay-enabled: true
-    consolidation-interval: 60s
-
-  # ─── Ingestion ───
-  ingestion:
-    root-directory: .
-    file-pattern: "**/*.md"
-    skip-dirs: ".git,.idea,.mvn,target,node_modules,.github"
-    chunk-size: 800
-    chunk-overlap: 100
-
-  # ─── Cluster ───
-  cluster:
-    shard-count: 1
-    replica-count: 0
-    shard-strategy: HASH
diff --git a/spector-core/README.md b/spector-core/README.md
deleted file mode 100644
index e76b5b3..0000000
--- a/spector-core/README.md
+++ /dev/null
@@ -1,47 +0,0 @@
-# spector-core 🌀
-
-> **The high-performance SIMD-accelerated similarity and quantization math core of Spector.**
-
-`spector-core` houses the low-level math kernels, Walsh-Hadamard transforms, and vectorized similarity operators that form the computational engine of the search platform. Written natively for Java 25 utilizing the Panama Vector API (`jdk.incubator.vector`), it compiles hardware-specific SIMD instructions (AVX2, AVX-512, and ARM NEON) on the fly, eliminating native libraries or JNI bindings.
-
----
-
-## 🏗️ Core Architecture & Roles
-
-1. **SIMD Similarity Kernels (`SimilarityKernel`):** Vectorized mathematical calculations for Euclidean ($L2^2$), Cosine, and Dot Product similarity functions. Fully optimized for 256-bit AVX2/AVX-512 lanes.
-2. **Fast Walsh-Hadamard Transform (`Fwht`):** Ultra-fast, in-place $O(D \log D)$ orthogonal rotation butterflies using only addition and subtraction instructions. This spreads dynamic range variance uniformly across all dimensions.
-3. **Asymmetric SIMD Quantization (`SvasqSimdKernel`):** Panama FFM-native distance calculators that evaluate off-heap INT8 codes directly against exact float32 query states, bypassing dequantization overhead.
-
----
-
-## 🚀 Key APIs
-
-### Similarity Kernels
-```java
-float[] a = ...;
-float[] b = ...;
-
-// High-speed SIMD L2 squared distance
-float l2Squared = SimilarityKernel.L2_SQUARED.compute(a, b);
-
-// High-speed SIMD Cosine similarity
-float cosineSim = SimilarityKernel.COSINE.compute(a, b);
-```
-
-### Fast Walsh-Hadamard Transform (FWHT)
-```java
-float[] data = ...; // must be padded to power of 2
-
-// In-place Walsh-Hadamard Butterfly transform
-Fwht.transformInPlace(data);
-```
-
----
-
-## 🛠️ Performance & SIMD Lanes
-
-The module auto-detects hardware architectures and selects optimal vector lanes at runtime:
-
-- **AVX-512 (512-bit):** 16 float lanes per instruction (Intel Xeon, recent AMD).
-- **AVX2 (256-bit):** 8 float lanes per instruction (Most modern x86 desktops/laptops).
-- **NEON (128-bit):** 4 float lanes per instruction (Apple Silicon M1/M2/M3, ARM64).
diff --git a/spector-core/pom.xml b/spector-core/pom.xml
index 2f1c18e..92b53f9 100644
--- a/spector-core/pom.xml
+++ b/spector-core/pom.xml
@@ -6,7 +6,7 @@
 
     <parent>
         <groupId>com.spectrayan</groupId>
-        <artifactId>spector</artifactId>
+        <artifactId>spector-search</artifactId>
         <version>0.1.0-SNAPSHOT</version>
     </parent>
 
@@ -14,11 +14,4 @@
     <name>Spector Core</name>
     <description>SIMD-accelerated math kernels and similarity functions via Java Vector API.</description>
 
-    <dependencies>
-        <dependency>
-            <groupId>com.spectrayan</groupId>
-            <artifactId>spector-commons</artifactId>
-        </dependency>
-    </dependencies>
-
 </project>
diff --git a/spector-core/src/main/java/com/spectrayan/spector/core/similarity/CosineSimilarity.java b/spector-core/src/main/java/com/spectrayan/spector/core/CosineSimilarity.java
similarity index 72%
rename from spector-core/src/main/java/com/spectrayan/spector/core/similarity/CosineSimilarity.java
rename to spector-core/src/main/java/com/spectrayan/spector/core/CosineSimilarity.java
index 6b8105b..9b18c39 100644
--- a/spector-core/src/main/java/com/spectrayan/spector/core/similarity/CosineSimilarity.java
+++ b/spector-core/src/main/java/com/spectrayan/spector/core/CosineSimilarity.java
@@ -1,28 +1,9 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.core.similarity;
-import com.spectrayan.spector.commons.error.SpectorException;
-import com.spectrayan.spector.core.simd.SimdCapability;
+package com.spectrayan.spector.core;
 
 import jdk.incubator.vector.FloatVector;
 import jdk.incubator.vector.VectorMask;
 import jdk.incubator.vector.VectorOperators;
 import jdk.incubator.vector.VectorSpecies;
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-import com.spectrayan.spector.commons.error.ErrorCode;
 
 /**
  * SIMD-accelerated cosine similarity computation.
@@ -52,7 +33,7 @@ private CosineSimilarity() {
      * @param a first vector
      * @param b second vector
      * @return cosine similarity in range [-1, 1], or 0 if degenerate
-     * @throws SpectorValidationException if arrays have different lengths
+     * @throws IllegalArgumentException if arrays have different lengths
      */
     public static float compute(float[] a, float[] b) {
         return compute(a, 0, b, 0, a.length);
@@ -112,13 +93,15 @@ public static float compute(float[] a, int aOffset, float[] b, int bOffset, int
 
     private static void validateInputs(float[] a, int aOffset, float[] b, int bOffset, int length) {
         if (length < 0) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_NEGATIVE, "length", length);
+            throw new IllegalArgumentException("length must be non-negative: " + length);
         }
         if (aOffset < 0 || aOffset + length > a.length) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_INVALID, String.format("a: offset=%d, length=%d, array.length=%d", aOffset, length, a.length));
+            throw new IllegalArgumentException(
+                    String.format("a: offset=%d, length=%d, array.length=%d", aOffset, length, a.length));
         }
         if (bOffset < 0 || bOffset + length > b.length) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_INVALID, String.format("b: offset=%d, length=%d, array.length=%d", bOffset, length, b.length));
+            throw new IllegalArgumentException(
+                    String.format("b: offset=%d, length=%d, array.length=%d", bOffset, length, b.length));
         }
     }
-}
\ No newline at end of file
+}
diff --git a/spector-core/src/main/java/com/spectrayan/spector/core/quantization/CrumbPacker.java b/spector-core/src/main/java/com/spectrayan/spector/core/CrumbPacker.java
similarity index 64%
rename from spector-core/src/main/java/com/spectrayan/spector/core/quantization/CrumbPacker.java
rename to spector-core/src/main/java/com/spectrayan/spector/core/CrumbPacker.java
index baf3353..ab37844 100644
--- a/spector-core/src/main/java/com/spectrayan/spector/core/quantization/CrumbPacker.java
+++ b/spector-core/src/main/java/com/spectrayan/spector/core/CrumbPacker.java
@@ -1,23 +1,4 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.core.quantization;
-import com.spectrayan.spector.commons.error.SpectorException;
-
-import com.spectrayan.spector.commons.error.ErrorCode;
-import com.spectrayan.spector.commons.error.SpectorValidationException;
+package com.spectrayan.spector.core;
 
 /**
  * Packs and unpacks 2-bit (crumb) values into byte arrays for INT2 quantized storage.
@@ -38,11 +19,12 @@ private CrumbPacker() {
      * @param values array of values, each in [0, 3]
      * @param length number of values to pack from the array
      * @return packed byte array
-     * @throws SpectorValidationException if length is negative or exceeds array length
+     * @throws IllegalArgumentException if length is negative or exceeds array length
      */
     public static byte[] pack(int[] values, int length) {
         if (length < 0 || length > values.length) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_OUT_OF_RANGE, "length", 0, 0, length);
+            throw new IllegalArgumentException(
+                    "length must be in [0, values.length], got " + length);
         }
 
         int packedLength = packedSize(length);
@@ -64,11 +46,12 @@ public static byte[] pack(int[] values, int length) {
      * @param packed the packed byte array
      * @param originalLength the number of values that were originally packed
      * @return array of unpacked 2-bit values
-     * @throws SpectorValidationException if originalLength is negative or exceeds capacity
+     * @throws IllegalArgumentException if originalLength is negative or exceeds capacity
      */
     public static int[] unpack(byte[] packed, int originalLength) {
         if (originalLength < 0 || originalLength > packed.length * 4) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_OUT_OF_RANGE, "originalLength", 0, 0, originalLength);
+            throw new IllegalArgumentException(
+                    "originalLength must be in [0, packed.length * 4], got " + originalLength);
         }
 
         int[] values = new int[originalLength];
@@ -93,4 +76,4 @@ public static int[] unpack(byte[] packed, int originalLength) {
     public static int packedSize(int dimensions) {
         return (dimensions + 3) / 4;
     }
-}
\ No newline at end of file
+}
diff --git a/spector-core/src/main/java/com/spectrayan/spector/core/similarity/DotProduct.java b/spector-core/src/main/java/com/spectrayan/spector/core/DotProduct.java
similarity index 66%
rename from spector-core/src/main/java/com/spectrayan/spector/core/similarity/DotProduct.java
rename to spector-core/src/main/java/com/spectrayan/spector/core/DotProduct.java
index d565bd0..665dd97 100644
--- a/spector-core/src/main/java/com/spectrayan/spector/core/similarity/DotProduct.java
+++ b/spector-core/src/main/java/com/spectrayan/spector/core/DotProduct.java
@@ -1,27 +1,8 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.core.similarity;
-import com.spectrayan.spector.commons.error.SpectorException;
-import com.spectrayan.spector.core.simd.SimdCapability;
+package com.spectrayan.spector.core;
 
 import jdk.incubator.vector.FloatVector;
 import jdk.incubator.vector.VectorMask;
 import jdk.incubator.vector.VectorSpecies;
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-import com.spectrayan.spector.commons.error.ErrorCode;
 
 /**
  * SIMD-accelerated dot product computation.
@@ -50,7 +31,7 @@ private DotProduct() {
      * @param a first vector
      * @param b second vector
      * @return dot product value
-     * @throws SpectorValidationException if arrays have different lengths
+     * @throws IllegalArgumentException if arrays have different lengths
      */
     public static float compute(float[] a, float[] b) {
         return compute(a, 0, b, 0, a.length);
@@ -69,7 +50,7 @@ public static float compute(float[] a, float[] b) {
      * @param bOffset offset into {@code b}
      * @param length number of elements to process
      * @return dot product value
-     * @throws SpectorValidationException if length is negative or offsets are out of bounds
+     * @throws IllegalArgumentException if length is negative or offsets are out of bounds
      */
     public static float compute(float[] a, int aOffset, float[] b, int bOffset, int length) {
         validateInputs(a, aOffset, b, bOffset, length);
@@ -99,13 +80,15 @@ public static float compute(float[] a, int aOffset, float[] b, int bOffset, int
 
     private static void validateInputs(float[] a, int aOffset, float[] b, int bOffset, int length) {
         if (length < 0) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_NEGATIVE, "length", length);
+            throw new IllegalArgumentException("length must be non-negative: " + length);
         }
         if (aOffset < 0 || aOffset + length > a.length) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_INVALID, String.format("a: offset=%d, length=%d, array.length=%d", aOffset, length, a.length));
+            throw new IllegalArgumentException(
+                    String.format("a: offset=%d, length=%d, array.length=%d", aOffset, length, a.length));
         }
         if (bOffset < 0 || bOffset + length > b.length) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_INVALID, String.format("b: offset=%d, length=%d, array.length=%d", bOffset, length, b.length));
+            throw new IllegalArgumentException(
+                    String.format("b: offset=%d, length=%d, array.length=%d", bOffset, length, b.length));
         }
     }
-}
\ No newline at end of file
+}
diff --git a/spector-core/src/main/java/com/spectrayan/spector/core/similarity/EuclideanDistance.java b/spector-core/src/main/java/com/spectrayan/spector/core/EuclideanDistance.java
similarity index 75%
rename from spector-core/src/main/java/com/spectrayan/spector/core/similarity/EuclideanDistance.java
rename to spector-core/src/main/java/com/spectrayan/spector/core/EuclideanDistance.java
index 7bddb30..dfa0461 100644
--- a/spector-core/src/main/java/com/spectrayan/spector/core/similarity/EuclideanDistance.java
+++ b/spector-core/src/main/java/com/spectrayan/spector/core/EuclideanDistance.java
@@ -1,28 +1,9 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.core.similarity;
-import com.spectrayan.spector.commons.error.SpectorException;
-import com.spectrayan.spector.core.simd.SimdCapability;
+package com.spectrayan.spector.core;
 
 import jdk.incubator.vector.FloatVector;
 import jdk.incubator.vector.VectorMask;
 import jdk.incubator.vector.VectorOperators;
 import jdk.incubator.vector.VectorSpecies;
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-import com.spectrayan.spector.commons.error.ErrorCode;
 
 /**
  * SIMD-accelerated Euclidean (L2) distance computation.
@@ -124,13 +105,15 @@ public static float computeSquared(float[] a, int aOffset, float[] b, int bOffse
 
     private static void validateInputs(float[] a, int aOffset, float[] b, int bOffset, int length) {
         if (length < 0) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_NEGATIVE, "length", length);
+            throw new IllegalArgumentException("length must be non-negative: " + length);
         }
         if (aOffset < 0 || aOffset + length > a.length) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_INVALID, String.format("a: offset=%d, length=%d, array.length=%d", aOffset, length, a.length));
+            throw new IllegalArgumentException(
+                    String.format("a: offset=%d, length=%d, array.length=%d", aOffset, length, a.length));
         }
         if (bOffset < 0 || bOffset + length > b.length) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_INVALID, String.format("b: offset=%d, length=%d, array.length=%d", bOffset, length, b.length));
+            throw new IllegalArgumentException(
+                    String.format("b: offset=%d, length=%d, array.length=%d", bOffset, length, b.length));
         }
     }
-}
\ No newline at end of file
+}
diff --git a/spector-core/src/main/java/com/spectrayan/spector/core/quantization/NibblePacker.java b/spector-core/src/main/java/com/spectrayan/spector/core/NibblePacker.java
similarity index 64%
rename from spector-core/src/main/java/com/spectrayan/spector/core/quantization/NibblePacker.java
rename to spector-core/src/main/java/com/spectrayan/spector/core/NibblePacker.java
index f1110a3..af6bb78 100644
--- a/spector-core/src/main/java/com/spectrayan/spector/core/quantization/NibblePacker.java
+++ b/spector-core/src/main/java/com/spectrayan/spector/core/NibblePacker.java
@@ -1,23 +1,4 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.core.quantization;
-import com.spectrayan.spector.commons.error.SpectorException;
-
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-import com.spectrayan.spector.commons.error.ErrorCode;
+package com.spectrayan.spector.core;
 
 /**
  * Packs and unpacks 4-bit (nibble) values into byte arrays for INT4 quantized storage.
@@ -38,11 +19,12 @@ private NibblePacker() {
      * @param values array of values, each in [0, 15]
      * @param length number of values to pack from the array
      * @return packed byte array
-     * @throws SpectorValidationException if length is negative or exceeds array length
+     * @throws IllegalArgumentException if length is negative or exceeds array length
      */
     public static byte[] pack(int[] values, int length) {
         if (length < 0 || length > values.length) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_OUT_OF_RANGE, "length", 0, 0, length);
+            throw new IllegalArgumentException(
+                    "length must be in [0, values.length], got " + length);
         }
 
         int packedLength = packedSize(length);
@@ -63,11 +45,12 @@ public static byte[] pack(int[] values, int length) {
      * @param packed the packed byte array
      * @param originalLength the number of values that were originally packed
      * @return array of unpacked 4-bit values
-     * @throws SpectorValidationException if originalLength is negative or exceeds capacity
+     * @throws IllegalArgumentException if originalLength is negative or exceeds capacity
      */
     public static int[] unpack(byte[] packed, int originalLength) {
         if (originalLength < 0 || originalLength > packed.length * 2) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_OUT_OF_RANGE, "originalLength", 0, 0, originalLength);
+            throw new IllegalArgumentException(
+                    "originalLength must be in [0, packed.length * 2], got " + originalLength);
         }
 
         int[] values = new int[originalLength];
@@ -94,4 +77,4 @@ public static int[] unpack(byte[] packed, int originalLength) {
     public static int packedSize(int dimensions) {
         return (dimensions + 1) / 2;
     }
-}
\ No newline at end of file
+}
diff --git a/spector-core/src/main/java/com/spectrayan/spector/core/quantization/NonUniformQuantizer.java b/spector-core/src/main/java/com/spectrayan/spector/core/NonUniformQuantizer.java
similarity index 79%
rename from spector-core/src/main/java/com/spectrayan/spector/core/quantization/NonUniformQuantizer.java
rename to spector-core/src/main/java/com/spectrayan/spector/core/NonUniformQuantizer.java
index 44233c0..6f7f372 100644
--- a/spector-core/src/main/java/com/spectrayan/spector/core/quantization/NonUniformQuantizer.java
+++ b/spector-core/src/main/java/com/spectrayan/spector/core/NonUniformQuantizer.java
@@ -1,24 +1,6 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.core.quantization;
-import com.spectrayan.spector.commons.error.SpectorException;
+package com.spectrayan.spector.core;
 
 import java.util.Arrays;
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-import com.spectrayan.spector.commons.error.ErrorCode;
 
 /**
  * Non-uniform (quantile-based) quantizer for INT4 and INT2 quantization.
@@ -61,23 +43,24 @@ private NonUniformQuantizer(int dimensions, int levels,
      * @param dimensions    vector dimensionality
      * @param levels        number of quantization levels (e.g. 16 for INT4, 4 for INT2)
      * @return a calibrated non-uniform quantizer
-     * @throws SpectorValidationException if sample is empty or null, or dimensions &lt; 1, or levels &lt; 2
+     * @throws IllegalArgumentException if sample is empty or null, or dimensions &lt; 1, or levels &lt; 2
      */
     public static NonUniformQuantizer calibrate(float[][] sampleVectors,
                                                  int dimensions, int levels) {
         if (sampleVectors == null || sampleVectors.length == 0) {
-            throw new SpectorValidationException(ErrorCode.EMPTY_COLLECTION, "sampleVectors");
+            throw new IllegalArgumentException("Sample vectors must not be empty");
         }
         if (dimensions < 1) {
-            throw new SpectorValidationException(ErrorCode.DIMENSIONS_INVALID, 0);
+            throw new IllegalArgumentException("Dimensions must be at least 1");
         }
         if (levels < 2) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_OUT_OF_RANGE, "levels", 2, Integer.MAX_VALUE, 0);
+            throw new IllegalArgumentException("Levels must be at least 2");
         }
 
         for (float[] vector : sampleVectors) {
             if (vector.length != dimensions) {
-                throw new SpectorValidationException(ErrorCode.DIMENSIONS_MISMATCH, dimensions, vector.length);
+                throw new IllegalArgumentException(
+                        "Expected " + dimensions + " dims, got " + vector.length);
             }
         }
 
@@ -145,11 +128,12 @@ public static NonUniformQuantizer calibrate(float[][] sampleVectors,
      *
      * @param vector the input float vector
      * @return array of quantized level indices, each in [0, levels-1]
-     * @throws SpectorValidationException if vector length does not match dimensions
+     * @throws IllegalArgumentException if vector length does not match dimensions
      */
     public int[] encode(float[] vector) {
         if (vector.length != dimensions) {
-            throw new SpectorValidationException(ErrorCode.DIMENSIONS_MISMATCH, dimensions, vector.length);
+            throw new IllegalArgumentException(
+                    "Expected " + dimensions + " dims, got " + vector.length);
         }
 
         int[] result = new int[dimensions];
@@ -166,11 +150,12 @@ public int[] encode(float[] vector) {
      *
      * @param quantized array of level indices
      * @return reconstructed float vector using bucket centroids
-     * @throws SpectorValidationException if quantized length does not match dimensions
+     * @throws IllegalArgumentException if quantized length does not match dimensions
      */
     public float[] decode(int[] quantized) {
         if (quantized.length != dimensions) {
-            throw new SpectorValidationException(ErrorCode.DIMENSIONS_MISMATCH, dimensions, quantized.length);
+            throw new IllegalArgumentException(
+                    "Expected " + dimensions + " dims, got " + quantized.length);
         }
 
         float[] result = new float[dimensions];
@@ -186,12 +171,12 @@ public float[] decode(int[] quantized) {
      *
      * @param dimension the dimension index
      * @return copy of the boundary array for that dimension
-     * @throws SpectorValidationException if dimension is out of range
+     * @throws IndexOutOfBoundsException if dimension is out of range
      */
     public float[] boundaries(int dimension) {
         if (dimension < 0 || dimension >= dimensions) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_OUT_OF_RANGE, 
-                    "dimension", 0, dimensions - 1, dimension);
+            throw new IndexOutOfBoundsException(
+                    "Dimension " + dimension + " out of range [0, " + (dimensions - 1) + "]");
         }
         return Arrays.copyOf(boundaries[dimension], levels);
     }
@@ -201,12 +186,12 @@ public float[] boundaries(int dimension) {
      *
      * @param dimension the dimension index
      * @return copy of the centroid array for that dimension
-     * @throws SpectorValidationException if dimension is out of range
+     * @throws IndexOutOfBoundsException if dimension is out of range
      */
     public float[] centroids(int dimension) {
         if (dimension < 0 || dimension >= dimensions) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_OUT_OF_RANGE, 
-                    "dimension", 0, dimensions - 1, dimension);
+            throw new IndexOutOfBoundsException(
+                    "Dimension " + dimension + " out of range [0, " + (dimensions - 1) + "]");
         }
         return Arrays.copyOf(centroids[dimension], levels);
     }
@@ -264,4 +249,4 @@ private int encodeValue(float value, int dimension) {
 
         return lo;
     }
-}
\ No newline at end of file
+}
diff --git a/spector-core/src/main/java/com/spectrayan/spector/core/PackedDotProduct.java b/spector-core/src/main/java/com/spectrayan/spector/core/PackedDotProduct.java
new file mode 100644
index 0000000..0b6dd20
--- /dev/null
+++ b/spector-core/src/main/java/com/spectrayan/spector/core/PackedDotProduct.java
@@ -0,0 +1,247 @@
+package com.spectrayan.spector.core;
+
+import jdk.incubator.vector.FloatVector;
+import jdk.incubator.vector.VectorSpecies;
+
+/**
+ * SIMD-accelerated dot product computation on nibble-packed (INT4) and crumb-packed (INT2)
+ * quantized vectors.
+ *
+ * <p>Computes {@code sum(query[i] * centroids[level[i]])} for all dimensions, where
+ * {@code level[i]} is extracted from the packed byte array. The centroid lookup converts
+ * quantized level indices back to representative float values for the distance computation.</p>
+ *
+ * <p>Auto-detects Java Vector API availability at class-load time. If the Vector API is
+ * not available, the public {@code computeInt4} and {@code computeInt2} methods fall back
+ * to the scalar implementations transparently.</p>
+ *
+ * <h3>INT4 (Nibble Packing)</h3>
+ * <pre>
+ *   Each byte: [dim_i (bits 7-4)] [dim_i+1 (bits 3-0)]
+ *   Centroids array: 16 entries (one per quantization level)
+ * </pre>
+ *
+ * <h3>INT2 (Crumb Packing)</h3>
+ * <pre>
+ *   Each byte: [dim_i (bits 7-6)] [dim_i+1 (bits 5-4)] [dim_i+2 (bits 3-2)] [dim_i+3 (bits 1-0)]
+ *   Centroids array: 4 entries (one per quantization level)
+ * </pre>
+ */
+public final class PackedDotProduct {
+
+    private static final boolean SIMD_AVAILABLE;
+    private static final VectorSpecies<Float> SPECIES;
+
+    static {
+        boolean available;
+        VectorSpecies<Float> species = null;
+        try {
+            species = SimdCapability.PREFERRED_SPECIES;
+            // Force class initialization to confirm Vector API is usable
+            FloatVector.zero(species);
+            available = true;
+        } catch (Throwable t) {
+            available = false;
+        }
+        SIMD_AVAILABLE = available;
+        SPECIES = species;
+    }
+
+    private PackedDotProduct() {
+        // utility class
+    }
+
+    /**
+     * Computes dot product between a float32 query and a nibble-packed INT4 document vector.
+     *
+     * <p>Automatically selects SIMD or scalar implementation based on runtime capability.</p>
+     *
+     * @param query      the query vector (float32), length must be >= dimensions
+     * @param packedDoc  nibble-packed document vector (2 values per byte)
+     * @param centroids4 centroid values for each of the 16 quantization levels
+     * @param dimensions number of dimensions in the original vector
+     * @return dot product value
+     */
+    public static float computeInt4(float[] query, byte[] packedDoc,
+                                     float[] centroids4, int dimensions) {
+        if (SIMD_AVAILABLE) {
+            return computeInt4Simd(query, packedDoc, centroids4, dimensions);
+        }
+        return computeInt4Scalar(query, packedDoc, centroids4, dimensions);
+    }
+
+    /**
+     * Computes dot product between a float32 query and a crumb-packed INT2 document vector.
+     *
+     * <p>Automatically selects SIMD or scalar implementation based on runtime capability.</p>
+     *
+     * @param query      the query vector (float32), length must be >= dimensions
+     * @param packedDoc  crumb-packed document vector (4 values per byte)
+     * @param centroids2 centroid values for each of the 4 quantization levels
+     * @param dimensions number of dimensions in the original vector
+     * @return dot product value
+     */
+    public static float computeInt2(float[] query, byte[] packedDoc,
+                                     float[] centroids2, int dimensions) {
+        if (SIMD_AVAILABLE) {
+            return computeInt2Simd(query, packedDoc, centroids2, dimensions);
+        }
+        return computeInt2Scalar(query, packedDoc, centroids2, dimensions);
+    }
+
+    /**
+     * Scalar fallback for INT4 dot product. Produces identical results to the SIMD path.
+     *
+     * @param query      the query vector (float32)
+     * @param packedDoc  nibble-packed document vector
+     * @param centroids4 centroid values for 16 levels
+     * @param dimensions number of dimensions
+     * @return dot product value
+     */
+    public static float computeInt4Scalar(float[] query, byte[] packedDoc,
+                                           float[] centroids4, int dimensions) {
+        float sum = 0.0f;
+        for (int i = 0; i < dimensions; i++) {
+            int byteIndex = i / 2;
+            int level;
+            if (i % 2 == 0) {
+                level = (packedDoc[byteIndex] >> 4) & 0x0F;
+            } else {
+                level = packedDoc[byteIndex] & 0x0F;
+            }
+            sum += query[i] * centroids4[level];
+        }
+        return sum;
+    }
+
+    /**
+     * Scalar fallback for INT2 dot product. Produces identical results to the SIMD path.
+     *
+     * @param query      the query vector (float32)
+     * @param packedDoc  crumb-packed document vector
+     * @param centroids2 centroid values for 4 levels
+     * @param dimensions number of dimensions
+     * @return dot product value
+     */
+    public static float computeInt2Scalar(float[] query, byte[] packedDoc,
+                                           float[] centroids2, int dimensions) {
+        float sum = 0.0f;
+        for (int i = 0; i < dimensions; i++) {
+            int byteIndex = i / 4;
+            int positionInByte = i % 4;
+            int shift = 6 - (positionInByte * 2);
+            int level = (packedDoc[byteIndex] >> shift) & 0x03;
+            sum += query[i] * centroids2[level];
+        }
+        return sum;
+    }
+
+    // ── SIMD implementations ──
+
+    private static float computeInt4Simd(float[] query, byte[] packedDoc,
+                                          float[] centroids4, int dimensions) {
+        int laneCount = SPECIES.length();
+
+        // Accumulate products into a temporary array, then sum sequentially
+        // to ensure bitwise-identical results to the scalar fallback.
+        float[] products = new float[dimensions];
+
+        int i = 0;
+        int limit = SPECIES.loopBound(dimensions);
+
+        // Main vectorized loop: compute products in SIMD-width chunks
+        for (; i < limit; i += laneCount) {
+            float[] docValues = new float[laneCount];
+            for (int j = 0; j < laneCount; j++) {
+                int dim = i + j;
+                int byteIndex = dim / 2;
+                int level;
+                if (dim % 2 == 0) {
+                    level = (packedDoc[byteIndex] >> 4) & 0x0F;
+                } else {
+                    level = packedDoc[byteIndex] & 0x0F;
+                }
+                docValues[j] = centroids4[level];
+            }
+
+            FloatVector vQuery = FloatVector.fromArray(SPECIES, query, i);
+            FloatVector vDoc = FloatVector.fromArray(SPECIES, docValues, 0);
+            FloatVector vProduct = vQuery.mul(vDoc);
+            vProduct.intoArray(products, i);
+        }
+
+        // Scalar tail for remaining dimensions
+        for (; i < dimensions; i++) {
+            int byteIndex = i / 2;
+            int level;
+            if (i % 2 == 0) {
+                level = (packedDoc[byteIndex] >> 4) & 0x0F;
+            } else {
+                level = packedDoc[byteIndex] & 0x0F;
+            }
+            products[i] = query[i] * centroids4[level];
+        }
+
+        // Sequential summation — same order as scalar path
+        float sum = 0.0f;
+        for (int k = 0; k < dimensions; k++) {
+            sum += products[k];
+        }
+        return sum;
+    }
+
+    private static float computeInt2Simd(float[] query, byte[] packedDoc,
+                                          float[] centroids2, int dimensions) {
+        int laneCount = SPECIES.length();
+
+        // Accumulate products into a temporary array, then sum sequentially
+        // to ensure bitwise-identical results to the scalar fallback.
+        float[] products = new float[dimensions];
+
+        int i = 0;
+        int limit = SPECIES.loopBound(dimensions);
+
+        // Main vectorized loop: compute products in SIMD-width chunks
+        for (; i < limit; i += laneCount) {
+            float[] docValues = new float[laneCount];
+            for (int j = 0; j < laneCount; j++) {
+                int dim = i + j;
+                int byteIndex = dim / 4;
+                int positionInByte = dim % 4;
+                int shift = 6 - (positionInByte * 2);
+                int level = (packedDoc[byteIndex] >> shift) & 0x03;
+                docValues[j] = centroids2[level];
+            }
+
+            FloatVector vQuery = FloatVector.fromArray(SPECIES, query, i);
+            FloatVector vDoc = FloatVector.fromArray(SPECIES, docValues, 0);
+            FloatVector vProduct = vQuery.mul(vDoc);
+            vProduct.intoArray(products, i);
+        }
+
+        // Scalar tail for remaining dimensions
+        for (; i < dimensions; i++) {
+            int byteIndex = i / 4;
+            int positionInByte = i % 4;
+            int shift = 6 - (positionInByte * 2);
+            int level = (packedDoc[byteIndex] >> shift) & 0x03;
+            products[i] = query[i] * centroids2[level];
+        }
+
+        // Sequential summation — same order as scalar path
+        float sum = 0.0f;
+        for (int k = 0; k < dimensions; k++) {
+            sum += products[k];
+        }
+        return sum;
+    }
+
+    /**
+     * Returns whether SIMD acceleration is available for packed dot product computation.
+     *
+     * @return true if Java Vector API is available and usable
+     */
+    public static boolean isSimdAvailable() {
+        return SIMD_AVAILABLE;
+    }
+}
diff --git a/spector-core/src/main/java/com/spectrayan/spector/core/QuantizationType.java b/spector-core/src/main/java/com/spectrayan/spector/core/QuantizationType.java
new file mode 100644
index 0000000..812e540
--- /dev/null
+++ b/spector-core/src/main/java/com/spectrayan/spector/core/QuantizationType.java
@@ -0,0 +1,89 @@
+package com.spectrayan.spector.core;
+
+/**
+ * Supported vector quantization strategies.
+ *
+ * <p>Quantization compresses float32 vectors into lower-precision formats
+ * to reduce memory usage while preserving search quality.</p>
+ */
+public enum QuantizationType {
+
+    /** No quantization — full float32 precision. */
+    NONE,
+
+    /**
+     * Scalar quantization to int8 (SQ8).
+     *
+     * <p>Each float32 dimension is mapped to a single byte [0, 255] using
+     * per-dimension min/max calibration. Reduces memory by 4× with
+     * ~99%+ recall when combined with asymmetric distance computation.</p>
+     */
+    SCALAR_INT8,
+
+    /**
+     * Scalar quantization to int4 (SQ4).
+     *
+     * <p>Each float32 dimension is mapped to a 4-bit value [0, 15] using
+     * non-uniform (quantile-based) calibration. Two values are packed per byte
+     * (nibble packing), achieving 8× compression vs float32.</p>
+     */
+    SCALAR_INT4,
+
+    /**
+     * Scalar quantization to int2 (SQ2).
+     *
+     * <p>Each float32 dimension is mapped to a 2-bit value [0, 3] using
+     * non-uniform (quantile-based) calibration. Four values are packed per byte
+     * (crumb packing), achieving 16× compression vs float32.</p>
+     */
+    SCALAR_INT2;
+
+    /**
+     * Returns the number of bits used to represent each vector dimension.
+     *
+     * @return bits per dimension for this quantization type
+     */
+    public int bitsPerDimension() {
+        return switch (this) {
+            case NONE -> 32;
+            case SCALAR_INT8 -> 8;
+            case SCALAR_INT4 -> 4;
+            case SCALAR_INT2 -> 2;
+        };
+    }
+
+    /**
+     * Returns the number of discrete quantization levels available.
+     *
+     * <p>This equals 2^bitsPerDimension — for example, INT8 has 256 levels,
+     * INT4 has 16 levels, and INT2 has 4 levels.</p>
+     *
+     * @return number of quantization levels
+     */
+    public int levels() {
+        return 1 << bitsPerDimension();
+    }
+
+    /**
+     * Returns the number of bytes required to store a single quantized vector
+     * of the given dimensionality.
+     *
+     * <ul>
+     *   <li>NONE: dimensions × 4 (full float32)</li>
+     *   <li>SCALAR_INT8: dimensions (one byte per dimension)</li>
+     *   <li>SCALAR_INT4: ceil(dimensions / 2) (nibble packing, 2 values per byte)</li>
+     *   <li>SCALAR_INT2: ceil(dimensions / 4) (crumb packing, 4 values per byte)</li>
+     * </ul>
+     *
+     * @param dimensions the vector dimensionality
+     * @return bytes required per vector
+     */
+    public int bytesPerVector(int dimensions) {
+        return switch (this) {
+            case NONE -> dimensions * 4;
+            case SCALAR_INT8 -> dimensions;
+            case SCALAR_INT4 -> (dimensions + 1) / 2;
+            case SCALAR_INT2 -> (dimensions + 3) / 4;
+        };
+    }
+}
diff --git a/spector-core/src/main/java/com/spectrayan/spector/core/QuantizedCosineSimilarity.java b/spector-core/src/main/java/com/spectrayan/spector/core/QuantizedCosineSimilarity.java
new file mode 100644
index 0000000..9a1d7f1
--- /dev/null
+++ b/spector-core/src/main/java/com/spectrayan/spector/core/QuantizedCosineSimilarity.java
@@ -0,0 +1,81 @@
+package com.spectrayan.spector.core;
+
+import jdk.incubator.vector.FloatVector;
+import jdk.incubator.vector.VectorOperators;
+import jdk.incubator.vector.VectorSpecies;
+
+/**
+ * SIMD-accelerated asymmetric cosine similarity between a float32 query
+ * and a quantized int8 document vector.
+ *
+ * <p>Dequantizes the document on-the-fly and computes cosine similarity
+ * in a single pass: accumulates dot product, query norm², and doc norm²
+ * simultaneously for maximum data locality.</p>
+ *
+ * <h3>Formula</h3>
+ * <pre>
+ *   cosine(query, dequant(doc)) = dot(q, d') / (‖q‖ × ‖d'‖)
+ *   where d'[i] = byte[i] × scale[i] + min[i]
+ * </pre>
+ */
+public final class QuantizedCosineSimilarity {
+
+    private static final VectorSpecies<Float> SPECIES = SimdCapability.PREFERRED_SPECIES;
+
+    private QuantizedCosineSimilarity() {}
+
+    /**
+     * Computes cosine similarity between a float32 query and a quantized int8 vector.
+     *
+     * @param query     the query vector (float32)
+     * @param quantized the quantized document vector (unsigned int8)
+     * @param mins      per-dimension minimum values from calibration
+     * @param scales    per-dimension scale values from calibration
+     * @param length    number of dimensions
+     * @return approximate cosine similarity in [-1, 1]
+     */
+    public static float compute(float[] query, byte[] quantized,
+                                 float[] mins, float[] scales, int length) {
+        int laneCount = SPECIES.length();
+        FloatVector sumDot = FloatVector.zero(SPECIES);
+        FloatVector sumNormQ = FloatVector.zero(SPECIES);
+        FloatVector sumNormD = FloatVector.zero(SPECIES);
+
+        int i = 0;
+        int limit = SPECIES.loopBound(length);
+
+        // ── Main vectorized loop ──
+        for (; i < limit; i += laneCount) {
+            FloatVector vQuery = FloatVector.fromArray(SPECIES, query, i);
+
+            // Dequantize bytes to float
+            float[] dequantized = new float[laneCount];
+            for (int j = 0; j < laneCount; j++) {
+                int unsigned = Byte.toUnsignedInt(quantized[i + j]);
+                dequantized[j] = unsigned * scales[i + j] + mins[i + j];
+            }
+            FloatVector vDoc = FloatVector.fromArray(SPECIES, dequantized, 0);
+
+            sumDot = vQuery.fma(vDoc, sumDot);       // dot += q * d
+            sumNormQ = vQuery.fma(vQuery, sumNormQ); // normQ += q * q
+            sumNormD = vDoc.fma(vDoc, sumNormD);     // normD += d * d
+        }
+
+        // ── Scalar tail ──
+        float tailDot = 0, tailNormQ = 0, tailNormD = 0;
+        for (; i < length; i++) {
+            int unsigned = Byte.toUnsignedInt(quantized[i]);
+            float d = unsigned * scales[i] + mins[i];
+            tailDot += query[i] * d;
+            tailNormQ += query[i] * query[i];
+            tailNormD += d * d;
+        }
+
+        float dot = sumDot.reduceLanes(VectorOperators.ADD) + tailDot;
+        float normQ = sumNormQ.reduceLanes(VectorOperators.ADD) + tailNormQ;
+        float normD = sumNormD.reduceLanes(VectorOperators.ADD) + tailNormD;
+
+        float denom = (float) Math.sqrt((double) normQ * normD);
+        return denom == 0.0f ? 0.0f : dot / denom;
+    }
+}
diff --git a/spector-core/src/main/java/com/spectrayan/spector/core/QuantizedDotProduct.java b/spector-core/src/main/java/com/spectrayan/spector/core/QuantizedDotProduct.java
new file mode 100644
index 0000000..56b2f8a
--- /dev/null
+++ b/spector-core/src/main/java/com/spectrayan/spector/core/QuantizedDotProduct.java
@@ -0,0 +1,96 @@
+package com.spectrayan.spector.core;
+
+import jdk.incubator.vector.ByteVector;
+import jdk.incubator.vector.FloatVector;
+import jdk.incubator.vector.VectorOperators;
+import jdk.incubator.vector.VectorSpecies;
+
+/**
+ * SIMD-accelerated asymmetric dot product between a float32 query and a
+ * quantized int8 document vector.
+ *
+ * <p>The quantized document vector is dequantized on-the-fly during the
+ * SIMD computation: {@code dequantized[i] = byte[i] * scale[i] + min[i]}.
+ * The query vector remains in full float32 precision throughout.</p>
+ *
+ * <h3>Performance</h3>
+ * <p>By operating on byte lanes, this kernel processes 4× more elements
+ * per SIMD register compared to float-only computation. On AVX2 (256-bit),
+ * each iteration handles 8 float lanes with pre-dequantized bytes.</p>
+ *
+ * <h3>Mathematical Equivalence</h3>
+ * <pre>
+ *   dot(query, dequant(doc)) = Σ query[i] × (doc_byte[i] × scale[i] + min[i])
+ *                             = Σ query[i] × doc_byte[i] × scale[i]
+ *                             + Σ query[i] × min[i]
+ * </pre>
+ */
+public final class QuantizedDotProduct {
+
+    private static final VectorSpecies<Float> SPECIES = SimdCapability.PREFERRED_SPECIES;
+
+    private QuantizedDotProduct() {}
+
+    /**
+     * Computes the dot product between a float32 query and a quantized int8 vector.
+     *
+     * @param query     the query vector (float32)
+     * @param quantized the quantized document vector (unsigned int8)
+     * @param mins      per-dimension minimum values from calibration
+     * @param scales    per-dimension scale values from calibration
+     * @param length    number of dimensions
+     * @return approximate dot product
+     */
+    public static float compute(float[] query, byte[] quantized,
+                                 float[] mins, float[] scales, int length) {
+        int laneCount = SPECIES.length();
+        FloatVector sumDot = FloatVector.zero(SPECIES);
+
+        int i = 0;
+        int limit = SPECIES.loopBound(length);
+
+        // ── Main vectorized loop ──
+        for (; i < limit; i += laneCount) {
+            // Load query floats
+            FloatVector vQuery = FloatVector.fromArray(SPECIES, query, i);
+
+            // Load quantized bytes and dequantize to float
+            // Manual widening: byte → unsigned int → float
+            float[] dequantized = new float[laneCount];
+            for (int j = 0; j < laneCount; j++) {
+                int unsigned = Byte.toUnsignedInt(quantized[i + j]);
+                dequantized[j] = unsigned * scales[i + j] + mins[i + j];
+            }
+            FloatVector vDoc = FloatVector.fromArray(SPECIES, dequantized, 0);
+
+            // FMA: sum += query * dequantized_doc
+            sumDot = vQuery.fma(vDoc, sumDot);
+        }
+
+        // ── Scalar tail ──
+        float tail = 0.0f;
+        for (; i < length; i++) {
+            int unsigned = Byte.toUnsignedInt(quantized[i]);
+            float dequantizedVal = unsigned * scales[i] + mins[i];
+            tail += query[i] * dequantizedVal;
+        }
+
+        return sumDot.reduceLanes(VectorOperators.ADD) + tail;
+    }
+
+    /**
+     * Computes the dot product using a pre-built lookup for dequantization.
+     *
+     * <p>When the same quantizer is used for many queries, pre-computing
+     * the dequantized values avoids redundant scale/min multiplications.
+     * Callers should dequantize once and pass the float array.</p>
+     *
+     * @param query        the query vector (float32)
+     * @param dequantized  pre-dequantized document vector (float32)
+     * @param length       number of dimensions
+     * @return dot product
+     */
+    public static float computePreDequantized(float[] query, float[] dequantized, int length) {
+        return DotProduct.compute(query, 0, dequantized, 0, length);
+    }
+}
diff --git a/spector-core/src/main/java/com/spectrayan/spector/core/quantization/ScalarQuantizer.java b/spector-core/src/main/java/com/spectrayan/spector/core/ScalarQuantizer.java
similarity index 84%
rename from spector-core/src/main/java/com/spectrayan/spector/core/quantization/ScalarQuantizer.java
rename to spector-core/src/main/java/com/spectrayan/spector/core/ScalarQuantizer.java
index 952f904..594b5ee 100644
--- a/spector-core/src/main/java/com/spectrayan/spector/core/quantization/ScalarQuantizer.java
+++ b/spector-core/src/main/java/com/spectrayan/spector/core/ScalarQuantizer.java
@@ -1,24 +1,6 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.core.quantization;
-import com.spectrayan.spector.commons.error.SpectorException;
+package com.spectrayan.spector.core;
 
 import java.util.Arrays;
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-import com.spectrayan.spector.commons.error.ErrorCode;
 
 /**
  * Scalar quantizer — maps float32 vectors to int8 (byte) vectors.
@@ -79,11 +61,11 @@ private ScalarQuantizer(int dimensions, float[] mins, float[] maxs) {
      * @param sampleVectors representative vector sample (at least 100 recommended)
      * @param dimensions    vector dimensionality
      * @return a calibrated quantizer
-     * @throws SpectorValidationException if sample is empty or dimensions mismatch
+     * @throws IllegalArgumentException if sample is empty or dimensions mismatch
      */
     public static ScalarQuantizer calibrate(float[][] sampleVectors, int dimensions) {
         if (sampleVectors == null || sampleVectors.length == 0) {
-            throw new SpectorValidationException(ErrorCode.EMPTY_COLLECTION, "sampleVectors");
+            throw new IllegalArgumentException("Sample vectors must not be empty");
         }
 
         float[] mins = new float[dimensions];
@@ -93,7 +75,8 @@ public static ScalarQuantizer calibrate(float[][] sampleVectors, int dimensions)
 
         for (float[] vector : sampleVectors) {
             if (vector.length != dimensions) {
-                throw new SpectorValidationException(ErrorCode.DIMENSIONS_MISMATCH, dimensions, vector.length);
+                throw new IllegalArgumentException(
+                        "Expected " + dimensions + " dims, got " + vector.length);
             }
             for (int d = 0; d < dimensions; d++) {
                 if (vector[d] < mins[d]) mins[d] = vector[d];
@@ -122,7 +105,7 @@ public static ScalarQuantizer calibrate(float[][] sampleVectors, int dimensions)
      */
     public static ScalarQuantizer fromBounds(int dimensions, float[] mins, float[] maxs) {
         if (mins.length != dimensions || maxs.length != dimensions) {
-            throw new SpectorValidationException(ErrorCode.LENGTH_MISMATCH, "mins/maxs", 0, "dimensions", 0);
+            throw new IllegalArgumentException("mins/maxs length must match dimensions");
         }
         return new ScalarQuantizer(dimensions,
                 Arrays.copyOf(mins, dimensions),
@@ -207,4 +190,4 @@ public void decode(byte[] src, int srcOffset, float[] dst, int dstOffset) {
     public float compressionRatio() {
         return 1.0f / 4.0f; // byte / float = 1/4
     }
-}
\ No newline at end of file
+}
diff --git a/spector-core/src/main/java/com/spectrayan/spector/core/simd/SimdCapability.java b/spector-core/src/main/java/com/spectrayan/spector/core/SimdCapability.java
similarity index 69%
rename from spector-core/src/main/java/com/spectrayan/spector/core/simd/SimdCapability.java
rename to spector-core/src/main/java/com/spectrayan/spector/core/SimdCapability.java
index f035515..fd7c39d 100644
--- a/spector-core/src/main/java/com/spectrayan/spector/core/simd/SimdCapability.java
+++ b/spector-core/src/main/java/com/spectrayan/spector/core/SimdCapability.java
@@ -1,19 +1,4 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.core.simd;
+package com.spectrayan.spector.core;
 
 import jdk.incubator.vector.FloatVector;
 import jdk.incubator.vector.VectorSpecies;
diff --git a/spector-core/src/main/java/com/spectrayan/spector/core/SimilarityFunction.java b/spector-core/src/main/java/com/spectrayan/spector/core/SimilarityFunction.java
new file mode 100644
index 0000000..5bd0744
--- /dev/null
+++ b/spector-core/src/main/java/com/spectrayan/spector/core/SimilarityFunction.java
@@ -0,0 +1,146 @@
+package com.spectrayan.spector.core;
+
+/**
+ * Enumerates the supported distance/similarity functions.
+ *
+ * <p>Each variant encapsulates the corresponding SIMD kernel and provides
+ * a uniform {@link #compute(float[], float[])} interface for use by indexes
+ * and query engines.</p>
+ *
+ * <p>Also supports asymmetric quantized computation via
+ * {@link #computeQuantized(float[], byte[], float[], float[], int)} for
+ * float32 query × int8 document distance.</p>
+ */
+public enum SimilarityFunction {
+
+    /**
+     * Cosine similarity — measures the angle between two vectors.
+     * Result range: [-1, 1]. Higher is more similar.
+     */
+    COSINE {
+        @Override
+        public float compute(float[] a, float[] b) {
+            return CosineSimilarity.compute(a, b);
+        }
+
+        @Override
+        public float compute(float[] a, int aOff, float[] b, int bOff, int len) {
+            return CosineSimilarity.compute(a, aOff, b, bOff, len);
+        }
+
+        @Override
+        public float computeQuantized(float[] query, byte[] quantized,
+                                       float[] mins, float[] scales, int length) {
+            return QuantizedCosineSimilarity.compute(query, quantized, mins, scales, length);
+        }
+
+        @Override
+        public boolean higherIsBetter() {
+            return true;
+        }
+    },
+
+    /**
+     * Dot product — measures the projection of one vector onto another.
+     * Unbounded range. Higher is more similar (for normalized vectors).
+     */
+    DOT_PRODUCT {
+        @Override
+        public float compute(float[] a, float[] b) {
+            return DotProduct.compute(a, b);
+        }
+
+        @Override
+        public float compute(float[] a, int aOff, float[] b, int bOff, int len) {
+            return DotProduct.compute(a, aOff, b, bOff, len);
+        }
+
+        @Override
+        public float computeQuantized(float[] query, byte[] quantized,
+                                       float[] mins, float[] scales, int length) {
+            return QuantizedDotProduct.compute(query, quantized, mins, scales, length);
+        }
+
+        @Override
+        public boolean higherIsBetter() {
+            return true;
+        }
+    },
+
+    /**
+     * Euclidean (L2) distance — measures straight-line distance.
+     * Range: [0, ∞). Lower is more similar.
+     */
+    EUCLIDEAN {
+        @Override
+        public float compute(float[] a, float[] b) {
+            return EuclideanDistance.compute(a, b);
+        }
+
+        @Override
+        public float compute(float[] a, int aOff, float[] b, int bOff, int len) {
+            return EuclideanDistance.compute(a, aOff, b, bOff, len);
+        }
+
+        @Override
+        public float computeQuantized(float[] query, byte[] quantized,
+                                       float[] mins, float[] scales, int length) {
+            // Dequantize and compute — no specialized Euclidean quantized kernel yet
+            float sum = 0;
+            for (int i = 0; i < length; i++) {
+                float d = Byte.toUnsignedInt(quantized[i]) * scales[i] + mins[i];
+                float diff = query[i] - d;
+                sum += diff * diff;
+            }
+            return (float) Math.sqrt(sum);
+        }
+
+        @Override
+        public boolean higherIsBetter() {
+            return false;
+        }
+    };
+
+    /**
+     * Computes the similarity/distance between two vectors.
+     *
+     * @param a first vector
+     * @param b second vector
+     * @return the similarity or distance score
+     */
+    public abstract float compute(float[] a, float[] b);
+
+    /**
+     * Computes the similarity/distance between two vector slices.
+     *
+     * @param a    first vector array
+     * @param aOff offset into a
+     * @param b    second vector array
+     * @param bOff offset into b
+     * @param len  number of elements
+     * @return the similarity or distance score
+     */
+    public abstract float compute(float[] a, int aOff, float[] b, int bOff, int len);
+
+    /**
+     * Computes asymmetric similarity/distance between a float32 query
+     * and a quantized int8 document vector.
+     *
+     * @param query     query vector in float32
+     * @param quantized document vector in int8 (unsigned byte)
+     * @param mins      per-dimension minimums from calibration
+     * @param scales    per-dimension scales from calibration
+     * @param length    number of dimensions
+     * @return the similarity or distance score
+     */
+    public abstract float computeQuantized(float[] query, byte[] quantized,
+                                            float[] mins, float[] scales, int length);
+
+    /**
+     * Whether higher scores indicate greater similarity.
+     *
+     * @return true for similarity metrics (cosine, dot), false for distance metrics (euclidean)
+     */
+    public abstract boolean higherIsBetter();
+}
+
diff --git a/spector-core/src/main/java/com/spectrayan/spector/core/similarity/VectorOps.java b/spector-core/src/main/java/com/spectrayan/spector/core/VectorOps.java
similarity index 88%
rename from spector-core/src/main/java/com/spectrayan/spector/core/similarity/VectorOps.java
rename to spector-core/src/main/java/com/spectrayan/spector/core/VectorOps.java
index 28f1776..58605b3 100644
--- a/spector-core/src/main/java/com/spectrayan/spector/core/similarity/VectorOps.java
+++ b/spector-core/src/main/java/com/spectrayan/spector/core/VectorOps.java
@@ -1,28 +1,9 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.core.similarity;
-import com.spectrayan.spector.commons.error.SpectorException;
-import com.spectrayan.spector.core.simd.SimdCapability;
+package com.spectrayan.spector.core;
 
 import jdk.incubator.vector.FloatVector;
 import jdk.incubator.vector.VectorMask;
 import jdk.incubator.vector.VectorOperators;
 import jdk.incubator.vector.VectorSpecies;
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-import com.spectrayan.spector.commons.error.ErrorCode;
 
 /**
  * SIMD-accelerated vector utility operations.
@@ -254,10 +235,11 @@ public static void subtract(float[] a, int aOffset, float[] b, int bOffset,
 
     private static void validateSlice(float[] arr, int offset, int length) {
         if (length < 0) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_NEGATIVE, "length", length);
+            throw new IllegalArgumentException("length must be non-negative: " + length);
         }
         if (offset < 0 || offset + length > arr.length) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_INVALID, String.format("offset=%d, length=%d, array.length=%d", offset, length, arr.length));
+            throw new IllegalArgumentException(
+                    String.format("offset=%d, length=%d, array.length=%d", offset, length, arr.length));
         }
     }
-}
\ No newline at end of file
+}
diff --git a/spector-core/src/main/java/com/spectrayan/spector/core/cluster/KMeans.java b/spector-core/src/main/java/com/spectrayan/spector/core/cluster/KMeans.java
deleted file mode 100644
index 0974319..0000000
--- a/spector-core/src/main/java/com/spectrayan/spector/core/cluster/KMeans.java
+++ /dev/null
@@ -1,233 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.core.cluster;
-
-import com.spectrayan.spector.core.similarity.EuclideanDistance;
-
-import java.util.Arrays;
-import java.util.Random;
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-import com.spectrayan.spector.commons.error.ErrorCode;
-import com.spectrayan.spector.commons.error.SpectorException;
-
-/**
- * K-Means++ clustering utility.
- *
- * <p>Provides a single authoritative implementation of K-Means++ seeding and Lloyd's
- * iterations used across all index types in the Spector engine
- * ({@code IvfFlatIndex}, {@code IvfPqIndex}, {@code QuantizedIvfPqIndex},
- * {@code SpectorIndex}). This eliminates the previously duplicated copy of the
- * same algorithm in each class.</p>
- *
- * <h3>Algorithm</h3>
- * <ol>
- *   <li><b>K-Means++ seeding</b> — the first center is chosen uniformly at random;
- *       each subsequent center is chosen with probability proportional to the squared
- *       distance from the nearest already-selected center.</li>
- *   <li><b>Lloyd's iterations</b> — alternates between assigning each point to its
- *       nearest center and recomputing each center as the mean of its assigned points.
- *       Stops early if no assignment changes (convergence).</li>
- * </ol>
- *
- * <h3>Empty Clusters</h3>
- * <p>If a cluster loses all its members during an iteration, its centroid is kept
- * unchanged (no collapse to NaN). This is the conventional safe fallback.</p>
- *
- * <h3>Allocation Budget</h3>
- * <p>{@code train()} allocates {@code newCenters} and {@code counts} once before
- * the Lloyd's loop — both are reused across all iterations to avoid per-iteration
- * GC pressure. {@code nearestCentroids()} uses a box-free partial selection sort
- * (no {@code Integer[]}), allocating only a {@code float[nc]} distance array and
- * a {@code boolean[nc]} used-flag array — both of negligible size.</p>
- */
-public final class KMeans {
-
-    private KMeans() {}
-
-    /**
-     * Runs K-Means++ on {@code samples} to produce {@code k} centroids.
-     *
-     * @param samples       training vectors; must contain at least {@code k} entries
-     * @param k             number of clusters (centroids to produce)
-     * @param maxIterations maximum Lloyd's iterations (training stops early on convergence)
-     * @param seed          random seed for reproducible K-Means++ initialization
-     * @return {@code float[k][dimensions]} centroid array
-     * @throws SpectorValidationException if {@code samples.length < k}
-     */
-    public static float[][] train(float[][] samples, int k, int maxIterations, long seed) {
-        int n = samples.length;
-        if (n < k) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_OUT_OF_RANGE, "samples", k, Integer.MAX_VALUE, n);
-        }
-        int dimensions = samples[0].length;
-        float[][] centers = new float[k][dimensions];
-        Random rng = new Random(seed);
-
-        // ── K-Means++ seeding ──
-        System.arraycopy(samples[rng.nextInt(n)], 0, centers[0], 0, dimensions);
-        float[] minDists = new float[n];
-        Arrays.fill(minDists, Float.MAX_VALUE);
-
-        for (int c = 1; c < k; c++) {
-            double totalDist = 0;
-            for (int i = 0; i < n; i++) {
-                float d = squaredL2(samples[i], centers[c - 1]);
-                if (d < minDists[i]) minDists[i] = d;
-                totalDist += minDists[i];
-            }
-            double target = rng.nextDouble() * totalDist;
-            double cumulative = 0;
-            int selected = 0;
-            for (int i = 0; i < n; i++) {
-                cumulative += minDists[i];
-                if (cumulative >= target) { selected = i; break; }
-            }
-            System.arraycopy(samples[selected], 0, centers[c], 0, dimensions);
-        }
-
-        // ── Lloyd's iterations ──
-        // newCenters and counts are allocated once outside the loop and reset each iteration
-        // to avoid k × dimensions float allocations per iteration.
-        int[]     assignments = new int[n];
-        float[][] newCenters  = new float[k][dimensions];
-        int[]     counts      = new int[k];
-
-        for (int iter = 0; iter < maxIterations; iter++) {
-            // Assignment step
-            boolean changed = false;
-            for (int i = 0; i < n; i++) {
-                int nearest = nearestCentroid(samples[i], centers);
-                if (nearest != assignments[i]) {
-                    assignments[i] = nearest;
-                    changed = true;
-                }
-            }
-            if (!changed) break; // Converged
-
-            // Reset accumulators in-place — zero allocation
-            for (int c = 0; c < k; c++) {
-                Arrays.fill(newCenters[c], 0f);
-                counts[c] = 0;
-            }
-
-            // Accumulate sums per cluster
-            for (int i = 0; i < n; i++) {
-                int c      = assignments[i];
-                float[] nc = newCenters[c];
-                float[] s  = samples[i];
-                counts[c]++;
-                for (int d = 0; d < dimensions; d++) {
-                    nc[d] += s[d];
-                }
-            }
-
-            // Compute means with multiply-by-inverse (avoids repeated division)
-            for (int c = 0; c < k; c++) {
-                if (counts[c] > 0) {
-                    float inv  = 1f / counts[c];
-                    float[] nc = newCenters[c];
-                    float[] cc = centers[c];
-                    for (int d = 0; d < dimensions; d++) {
-                        cc[d] = nc[d] * inv;
-                    }
-                }
-                // Empty cluster: keep previous centroid (safe fallback, avoids NaN)
-            }
-        }
-
-        return centers;
-    }
-
-    /**
-     * Returns the index of the nearest centroid to {@code vector} by squared L2 distance.
-     *
-     * @param vector    the query vector
-     * @param centroids {@code float[k][dimensions]} centroid array
-     * @return index into {@code centroids} of the nearest centroid
-     */
-    public static int nearestCentroid(float[] vector, float[][] centroids) {
-        int best = 0;
-        float bestDist = Float.MAX_VALUE;
-        for (int c = 0; c < centroids.length; c++) {
-            float d = squaredL2(vector, centroids[c]);
-            if (d < bestDist) { bestDist = d; best = c; }
-        }
-        return best;
-    }
-
-    /**
-     * Returns the indices of the {@code count} nearest centroids to {@code query},
-     * sorted closest-first by squared L2 distance.
-     *
-     * <p>Uses a box-free partial selection sort — O(nc × count) with zero boxing
-     * allocations. Correct and efficient when {@code count ≪ nc} (e.g. nProbe=16,
-     * nCentroids=256 → 4096 comparisons). Replaces the previous approach that
-     * box-allocated {@code Integer[nc]} on every call.</p>
-     *
-     * <p>If {@code count >= centroids.length}, all centroids are returned sorted.</p>
-     *
-     * @param query     the query vector
-     * @param centroids {@code float[k][dimensions]} centroid array
-     * @param count     number of nearest centroids to return
-     * @return int array of length {@code min(count, centroids.length)}, closest first
-     */
-    public static int[] nearestCentroids(float[] query, float[][] centroids, int count) {
-        int nc     = centroids.length;
-        int actual = Math.min(count, nc);
-
-        // Compute all distances once — float[nc], stack-friendly
-        float[] dists = new float[nc];
-        for (int c = 0; c < nc; c++) {
-            dists[c] = squaredL2(query, centroids[c]);
-        }
-
-        // Partial selection sort — no boxing, no Comparator, no Integer[]
-        int[]     result = new int[actual];
-        boolean[] used   = new boolean[nc];
-        for (int r = 0; r < actual; r++) {
-            float bestDist = Float.MAX_VALUE;
-            int   bestIdx  = -1;
-            for (int c = 0; c < nc; c++) {
-                if (!used[c] && dists[c] < bestDist) {
-                    bestDist = dists[c];
-                    bestIdx  = c;
-                }
-            }
-            result[r]     = bestIdx;
-            used[bestIdx] = true;
-        }
-        return result;
-    }
-
-    /**
-     * Computes the squared Euclidean (L2) distance between two vectors.
-     *
-     * <p>Returns the squared distance (no {@code sqrt}) for efficiency in comparisons
-     * where the relative order is all that matters.</p>
-     *
-     * <p>Delegates to the SIMD-accelerated {@link EuclideanDistance#computeSquared(float[], float[])}
-     * kernel, which uses the Java Vector API (Project Panama) for hardware-optimized
-     * computation. This is critical because {@code squaredL2} is called on every vector
-     * insertion (centroid routing) and every search (nProbe selection).</p>
-     *
-     * @param a first vector
-     * @param b second vector
-     * @return squared L2 distance: {@code Σ (a[i] − b[i])²}
-     */
-    public static float squaredL2(float[] a, float[] b) {
-        return EuclideanDistance.computeSquared(a, b);
-    }
-}
\ No newline at end of file
diff --git a/spector-core/src/main/java/com/spectrayan/spector/core/package-info.java b/spector-core/src/main/java/com/spectrayan/spector/core/package-info.java
index 6c8f76f..1c61d37 100644
--- a/spector-core/src/main/java/com/spectrayan/spector/core/package-info.java
+++ b/spector-core/src/main/java/com/spectrayan/spector/core/package-info.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 /**
  * Spector Core — SIMD-accelerated math kernels and similarity functions.
  *
diff --git a/spector-core/src/main/java/com/spectrayan/spector/core/quantization/QuantizationType.java b/spector-core/src/main/java/com/spectrayan/spector/core/quantization/QuantizationType.java
deleted file mode 100644
index 7289e5a..0000000
--- a/spector-core/src/main/java/com/spectrayan/spector/core/quantization/QuantizationType.java
+++ /dev/null
@@ -1,185 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.core.quantization;
-import com.spectrayan.spector.commons.error.SpectorException;
-
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-import com.spectrayan.spector.commons.error.ErrorCode;
-
-/**
- * Supported vector quantization strategies.
- *
- * <p>Quantization compresses float32 vectors into lower-precision formats
- * to reduce memory usage while preserving search quality.</p>
- */
-public enum QuantizationType {
-
-    /** No quantization — full float32 precision. */
-    NONE,
-
-    /**
-     * Scalar quantization to int8 (SQ8).
-     *
-     * <p>Each float32 dimension is mapped to a single byte [0, 255] using
-     * per-dimension min/max calibration. Reduces memory by 4× with
-     * ~99%+ recall when combined with asymmetric distance computation.</p>
-     */
-    SCALAR_INT8,
-
-    /**
-     * Scalar quantization to int4 (SQ4).
-     *
-     * <p>Each float32 dimension is mapped to a 4-bit value [0, 15] using
-     * non-uniform (quantile-based) calibration. Two values are packed per byte
-     * (nibble packing), achieving 8× compression vs float32.</p>
-     */
-    SCALAR_INT4,
-
-    /**
-     * Scalar quantization to int2 (SQ2).
-     *
-     * <p>Each float32 dimension is mapped to a 2-bit value [0, 3] using
-     * non-uniform (quantile-based) calibration. Four values are packed per byte
-     * (crumb packing), achieving 16× compression vs float32.</p>
-     */
-    SCALAR_INT2,
-
-    /**
-     * TurboQuant — random rotation + optimal scalar quantization (4-bit).
-     *
-     * <p>Applies a fixed random orthogonal rotation to isotropize the vector
-     * distribution, then quantizes each rotated coordinate with an optimal
-     * scalar quantizer at 4 bits. Achieves 8× compression with ~97%+ recall,
-     * outperforming standard SQ4 due to the rotation making coordinates
-     * near-independent and uniformly distributed.</p>
-     *
-     * <p>Based on TurboQuant (Google Research, 2025).</p>
-     */
-    TURBO_QUANT,
-
-    /**
-     * SVASQ — Vectorized Affine Scalar Quantization with FWHT rotation.
-     *
-     * <p>Combines Fast Walsh-Hadamard Transform (FWHT) rotation with random sign
-     * flips to isotropize the vector distribution, then applies per-dimension
-     * percentile-clipped affine quantization to signed INT8 [-127, 127].</p>
-     *
-     * <h3>Memory Layout (per vector)</h3>
-     * <pre>
-     *   [4 bytes: float32 exact L2 norm²] [paddedDim bytes: signed INT8 codes]
-     * </pre>
-     * where {@code paddedDim} is the next power-of-two ≥ dimensions.
-     *
-     * <h3>Key Properties</h3>
-     * <ul>
-     *   <li>Asymmetric distance computation — query stays in float32, corpus in INT8.</li>
-     *   <li>Exact-norm L2 header eliminates quantization error in L2 ranking.</li>
-     *   <li>FWHT rotation is O(D log D) with zero multiplications (vs O(D²) for dense rotation).</li>
-     *   <li>Panama SIMD kernel: {@code ByteVector.castShape → FMA → reduceLanes} for maximum throughput.</li>
-     *   <li>Zero-padding to power-of-2 guarantees no SIMD tail loop.</li>
-     * </ul>
-     *
-     * <p><strong>Note:</strong> {@link #bytesPerVector(int)} is not supported for SVASQ
-     * because storage size depends on {@code paddedDim = nextPow2(dimensions)}, not
-     * {@code dimensions} alone. Use {@code SvasqParams.bytesPerVector()} or
-     * {@code SvasqEncoder.bytesPerVector()} instead.</p>
-     */
-    SVASQ,
-
-    /**
-     * SVASQ-4 — Vectorized Affine Scalar Quantization at INT4 bit width.
-     *
-     * <p>Same FWHT rotation pipeline as {@link #SVASQ} but quantizes to offset-encoded
-     * INT4 [0, 14] and nibble-packs two values per byte, achieving <b>2× additional
-     * compression</b> over SVASQ-8 (approximately 6–8× vs float32).</p>
-     *
-     * <h3>Memory Layout (per vector)</h3>
-     * <pre>
-     *   [4 bytes: float32 exact L2 norm²] [paddedDim/2 bytes: nibble-packed INT4 codes]
-     * </pre>
-     *
-     * <h3>Key Properties</h3>
-     * <ul>
-     *   <li>Offset encoding: signed [-7, 7] → unsigned [0, 14] for SIMD-friendly nibble ops.</li>
-     *   <li>Tighter clipping (2.5σ vs 3.0σ) to maximize use of 15 quantization levels.</li>
-     *   <li>Deinterleaved query layout enables ILP in the SIMD kernel.</li>
-     *   <li>With 3× oversampling rescore: ~97–99% recall@10.</li>
-     * </ul>
-     *
-     * <p><strong>Note:</strong> {@link #bytesPerVector(int)} is not supported for SVASQ_4.
-     * Use {@code SvasqParams.bytesPerVector()} or {@code Svasq4Encoder.bytesPerVector()} instead.</p>
-     */
-    SVASQ_4;
-
-    /**
-     * Returns the number of bits used to represent each vector dimension.
-     *
-     * @return bits per dimension for this quantization type
-     */
-    public int bitsPerDimension() {
-        return switch (this) {
-            case NONE        -> 32;
-            case SCALAR_INT8 -> 8;
-            case SCALAR_INT4, TURBO_QUANT -> 4;
-            case SCALAR_INT2 -> 2;
-            // SVASQ uses 8 bits per padded dimension; paddedDim ≥ dimensions
-            case SVASQ        -> 8;
-            // SVASQ_4 uses 4 bits per padded dimension, nibble-packed
-            case SVASQ_4      -> 4;
-        };
-    }
-
-    /**
-     * Returns the number of discrete quantization levels available.
-     *
-     * <p>This equals 2^bitsPerDimension — for example, INT8 has 256 levels,
-     * INT4 has 16 levels, and INT2 has 4 levels.</p>
-     *
-     * @return number of quantization levels
-     */
-    public int levels() {
-        return 1 << bitsPerDimension();
-    }
-
-    /**
-     * Returns the number of bytes required to store a single quantized vector
-     * of the given dimensionality.
-     *
-     * <ul>
-     *   <li>NONE: dimensions × 4 (full float32)</li>
-     *   <li>SCALAR_INT8: dimensions (one byte per dimension)</li>
-     *   <li>SCALAR_INT4: ceil(dimensions / 2) (nibble packing, 2 values per byte)</li>
-     *   <li>SCALAR_INT2: ceil(dimensions / 4) (crumb packing, 4 values per byte)</li>
-     * </ul>
-     *
-     * @param dimensions the vector dimensionality
-     * @return bytes required per vector
-     */
-    public int bytesPerVector(int dimensions) {
-        return switch (this) {
-            case NONE        -> dimensions * 4;
-            case SCALAR_INT8 -> dimensions;
-            case SCALAR_INT4, TURBO_QUANT -> (dimensions + 1) / 2;
-            case SCALAR_INT2 -> (dimensions + 3) / 4;
-            // SVASQ storage size = 4 + nextPow2(dimensions), not a simple function of dimensions.
-            // Use SvasqParams.bytesPerVector() or SvasqEncoder.bytesPerVector() instead.
-            case SVASQ -> throw new SpectorValidationException(ErrorCode.ARGUMENT_INVALID,
-                            "bytesPerVector", "SVASQ depends on paddedDim. Use SvasqEncoder.bytesPerVector()");
-            case SVASQ_4 -> throw new SpectorValidationException(ErrorCode.ARGUMENT_INVALID,
-                            "bytesPerVector", "SVASQ_4 depends on paddedDim. Use Svasq4Encoder.bytesPerVector()");
-        };
-    }
-}
\ No newline at end of file
diff --git a/spector-core/src/main/java/com/spectrayan/spector/core/quantization/TurboQuantizer.java b/spector-core/src/main/java/com/spectrayan/spector/core/quantization/TurboQuantizer.java
deleted file mode 100644
index 33c69da..0000000
--- a/spector-core/src/main/java/com/spectrayan/spector/core/quantization/TurboQuantizer.java
+++ /dev/null
@@ -1,452 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.core.quantization;
-import com.spectrayan.spector.commons.error.SpectorException;
-
-import java.util.Arrays;
-
-import com.spectrayan.spector.core.simd.RandomRotation;
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-import com.spectrayan.spector.commons.error.SpectorInternalException;
-import com.spectrayan.spector.commons.error.ErrorCode;
-
-/**
- * TurboQuant quantizer — random rotation + optimal scalar quantization.
- *
- * <p>Implements the core TurboQuant algorithm from Google Research (2025):
- * <ol>
- *   <li><b>Random rotation</b> — Apply a fixed orthogonal transform to isotropize
- *       the vector distribution, making coordinates near-independent.</li>
- *   <li><b>Per-coordinate scalar quantization</b> — After rotation, each coordinate
- *       is quantized with an optimal scalar quantizer at the configured bit width.</li>
- *   <li><b>Norm preservation</b> — Store the original L2 norm separately for
- *       accurate inner-product reconstruction.</li>
- * </ol>
- *
- * <h3>Key Properties</h3>
- * <ul>
- *   <li><b>Data-oblivious rotation</b> — No heavy training (unlike PQ's K-Means)</li>
- *   <li><b>Near-optimal distortion</b> — Matches information-theoretic bounds</li>
- *   <li><b>Configurable bit width</b> — 2, 4, or 8 bits per coordinate</li>
- *   <li><b>SIMD-friendly storage</b> — Uses existing nibble/crumb packing</li>
- *   <li><b>Fast distance computation</b> — Quantized dot product in rotated space</li>
- * </ul>
- *
- * <h3>Compression Rates</h3>
- * <table>
- *   <tr><td>Bits</td><td>Compression vs float32</td><td>Typical Recall@10</td></tr>
- *   <tr><td>4</td><td>8×</td><td>~97%+</td></tr>
- *   <tr><td>8</td><td>4×</td><td>~99.5%+</td></tr>
- *   <tr><td>2</td><td>16×</td><td>~92%+</td></tr>
- * </table>
- *
- * <h3>Usage</h3>
- * <pre>{@code
- *   // Calibrate from sample data
- *   TurboQuantizer tq = TurboQuantizer.calibrate(sampleVectors, 384, 4, 42L);
- *
- *   // Encode
- *   TurboQuantizer.TurboCode code = tq.encode(vector);
- *
- *   // Decode (approximate reconstruction)
- *   float[] reconstructed = tq.decode(code);
- *
- *   // Distance computation in quantized space
- *   float dist = tq.approximateDistance(queryVector, code);
- * }</pre>
- *
- * @see RandomRotation
- */
-public final class TurboQuantizer {
-
-    private final int dimensions;
-    private final int bitsPerDimension;
-    private final RandomRotation rotation;
-    private final float[] mins;       // per-dimension min in rotated space
-    private final float[] maxs;       // per-dimension max in rotated space
-    private final float[] scales;     // (max - min) / (levels - 1)
-    private final float[] invScales;  // (levels - 1) / (max - min)
-    private final int levels;
-
-    private TurboQuantizer(int dimensions, int bitsPerDimension,
-                           RandomRotation rotation,
-                           float[] mins, float[] maxs) {
-        this.dimensions = dimensions;
-        this.bitsPerDimension = bitsPerDimension;
-        this.rotation = rotation;
-        this.mins = mins;
-        this.maxs = maxs;
-        this.levels = 1 << bitsPerDimension;
-        this.scales = new float[dimensions];
-        this.invScales = new float[dimensions];
-
-        for (int d = 0; d < dimensions; d++) {
-            float range = maxs[d] - mins[d];
-            if (range < 1e-10f) {
-                scales[d] = 1.0f;
-                invScales[d] = 0.0f;
-            } else {
-                scales[d] = range / (levels - 1);
-                invScales[d] = (levels - 1) / range;
-            }
-        }
-    }
-
-    /**
-     * Calibrates a TurboQuantizer from sample vectors.
-     *
-     * <p>Steps:
-     * <ol>
-     *   <li>Generate a random orthogonal rotation matrix from the seed</li>
-     *   <li>Rotate all sample vectors</li>
-     *   <li>Compute per-dimension min/max in the rotated space</li>
-     * </ol>
-     *
-     * @param sampleVectors representative sample of vectors
-     * @param dimensions    vector dimensionality
-     * @param bitsPerDim    bits per dimension (2, 4, or 8)
-     * @param seed          random seed for rotation matrix
-     * @return a calibrated TurboQuantizer
-     * @throws SpectorValidationException if parameters are invalid
-     */
-    public static TurboQuantizer calibrate(float[][] sampleVectors, int dimensions,
-                                            int bitsPerDim, long seed) {
-        if (sampleVectors == null || sampleVectors.length == 0) {
-            throw new SpectorValidationException(ErrorCode.EMPTY_COLLECTION, "sampleVectors");
-        }
-        if (dimensions < 1) {
-            throw new SpectorValidationException(ErrorCode.DIMENSIONS_INVALID, 0);
-        }
-        if (bitsPerDim != 2 && bitsPerDim != 4 && bitsPerDim != 8) {
-            throw new SpectorValidationException(ErrorCode.BIT_WIDTH_INVALID, "2, 4, 8", bitsPerDim);
-        }
-
-        // Generate rotation
-        RandomRotation rotation = RandomRotation.generate(dimensions, seed);
-
-        // Compute min/max in rotated space
-        float[] mins = new float[dimensions];
-        float[] maxs = new float[dimensions];
-        Arrays.fill(mins, Float.MAX_VALUE);
-        Arrays.fill(maxs, -Float.MAX_VALUE);
-
-        float[] rotated = new float[dimensions];
-        for (float[] vector : sampleVectors) {
-            if (vector.length != dimensions) {
-                throw new SpectorValidationException(ErrorCode.DIMENSIONS_MISMATCH, dimensions, vector.length);
-            }
-            rotation.rotate(vector, rotated);
-            for (int d = 0; d < dimensions; d++) {
-                if (rotated[d] < mins[d]) mins[d] = rotated[d];
-                if (rotated[d] > maxs[d]) maxs[d] = rotated[d];
-            }
-        }
-
-        // Expand range by 5% to handle distribution shifts
-        for (int d = 0; d < dimensions; d++) {
-            float range = maxs[d] - mins[d];
-            float margin = range * 0.025f;
-            mins[d] -= margin;
-            maxs[d] += margin;
-        }
-
-        return new TurboQuantizer(dimensions, bitsPerDim, rotation, mins, maxs);
-    }
-
-    /**
-     * Creates a TurboQuantizer from pre-computed parameters (for deserialization).
-     *
-     * @param dimensions     vector dimensionality
-     * @param bitsPerDim     bits per dimension
-     * @param rotation       the rotation matrix
-     * @param mins           per-dimension minimums in rotated space
-     * @param maxs           per-dimension maximums in rotated space
-     * @return a TurboQuantizer
-     */
-    public static TurboQuantizer fromParameters(int dimensions, int bitsPerDim,
-                                                 RandomRotation rotation,
-                                                 float[] mins, float[] maxs) {
-        return new TurboQuantizer(dimensions, bitsPerDim, rotation, mins, maxs);
-    }
-
-    // ─────────────── Encoding ───────────────
-
-    /**
-     * Encodes a vector to a TurboQuant code.
-     *
-     * <p>Steps: rotate → scalar quantize → pack + store norm.</p>
-     *
-     * @param vector the input float vector
-     * @return the encoded TurboQuant code
-     */
-    public TurboCode encode(float[] vector) {
-        if (vector.length != dimensions) {
-            throw new SpectorValidationException(ErrorCode.DIMENSIONS_MISMATCH, dimensions, vector.length);
-        }
-
-        // Step 1: Compute and store the L2 norm
-        float norm = l2Norm(vector);
-
-        // Step 2: Rotate
-        float[] rotated = rotation.rotate(vector);
-
-        // Step 3: Scalar quantize in rotated space
-        int[] quantized = new int[dimensions];
-        int maxLevel = levels - 1;
-        for (int d = 0; d < dimensions; d++) {
-            float normalized = (rotated[d] - mins[d]) * invScales[d];
-            quantized[d] = Math.max(0, Math.min(maxLevel, Math.round(normalized)));
-        }
-
-        // Step 4: Pack into bytes
-        byte[] packed = pack(quantized);
-
-        return new TurboCode(packed, norm);
-    }
-
-    /**
-     * Encodes a vector to raw bytes (without norm), for storage in QuantizedVectorStore.
-     * The norm is stored separately or not needed for some distance functions.
-     *
-     * @param vector the input float vector
-     * @return packed quantized bytes
-     */
-    public byte[] encodeToBytes(float[] vector) {
-        float[] rotated = rotation.rotate(vector);
-        int[] quantized = new int[dimensions];
-        int maxLevel = levels - 1;
-        for (int d = 0; d < dimensions; d++) {
-            float normalized = (rotated[d] - mins[d]) * invScales[d];
-            quantized[d] = Math.max(0, Math.min(maxLevel, Math.round(normalized)));
-        }
-        return pack(quantized);
-    }
-
-    // ─────────────── Decoding ───────────────
-
-    /**
-     * Decodes a TurboQuant code back to an approximate float vector.
-     *
-     * <p>Steps: unpack → dequantize → inverse rotate.</p>
-     *
-     * @param code the TurboQuant code
-     * @return reconstructed float vector (approximate)
-     */
-    public float[] decode(TurboCode code) {
-        return decodeFromBytes(code.packed());
-    }
-
-    /**
-     * Decodes packed bytes (without norm) back to approximate float vector.
-     *
-     * @param packed the packed quantized bytes
-     * @return reconstructed float vector
-     */
-    public float[] decodeFromBytes(byte[] packed) {
-        int[] quantized = unpack(packed);
-        float[] rotated = new float[dimensions];
-
-        for (int d = 0; d < dimensions; d++) {
-            rotated[d] = quantized[d] * scales[d] + mins[d];
-        }
-
-        float[] result = new float[dimensions];
-        rotation.inverseRotate(rotated, result);
-        return result;
-    }
-
-    // ─────────────── Distance Computation ───────────────
-
-    /**
-     * Computes approximate squared L2 distance between a query and a coded vector.
-     *
-     * <p>Rotates the query into the quantized space and computes distance there.
-     * Since orthogonal rotation preserves L2 distances, this is equivalent to
-     * computing distance in the original space.</p>
-     *
-     * @param query the query vector (unrotated, original space)
-     * @param code  the TurboQuant code of the database vector
-     * @return approximate squared L2 distance
-     */
-    public float approximateL2Distance(float[] query, TurboCode code) {
-        float[] rotatedQuery = rotation.rotate(query);
-        int[] quantized = unpack(code.packed());
-
-        float dist = 0;
-        for (int d = 0; d < dimensions; d++) {
-            float reconstructed = quantized[d] * scales[d] + mins[d];
-            float diff = rotatedQuery[d] - reconstructed;
-            dist += diff * diff;
-        }
-        return dist;
-    }
-
-    /**
-     * Computes approximate inner product between a query and a coded vector.
-     *
-     * <p>Uses the stored norm and reconstructed direction for accurate IP estimation.
-     * Rotation preserves inner products, so we work in the rotated space.</p>
-     *
-     * @param query the query vector (unrotated)
-     * @param code  the TurboQuant code
-     * @return approximate inner product
-     */
-    public float approximateInnerProduct(float[] query, TurboCode code) {
-        float[] rotatedQuery = rotation.rotate(query);
-        int[] quantized = unpack(code.packed());
-
-        float ip = 0;
-        for (int d = 0; d < dimensions; d++) {
-            float reconstructed = quantized[d] * scales[d] + mins[d];
-            ip += rotatedQuery[d] * reconstructed;
-        }
-        return ip;
-    }
-
-    /**
-     * Computes approximate cosine similarity between a query and a coded vector.
-     *
-     * @param query the query vector (unrotated)
-     * @param code  the TurboQuant code
-     * @return approximate cosine similarity
-     */
-    public float approximateCosineSimilarity(float[] query, TurboCode code) {
-        float queryNorm = l2Norm(query);
-        if (queryNorm < 1e-10f || code.norm() < 1e-10f) return 0f;
-        float ip = approximateInnerProduct(query, code);
-        return ip / (queryNorm * code.norm());
-    }
-
-    // ─────────────── Batch Operations ───────────────
-
-    /**
-     * Precomputes a rotated query for batch distance computation.
-     * Call this once per query, then use it with {@link #distanceFromRotatedQuery}.
-     *
-     * @param query the query vector
-     * @return rotated query vector
-     */
-    public float[] rotateQuery(float[] query) {
-        return rotation.rotate(query);
-    }
-
-    /**
-     * Computes squared L2 distance from a pre-rotated query to packed bytes.
-     * This avoids re-rotating the query for each database vector.
-     *
-     * @param rotatedQuery pre-rotated query (from {@link #rotateQuery})
-     * @param packed       packed quantized bytes of a database vector
-     * @return approximate squared L2 distance
-     */
-    public float distanceFromRotatedQuery(float[] rotatedQuery, byte[] packed) {
-        int[] quantized = unpack(packed);
-        float dist = 0;
-        for (int d = 0; d < dimensions; d++) {
-            float reconstructed = quantized[d] * scales[d] + mins[d];
-            float diff = rotatedQuery[d] - reconstructed;
-            dist += diff * diff;
-        }
-        return dist;
-    }
-
-    // ─────────────── Accessors ───────────────
-
-    /** Returns the dimensionality. */
-    public int dimensions() { return dimensions; }
-
-    /** Returns bits per dimension. */
-    public int bitsPerDimension() { return bitsPerDimension; }
-
-    /** Returns the number of quantization levels per dimension. */
-    public int levels() { return levels; }
-
-    /** Returns the rotation matrix. */
-    public RandomRotation rotation() { return rotation; }
-
-    /** Returns per-dimension mins in rotated space. */
-    public float[] mins() { return Arrays.copyOf(mins, dimensions); }
-
-    /** Returns per-dimension maxs in rotated space. */
-    public float[] maxs() { return Arrays.copyOf(maxs, dimensions); }
-
-    /** Returns the bytes required to store a single quantized vector. */
-    public int bytesPerVector() {
-        return switch (bitsPerDimension) {
-            case 8 -> dimensions;
-            case 4 -> NibblePacker.packedSize(dimensions);
-            case 2 -> CrumbPacker.packedSize(dimensions);
-            default -> throw new SpectorInternalException(ErrorCode.ARGUMENT_INVALID, "bits", bitsPerDimension);
-        };
-    }
-
-    /** Returns the compression ratio vs float32. */
-    public float compressionRatio() {
-        return (float) bytesPerVector() / (dimensions * 4);
-    }
-
-    // ─────────────── Packing / Unpacking ───────────────
-
-    private byte[] pack(int[] quantized) {
-        return switch (bitsPerDimension) {
-            case 8 -> {
-                byte[] result = new byte[dimensions];
-                for (int d = 0; d < dimensions; d++) {
-                    result[d] = (byte) quantized[d];
-                }
-                yield result;
-            }
-            case 4 -> NibblePacker.pack(quantized, dimensions);
-            case 2 -> CrumbPacker.pack(quantized, dimensions);
-            default -> throw new SpectorInternalException(ErrorCode.ARGUMENT_INVALID, "bits", bitsPerDimension);
-        };
-    }
-
-    private int[] unpack(byte[] packed) {
-        return switch (bitsPerDimension) {
-            case 8 -> {
-                int[] result = new int[dimensions];
-                for (int d = 0; d < dimensions; d++) {
-                    result[d] = Byte.toUnsignedInt(packed[d]);
-                }
-                yield result;
-            }
-            case 4 -> NibblePacker.unpack(packed, dimensions);
-            case 2 -> CrumbPacker.unpack(packed, dimensions);
-            default -> throw new SpectorInternalException(ErrorCode.ARGUMENT_INVALID, "bits", bitsPerDimension);
-        };
-    }
-
-    private static float l2Norm(float[] v) {
-        float sum = 0;
-        for (float f : v) sum += f * f;
-        return (float) Math.sqrt(sum);
-    }
-
-    // ─────────────── TurboCode Record ───────────────
-
-    /**
-     * Encoded TurboQuant representation of a vector.
-     *
-     * @param packed the quantized and packed bytes
-     * @param norm   the original L2 norm (for inner product / cosine reconstruction)
-     */
-    public record TurboCode(byte[] packed, float norm) {
-        public TurboCode {
-            if (packed == null) throw new SpectorValidationException(ErrorCode.ARGUMENT_NULL, "packed");
-            if (Float.isNaN(norm)) throw new SpectorValidationException(ErrorCode.ARGUMENT_INVALID, "norm", "NaN");
-        }
-    }
-}
\ No newline at end of file
diff --git a/spector-core/src/main/java/com/spectrayan/spector/core/quantization/strategy/DistanceContext.java b/spector-core/src/main/java/com/spectrayan/spector/core/quantization/strategy/DistanceContext.java
deleted file mode 100644
index c4d1dec..0000000
--- a/spector-core/src/main/java/com/spectrayan/spector/core/quantization/strategy/DistanceContext.java
+++ /dev/null
@@ -1,111 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.core.quantization.strategy;
-
-import com.spectrayan.spector.core.quantization.svasq.Svasq4QueryState;
-import com.spectrayan.spector.core.quantization.svasq.SvasqQueryState;
-
-/**
- * Sealed per-query distance context — carries pre-computed state that is
- * prepared <em>once per search</em> and reused for every candidate comparison.
- *
- * <p>Each {@link QuantizationStrategy} produces one concrete subtype from
- * {@link QuantizationStrategy#prepareQueryContext(float[])}. The subtype is
- * then passed back into {@link QuantizationStrategy#distance} for each
- * candidate node, avoiding redundant computation in the HNSW hot loop.</p>
- *
- * <h3>Sealed hierarchy</h3>
- * <ul>
- *   <li>{@link Int8Context} — query vector + per-dim min/scale for INT8 ADC</li>
- *   <li>{@link PackedContext} — query vector + global centroids for INT4/INT2 packed dot</li>
- *   <li>{@link TurboContext} — pre-rotated query for TurboQuant distance</li>
- *   <li>{@link SvasqCtx} — pre-rotated query state for SVASQ-8 SIMD kernel</li>
- *   <li>{@link Svasq4Ctx} — deinterleaved query state for SVASQ-4 nibble SIMD kernel</li>
- *   <li>{@link ExactContext} — raw float query for exact float32 fallback</li>
- * </ul>
- */
-public sealed interface DistanceContext
-        permits DistanceContext.Int8Context,
-                DistanceContext.PackedContext,
-                DistanceContext.TurboContext,
-                DistanceContext.SvasqCtx,
-                DistanceContext.Svasq4Ctx,
-                DistanceContext.ExactContext {
-
-    /**
-     * Context for INT8 (SQ8) asymmetric distance computation.
-     *
-     * @param query  the raw float query vector
-     * @param mins   per-dimension min values from ScalarQuantizer
-     * @param scales per-dimension scale values from ScalarQuantizer
-     */
-    record Int8Context(float[] query, float[] mins, float[] scales)
-            implements DistanceContext {}
-
-    /**
-     * Context for INT4 / INT2 packed dot product computation.
-     *
-     * @param query           the raw float query vector
-     * @param globalCentroids averaged centroids for PackedDotProduct lookup
-     * @param dimensions      original vector dimensionality
-     */
-    record PackedContext(float[] query, float[] globalCentroids, int dimensions)
-            implements DistanceContext {}
-
-    /**
-     * Context for TurboQuant distance computation.
-     *
-     * <p>Carries the pre-rotated query vector — the rotation step (O(D²)) is performed
-     * once per search and reused for every candidate comparison.</p>
-     *
-     * @param rotatedQuery pre-rotated query in TurboQuant's rotated space
-     */
-    record TurboContext(float[] rotatedQuery)
-            implements DistanceContext {}
-
-    /**
-     * Context for SVASQ SIMD kernel (FWHT-rotated asymmetric distance).
-     *
-     * <p>Contains the pre-rotated, pre-scaled query tilde and the asymmetric
-     * constant for the L2 expansion formula.</p>
-     *
-     * @param state     pre-computed SVASQ query state (qTilde, constL2Q, dotOffset)
-     * @param paddedDim SVASQ padded dimensionality (power-of-two)
-     */
-    record SvasqCtx(SvasqQueryState state, int paddedDim)
-            implements DistanceContext {}
-
-    /**
-     * Context for SVASQ-4 nibble-packed SIMD kernel (FWHT-rotated asymmetric distance, INT4).
-     *
-     * <p>Contains the deinterleaved pre-scaled query arrays (hi/lo) and the
-     * adjusted L2 constant with offset-encoding bias absorbed.</p>
-     *
-     * @param state   pre-computed SVASQ-4 query state (qTildeHi, qTildeLo, constL2Q, dotOffset)
-     * @param halfDim half of paddedDim (number of nibble-packed code bytes)
-     */
-    record Svasq4Ctx(Svasq4QueryState state, int halfDim)
-            implements DistanceContext {}
-
-    /**
-     * Fallback context for exact float32 distance (used before calibration
-     * or when no quantizer is available).
-     *
-     * @param query the raw float query vector
-     */
-    record ExactContext(float[] query)
-            implements DistanceContext {}
-}
diff --git a/spector-core/src/main/java/com/spectrayan/spector/core/quantization/strategy/Int2Strategy.java b/spector-core/src/main/java/com/spectrayan/spector/core/quantization/strategy/Int2Strategy.java
deleted file mode 100644
index 82eaeb1..0000000
--- a/spector-core/src/main/java/com/spectrayan/spector/core/quantization/strategy/Int2Strategy.java
+++ /dev/null
@@ -1,108 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.core.quantization.strategy;
-import com.spectrayan.spector.commons.error.SpectorException;
-
-import com.spectrayan.spector.core.quantization.CrumbPacker;
-import com.spectrayan.spector.core.quantization.NonUniformQuantizer;
-import com.spectrayan.spector.core.similarity.PackedDotProduct;
-import com.spectrayan.spector.core.similarity.SimilarityFunction;
-
-import java.lang.foreign.MemorySegment;
-import java.lang.foreign.ValueLayout;
-import com.spectrayan.spector.commons.error.ErrorCode;
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-
-/**
- * Quantization strategy for 2-bit crumb-packed quantization via {@link NonUniformQuantizer}.
- *
- * <h3>Memory layout per vector</h3>
- * <pre>
- *   [byte × ceil(dimensions/4)]  — four 2-bit levels packed per byte (bits 7-6, 5-4, 3-2, 1-0)
- * </pre>
- *
- * <h3>Zero-Copy Distance</h3>
- * <p>The {@link #distance} method passes the off-heap {@link MemorySegment} and offset
- * directly to {@link PackedDotProduct#computeInt2(float[], MemorySegment, long, float[], int)}.
- * Crumbs are unpacked and centroids looked up inside the SIMD kernel — no intermediate
- * {@code byte[]} copy in the hot path.</p>
- */
-final class Int2Strategy implements QuantizationStrategy {
-
-    private final NonUniformQuantizer quantizer;
-    private final SimilarityFunction similarityFunction;
-    private final float[] globalCentroids;
-    private final int bpv;
-
-    Int2Strategy(NonUniformQuantizer quantizer, SimilarityFunction similarityFunction,
-                 float[] globalCentroids) {
-        this.quantizer = quantizer;
-        this.similarityFunction = similarityFunction;
-        this.globalCentroids = globalCentroids;
-        this.bpv = (quantizer.dimensions() + 3) / 4; // ceil(D/4)
-    }
-
-    @Override
-    public void encode(float[] vector, MemorySegment segment, long offset) {
-        int[] levels = quantizer.encode(vector);
-        byte[] packed = CrumbPacker.pack(levels, quantizer.dimensions());
-        // Write packed bytes into off-heap segment
-        MemorySegment.copy(packed, 0, segment, ValueLayout.JAVA_BYTE, offset, packed.length);
-    }
-
-    @Override
-    public float[] decode(MemorySegment segment, long offset, int dimensions) {
-        // Read crumbs directly from the off-heap segment
-        byte[] packed = new byte[bpv];
-        MemorySegment.copy(segment, ValueLayout.JAVA_BYTE, offset, packed, 0, bpv);
-        int[] levels = CrumbPacker.unpack(packed, dimensions);
-        return quantizer.decode(levels);
-    }
-
-    /**
-     * Computes INT2 asymmetric dot product — <b>zero-copy hot path</b>.
-     *
-     * <p>Passes the off-heap segment and offset directly to
-     * {@link PackedDotProduct#computeInt2(float[], MemorySegment, long, float[], int)}.
-     * No {@code byte[]} is allocated — crumbs are unpacked inside the SIMD kernel
-     * reading directly from off-heap memory.</p>
-     */
-    @Override
-    public float distance(MemorySegment segment, long offset, DistanceContext ctx) {
-        if (!(ctx instanceof DistanceContext.PackedContext pc)) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_INVALID, "context", "expected PackedContext but got " + ctx.getClass().getSimpleName());
-        }
-        // Zero-copy: segment passed directly to the kernel — no byte[] allocation
-        float dot = PackedDotProduct.computeInt2(
-                pc.query(), segment, offset, pc.globalCentroids(), pc.dimensions());
-        return similarityFunction.higherIsBetter() ? dot : -dot;
-    }
-
-    @Override
-    public DistanceContext prepareQueryContext(float[] query) {
-        return new DistanceContext.PackedContext(query, globalCentroids, quantizer.dimensions());
-    }
-
-    @Override
-    public int bytesPerVector() {
-        return bpv;
-    }
-
-    @Override
-    public int compressionFactor(int dimensions) {
-        return 16; // float32 (4 bytes) → INT2 (0.25 bytes)
-    }
-}
\ No newline at end of file
diff --git a/spector-core/src/main/java/com/spectrayan/spector/core/quantization/strategy/Int4Strategy.java b/spector-core/src/main/java/com/spectrayan/spector/core/quantization/strategy/Int4Strategy.java
deleted file mode 100644
index 67baa15..0000000
--- a/spector-core/src/main/java/com/spectrayan/spector/core/quantization/strategy/Int4Strategy.java
+++ /dev/null
@@ -1,108 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.core.quantization.strategy;
-import com.spectrayan.spector.commons.error.SpectorException;
-
-import com.spectrayan.spector.core.quantization.NibblePacker;
-import com.spectrayan.spector.core.quantization.NonUniformQuantizer;
-import com.spectrayan.spector.core.similarity.PackedDotProduct;
-import com.spectrayan.spector.core.similarity.SimilarityFunction;
-
-import java.lang.foreign.MemorySegment;
-import java.lang.foreign.ValueLayout;
-import com.spectrayan.spector.commons.error.ErrorCode;
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-
-/**
- * Quantization strategy for 4-bit nibble-packed quantization via {@link NonUniformQuantizer}.
- *
- * <h3>Memory layout per vector</h3>
- * <pre>
- *   [byte × ceil(dimensions/2)]  — two 4-bit levels packed per byte (high nibble first)
- * </pre>
- *
- * <h3>Zero-Copy Distance</h3>
- * <p>The {@link #distance} method passes the off-heap {@link MemorySegment} and offset
- * directly to {@link PackedDotProduct#computeInt4(float[], MemorySegment, long, float[], int)}.
- * Nibbles are unpacked and centroids looked up inside the SIMD kernel — no intermediate
- * {@code byte[]} copy in the hot path.</p>
- */
-final class Int4Strategy implements QuantizationStrategy {
-
-    private final NonUniformQuantizer quantizer;
-    private final SimilarityFunction similarityFunction;
-    private final float[] globalCentroids;
-    private final int bpv;
-
-    Int4Strategy(NonUniformQuantizer quantizer, SimilarityFunction similarityFunction,
-                 float[] globalCentroids) {
-        this.quantizer = quantizer;
-        this.similarityFunction = similarityFunction;
-        this.globalCentroids = globalCentroids;
-        this.bpv = (quantizer.dimensions() + 1) / 2; // ceil(D/2)
-    }
-
-    @Override
-    public void encode(float[] vector, MemorySegment segment, long offset) {
-        int[] levels = quantizer.encode(vector);
-        byte[] packed = NibblePacker.pack(levels, quantizer.dimensions());
-        // Write packed bytes into off-heap segment
-        MemorySegment.copy(packed, 0, segment, ValueLayout.JAVA_BYTE, offset, packed.length);
-    }
-
-    @Override
-    public float[] decode(MemorySegment segment, long offset, int dimensions) {
-        // Read nibbles directly from the off-heap segment
-        byte[] packed = new byte[bpv];
-        MemorySegment.copy(segment, ValueLayout.JAVA_BYTE, offset, packed, 0, bpv);
-        int[] levels = NibblePacker.unpack(packed, dimensions);
-        return quantizer.decode(levels);
-    }
-
-    /**
-     * Computes INT4 asymmetric dot product — <b>zero-copy hot path</b>.
-     *
-     * <p>Passes the off-heap segment and offset directly to
-     * {@link PackedDotProduct#computeInt4(float[], MemorySegment, long, float[], int)}.
-     * No {@code byte[]} is allocated — nibbles are unpacked inside the SIMD kernel
-     * reading directly from off-heap memory.</p>
-     */
-    @Override
-    public float distance(MemorySegment segment, long offset, DistanceContext ctx) {
-        if (!(ctx instanceof DistanceContext.PackedContext pc)) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_INVALID, "context", "expected PackedContext but got " + ctx.getClass().getSimpleName());
-        }
-        // Zero-copy: segment passed directly to the kernel — no byte[] allocation
-        float dot = PackedDotProduct.computeInt4(
-                pc.query(), segment, offset, pc.globalCentroids(), pc.dimensions());
-        return similarityFunction.higherIsBetter() ? dot : -dot;
-    }
-
-    @Override
-    public DistanceContext prepareQueryContext(float[] query) {
-        return new DistanceContext.PackedContext(query, globalCentroids, quantizer.dimensions());
-    }
-
-    @Override
-    public int bytesPerVector() {
-        return bpv;
-    }
-
-    @Override
-    public int compressionFactor(int dimensions) {
-        return 8; // float32 (4 bytes) → INT4 (0.5 bytes)
-    }
-}
\ No newline at end of file
diff --git a/spector-core/src/main/java/com/spectrayan/spector/core/quantization/strategy/Int8Strategy.java b/spector-core/src/main/java/com/spectrayan/spector/core/quantization/strategy/Int8Strategy.java
deleted file mode 100644
index 40eedc3..0000000
--- a/spector-core/src/main/java/com/spectrayan/spector/core/quantization/strategy/Int8Strategy.java
+++ /dev/null
@@ -1,104 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.core.quantization.strategy;
-import com.spectrayan.spector.commons.error.SpectorException;
-
-import com.spectrayan.spector.core.quantization.ScalarQuantizer;
-import com.spectrayan.spector.core.similarity.SimilarityFunction;
-
-import java.lang.foreign.MemorySegment;
-import java.lang.foreign.ValueLayout;
-import com.spectrayan.spector.commons.error.ErrorCode;
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-
-/**
- * Quantization strategy for INT8 scalar quantization via {@link ScalarQuantizer}.
- *
- * <h3>Memory layout per vector</h3>
- * <pre>
- *   [unsigned byte × dimensions]
- * </pre>
- * One unsigned byte per dimension, linear min/max mapping calibrated by {@link ScalarQuantizer}.
- *
- * <h3>Zero-Copy Distance</h3>
- * <p>The {@link #distance} method passes the off-heap {@link MemorySegment} and offset
- * directly to {@link SimilarityFunction#computeQuantizedFromSegment} — no {@code byte[]}
- * intermediate allocation in the hot path. The encoded bytes are read from off-heap
- * memory inside the SIMD kernel.</p>
- */
-final class Int8Strategy implements QuantizationStrategy {
-
-    private final ScalarQuantizer quantizer;
-    private final SimilarityFunction similarityFunction;
-    private final int bpv; // bytes per vector = dimensions
-
-    Int8Strategy(ScalarQuantizer quantizer, SimilarityFunction similarityFunction) {
-        this.quantizer = quantizer;
-        this.similarityFunction = similarityFunction;
-        this.bpv = quantizer.dimensions();
-    }
-
-    @Override
-    public void encode(float[] vector, MemorySegment segment, long offset) {
-        byte[] encoded = quantizer.encode(vector);
-        MemorySegment.copy(encoded, 0, segment, ValueLayout.JAVA_BYTE, offset, encoded.length);
-    }
-
-    @Override
-    public float[] decode(MemorySegment segment, long offset, int dimensions) {
-        // Read directly from segment — reconstruct float via dequantization
-        float[] mins   = quantizer.mins();
-        float[] scales = quantizer.scales();
-        float[] result = new float[dimensions];
-        for (int i = 0; i < dimensions; i++) {
-            int unsigned = segment.get(ValueLayout.JAVA_BYTE, offset + i) & 0xFF;
-            result[i] = unsigned * scales[i] + mins[i];
-        }
-        return result;
-    }
-
-    /**
-     * Computes INT8 asymmetric distance — <b>zero-copy hot path</b>.
-     *
-     * <p>Passes the off-heap segment and offset directly to
-     * {@link SimilarityFunction#computeQuantizedFromSegment}. The bytes are read
-     * inside the SIMD kernel without any intermediate {@code byte[]} allocation.</p>
-     */
-    @Override
-    public float distance(MemorySegment segment, long offset, DistanceContext ctx) {
-        if (!(ctx instanceof DistanceContext.Int8Context ic)) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_INVALID, "context", "expected Int8Context but got " + ctx.getClass().getSimpleName());
-        }
-        // Zero-copy: segment is passed directly to the kernel — no byte[] allocation
-        return similarityFunction.computeQuantizedFromSegment(
-                ic.query(), segment, offset, ic.mins(), ic.scales(), bpv);
-    }
-
-    @Override
-    public DistanceContext prepareQueryContext(float[] query) {
-        return new DistanceContext.Int8Context(query, quantizer.mins(), quantizer.scales());
-    }
-
-    @Override
-    public int bytesPerVector() {
-        return bpv;
-    }
-
-    @Override
-    public int compressionFactor(int dimensions) {
-        return 4; // float32 (4 bytes) → INT8 (1 byte)
-    }
-}
\ No newline at end of file
diff --git a/spector-core/src/main/java/com/spectrayan/spector/core/quantization/strategy/QuantizationStrategy.java b/spector-core/src/main/java/com/spectrayan/spector/core/quantization/strategy/QuantizationStrategy.java
deleted file mode 100644
index a546d83..0000000
--- a/spector-core/src/main/java/com/spectrayan/spector/core/quantization/strategy/QuantizationStrategy.java
+++ /dev/null
@@ -1,125 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.core.quantization.strategy;
-
-import java.lang.foreign.MemorySegment;
-
-import com.spectrayan.spector.commons.error.SpectorException;
-
-/**
- * Strategy interface for vector quantization operations.
- *
- * <p>This is the core SPI (Service Provider Interface) of the Strategy + Abstract Factory
- * design pattern refactor. Each implementation encapsulates a complete quantization
- * scheme: encoding, decoding, and asymmetric distance computation.</p>
- *
- * <h3>Design</h3>
- * <ul>
- *   <li><b>Open/Closed:</b> Adding a new quantization type (INT16, FP8, BFloat16) requires
- *       only a new implementation of this interface. {@code QuantizedVectorStore} and
- *       {@code QuantizedHnswIndex} never need to change.</li>
- *   <li><b>Asymmetric Distance:</b> {@link #prepareQueryContext(float[])} is called
- *       <em>once per search</em>. The returned {@link DistanceContext} is passed into
- *       {@link #distance} for every candidate, amortizing per-query computation
- *       (e.g., FWHT rotation, scale pre-multiplication) across all comparisons.</li>
- *   <li><b>Off-heap:</b> {@link #encode} and {@link #distance} operate directly on
- *       {@link MemorySegment}, enabling zero-copy hot paths without GC pressure.</li>
- * </ul>
- *
- * <h3>Implementations</h3>
- * <ul>
- *   <li>{@link Int8Strategy} — linear INT8 quantization via {@code ScalarQuantizer}</li>
- *   <li>{@link Int4Strategy} — nibble-packed INT4 via {@code NonUniformQuantizer}</li>
- *   <li>{@link Int2Strategy} — crumb-packed INT2 via {@code NonUniformQuantizer}</li>
- *   <li>{@link TurboQuantStrategy} — turbo quantization via {@code TurboQuantizer}</li>
- *   <li>{@link SvasqStrategy} — FWHT-rotated INT8 with Panama SIMD kernel</li>
- * </ul>
- *
- * <h3>Thread Safety</h3>
- * <p>All implementations are immutable after construction and safe for concurrent
- * {@link #encode} and {@link #distance} calls. {@link #prepareQueryContext} returns
- * a new per-call object; callers are responsible for thread-local usage.</p>
- */
-public interface QuantizationStrategy {
-
-    /**
-     * Encodes a float32 vector and writes the result directly into an off-heap segment.
-     *
-     * <p>The segment must have at least {@code offset + bytesPerVector()} bytes available
-     * starting at {@code offset}.</p>
-     *
-     * @param vector  float32 input vector (length must equal the strategy's dimension)
-     * @param segment off-heap target memory segment
-     * @param offset  byte offset within the segment for this vector
-     */
-    void encode(float[] vector, MemorySegment segment, long offset);
-
-    /**
-     * Decodes an approximation of the original float32 vector from an off-heap segment.
-     *
-     * @param segment    off-heap segment containing the encoded vector
-     * @param offset     byte offset of the encoded vector
-     * @param dimensions original vector dimensionality
-     * @return approximate float32 reconstruction
-     */
-    float[] decode(MemorySegment segment, long offset, int dimensions);
-
-    /**
-     * Computes the approximate distance between a stored (quantized) vector and
-     * a pre-prepared query context.
-     *
-     * <p>{@code ctx} must be the result of {@link #prepareQueryContext(float[])}
-     * called with the same query for this search traversal.</p>
-     *
-     * @param segment  off-heap segment containing the encoded candidate vector
-     * @param offset   byte offset of the candidate vector within the segment
-     * @param ctx      pre-computed query context from {@link #prepareQueryContext}
-     * @return approximate distance (interpretation depends on similarity function)
-     */
-    float distance(MemorySegment segment, long offset, DistanceContext ctx);
-
-    /**
-     * Prepares a per-query distance context to be reused for all candidates in a
-     * single search traversal.
-     *
-     * <p>This is the "prepare-once, evaluate-N-times" step. For SVASQ, this performs
-     * the O(D log D) FWHT rotation and scale pre-multiplication. For INT8, it
-     * captures the query vector reference. For packed strategies, it resolves the
-     * global centroid table.</p>
-     *
-     * <p>The returned context must not be shared across concurrent searches.</p>
-     *
-     * @param query float32 query vector
-     * @return an immutable per-query context for this strategy type
-     */
-    DistanceContext prepareQueryContext(float[] query);
-
-    /**
-     * Returns the number of bytes this strategy uses per stored vector.
-     *
-     * @return bytes per vector
-     */
-    int bytesPerVector();
-
-    /**
-     * Returns the approximate compression factor relative to float32 storage
-     * (for logging). A value of 4 means the strategy uses 4× less memory than float32.
-     *
-     * @param dimensions vector dimensionality
-     * @return compression factor (≥ 1)
-     */
-    int compressionFactor(int dimensions);
-}
diff --git a/spector-core/src/main/java/com/spectrayan/spector/core/quantization/strategy/QuantizationStrategyFactory.java b/spector-core/src/main/java/com/spectrayan/spector/core/quantization/strategy/QuantizationStrategyFactory.java
deleted file mode 100644
index 691330a..0000000
--- a/spector-core/src/main/java/com/spectrayan/spector/core/quantization/strategy/QuantizationStrategyFactory.java
+++ /dev/null
@@ -1,271 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.core.quantization.strategy;
-import com.spectrayan.spector.commons.error.SpectorException;
-
-import com.spectrayan.spector.core.quantization.NonUniformQuantizer;
-import com.spectrayan.spector.core.quantization.QuantizationType;
-import com.spectrayan.spector.core.quantization.ScalarQuantizer;
-import com.spectrayan.spector.core.quantization.TurboQuantizer;
-import com.spectrayan.spector.core.quantization.svasq.Svasq4Encoder;
-import com.spectrayan.spector.core.quantization.svasq.SvasqEncoder;
-import com.spectrayan.spector.core.quantization.svasq.SvasqParams;
-import com.spectrayan.spector.core.similarity.SimilarityFunction;
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-import com.spectrayan.spector.commons.error.ErrorCode;
-
-/**
- * Abstract Factory for creating {@link QuantizationStrategy} instances.
- *
- * <p>Centralizes the "which strategy for which type" decision and validates
- * that required quantizer objects are present. Callers (e.g., {@code QuantizedVectorStore}
- * and {@code QuantizedHnswIndex}) call {@link #create} and hold a single
- * {@link QuantizationStrategy} reference — no more per-type fields or switch chains.</p>
- *
- * <h3>Usage</h3>
- * <pre>{@code
- *   QuantizationStrategy strategy = QuantizationStrategyFactory.create(
- *       QuantizationType.SVASQ,
- *       null, null, null,
- *       svasqEncoder,
- *       similarityFunction
- *   );
- *   strategy.encode(vector, segment, offset);
- *   DistanceContext ctx = strategy.prepareQueryContext(query);
- *   float dist = strategy.distance(segment, offset, ctx);
- * }</pre>
- *
- * <h3>Open/Closed principle</h3>
- * <p>To add a new quantization type: implement {@link QuantizationStrategy},
- * add a case here. {@code QuantizedVectorStore} and {@code QuantizedHnswIndex}
- * do not change.</p>
- */
-public final class QuantizationStrategyFactory {
-
-    private QuantizationStrategyFactory() {}
-
-    /**
-     * Creates a {@link QuantizationStrategy} for the given quantization type,
-     * validating that all required sub-quantizers are present.
-     *
-     * @param type               the quantization type (must not be null or NONE)
-     * @param scalarQuantizer    required for SCALAR_INT8 (may be null for others)
-     * @param nonUniformQuantizer required for SCALAR_INT4 / SCALAR_INT2 (may be null for others)
-     * @param turboQuantizer     required for TURBO_QUANT (may be null for others)
-     * @param svasqEncoder        required for SVASQ (may be null for others)
-     * @param svasq4Encoder       required for SVASQ_4 (may be null for others)
-     * @param similarityFunction the distance metric (must not be null)
-     * @return a fully initialized {@link QuantizationStrategy}
-     * @throws SpectorValidationException if a required sub-quantizer is missing or dimensions mismatch
-     */
-    public static QuantizationStrategy create(
-            QuantizationType type,
-            ScalarQuantizer scalarQuantizer,
-            NonUniformQuantizer nonUniformQuantizer,
-            TurboQuantizer turboQuantizer,
-            SvasqEncoder svasqEncoder,
-            Svasq4Encoder svasq4Encoder,
-            SimilarityFunction similarityFunction) {
-
-        if (type == null) throw new SpectorValidationException(ErrorCode.ARGUMENT_NULL, "QuantizationType");
-        if (similarityFunction == null) throw new SpectorValidationException(ErrorCode.ARGUMENT_NULL, "SimilarityFunction");
-
-        return switch (type) {
-            case SCALAR_INT8 -> {
-                if (scalarQuantizer == null) {
-                    throw new SpectorValidationException(ErrorCode.ARGUMENT_NULL, "ScalarQuantizer for SCALAR_INT8");
-                }
-                yield new Int8Strategy(scalarQuantizer, similarityFunction);
-            }
-            case SCALAR_INT4 -> {
-                if (nonUniformQuantizer == null) {
-                    throw new SpectorValidationException(ErrorCode.ARGUMENT_NULL, "NonUniformQuantizer for SCALAR_INT4");
-                }
-                validateLevels(nonUniformQuantizer, type);
-                yield new Int4Strategy(nonUniformQuantizer, similarityFunction,
-                        computeGlobalCentroids(nonUniformQuantizer));
-            }
-            case SCALAR_INT2 -> {
-                if (nonUniformQuantizer == null) {
-                    throw new SpectorValidationException(ErrorCode.ARGUMENT_NULL, "NonUniformQuantizer for SCALAR_INT2");
-                }
-                validateLevels(nonUniformQuantizer, type);
-                yield new Int2Strategy(nonUniformQuantizer, similarityFunction,
-                        computeGlobalCentroids(nonUniformQuantizer));
-            }
-            case TURBO_QUANT -> {
-                if (turboQuantizer == null) {
-                    throw new SpectorValidationException(ErrorCode.ARGUMENT_NULL, "TurboQuantizer for TURBO_QUANT");
-                }
-                yield new TurboQuantStrategy(turboQuantizer, similarityFunction);
-            }
-            case SVASQ -> {
-                if (svasqEncoder == null) {
-                    throw new SpectorValidationException(ErrorCode.ARGUMENT_NULL, "SvasqEncoder for SVASQ");
-                }
-                yield new SvasqStrategy(svasqEncoder, similarityFunction);
-            }
-            case SVASQ_4 -> {
-                if (svasq4Encoder == null) {
-                    throw new SpectorValidationException(ErrorCode.ARGUMENT_NULL, "Svasq4Encoder for SVASQ_4");
-                }
-                yield new Svasq4Strategy(svasq4Encoder, similarityFunction);
-            }
-            case NONE -> throw new SpectorValidationException(ErrorCode.QUANTIZATION_TYPE_INVALID, "NONE");
-        };
-    }
-
-    /**
-     * Backward-compatible overload without Svasq4Encoder parameter.
-     *
-     * <p>Delegates to the full overload with {@code svasq4Encoder = null}.</p>
-     */
-    public static QuantizationStrategy create(
-            QuantizationType type,
-            ScalarQuantizer scalarQuantizer,
-            NonUniformQuantizer nonUniformQuantizer,
-            TurboQuantizer turboQuantizer,
-            SvasqEncoder svasqEncoder,
-            SimilarityFunction similarityFunction) {
-        return create(type, scalarQuantizer, nonUniformQuantizer, turboQuantizer,
-                svasqEncoder, null, similarityFunction);
-    }
-
-    /**
-     * Creates a {@link QuantizationStrategy} for the given quantization type,
-     * additionally validating that quantizer dimensions match the expected store dimension.
-     *
-     * <p>Use this overload when you want to enforce dimension consistency at the
-     * factory level rather than relying on the strategy to detect mismatches
-     * at encode time.</p>
-     *
-     * @param type               the quantization type
-     * @param dimensions         expected vector dimensionality
-     * @param scalarQuantizer    required for SCALAR_INT8
-     * @param nonUniformQuantizer required for SCALAR_INT4 / SCALAR_INT2
-     * @param turboQuantizer     required for TURBO_QUANT
-     * @param svasqEncoder        required for SVASQ
-     * @param svasq4Encoder       required for SVASQ_4
-     * @param similarityFunction the distance metric
-     * @return a fully initialized {@link QuantizationStrategy}
-     * @throws SpectorValidationException if required quantizer missing or dimension mismatch detected
-     */
-    public static QuantizationStrategy createWithDimCheck(
-            QuantizationType type,
-            int dimensions,
-            ScalarQuantizer scalarQuantizer,
-            NonUniformQuantizer nonUniformQuantizer,
-            TurboQuantizer turboQuantizer,
-            SvasqEncoder svasqEncoder,
-            Svasq4Encoder svasq4Encoder,
-            SimilarityFunction similarityFunction) {
-
-        // Dimension consistency checks (mirrors original QuantizedVectorStore validation)
-        if (type == QuantizationType.SCALAR_INT8 && scalarQuantizer != null
-                && scalarQuantizer.dimensions() != dimensions) {
-            throw new SpectorValidationException(ErrorCode.DIMENSIONS_MISMATCH, scalarQuantizer.dimensions(), dimensions);
-        }
-        if ((type == QuantizationType.SCALAR_INT4 || type == QuantizationType.SCALAR_INT2)
-                && nonUniformQuantizer != null
-                && nonUniformQuantizer.dimensions() != dimensions) {
-            throw new SpectorValidationException(ErrorCode.DIMENSIONS_MISMATCH, nonUniformQuantizer.dimensions(), dimensions);
-        }
-        if (type == QuantizationType.TURBO_QUANT && turboQuantizer != null
-                && turboQuantizer.dimensions() != dimensions) {
-            throw new SpectorValidationException(ErrorCode.DIMENSIONS_MISMATCH, turboQuantizer.dimensions(), dimensions);
-        }
-        if (type == QuantizationType.SVASQ && svasqEncoder != null
-                && svasqEncoder.params().originalDim() != dimensions) {
-            throw new SpectorValidationException(ErrorCode.DIMENSIONS_MISMATCH, svasqEncoder.params().originalDim(), dimensions);
-        }
-        if (type == QuantizationType.SVASQ_4 && svasq4Encoder != null
-                && svasq4Encoder.params().originalDim() != dimensions) {
-            throw new SpectorValidationException(ErrorCode.DIMENSIONS_MISMATCH, svasq4Encoder.params().originalDim(), dimensions);
-        }
-
-        return create(type, scalarQuantizer, nonUniformQuantizer, turboQuantizer,
-                svasqEncoder, svasq4Encoder, similarityFunction);
-    }
-
-    /**
-     * Backward-compatible overload without Svasq4Encoder parameter.
-     */
-    public static QuantizationStrategy createWithDimCheck(
-            QuantizationType type,
-            int dimensions,
-            ScalarQuantizer scalarQuantizer,
-            NonUniformQuantizer nonUniformQuantizer,
-            TurboQuantizer turboQuantizer,
-            SvasqEncoder svasqEncoder,
-            SimilarityFunction similarityFunction) {
-        return createWithDimCheck(type, dimensions, scalarQuantizer, nonUniformQuantizer,
-                turboQuantizer, svasqEncoder, null, similarityFunction);
-    }
-
-    /**
-     * Creates a SVASQ strategy directly from {@link SvasqParams} (convenience overload).
-     *
-     * @param params             calibrated SVASQ parameters
-     * @param similarityFunction distance metric
-     * @return a fully initialized SVASQ {@link QuantizationStrategy}
-     */
-    public static QuantizationStrategy createSvasq(SvasqParams params,
-                                                   SimilarityFunction similarityFunction) {
-        return new SvasqStrategy(params, similarityFunction);
-    }
-
-    /**
-     * Creates a SVASQ-4 strategy directly from {@link SvasqParams} (convenience overload).
-     *
-     * @param params             calibrated SVASQ-4 parameters (bitWidth must be 4)
-     * @param similarityFunction distance metric
-     * @return a fully initialized SVASQ-4 {@link QuantizationStrategy}
-     */
-    public static QuantizationStrategy createSvasq4(SvasqParams params,
-                                                    SimilarityFunction similarityFunction) {
-        return new Svasq4Strategy(params, similarityFunction);
-    }
-
-    // ─────────────── Internals ───────────────
-
-    /**
-     * Computes global centroids for INT4/INT2 packed dot product lookup.
-     *
-     * <p>The global centroids are a single flat array of length {@code levels},
-     * where each entry is the average of that level's per-dimension centroid
-     * across all dimensions. Used by {@link com.spectrayan.spector.core.similarity.PackedDotProduct}.</p>
-     */
-    static float[] computeGlobalCentroids(NonUniformQuantizer nuq) {
-        int levels = nuq.levels();
-        int dims   = nuq.dimensions();
-        float[] global = new float[levels];
-        for (int level = 0; level < levels; level++) {
-            double sum = 0.0;
-            for (int dim = 0; dim < dims; dim++) {
-                sum += nuq.centroids(dim)[level];
-            }
-            global[level] = (float) (sum / dims);
-        }
-        return global;
-    }
-
-    private static void validateLevels(NonUniformQuantizer nuq, QuantizationType type) {
-        int expected = type.levels();
-        if (nuq.levels() != expected) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_INVALID, "levels", type + " requires " + expected + " but got " + nuq.levels());
-        }
-    }
-}
\ No newline at end of file
diff --git a/spector-core/src/main/java/com/spectrayan/spector/core/quantization/strategy/Svasq4Strategy.java b/spector-core/src/main/java/com/spectrayan/spector/core/quantization/strategy/Svasq4Strategy.java
deleted file mode 100644
index f00cff9..0000000
--- a/spector-core/src/main/java/com/spectrayan/spector/core/quantization/strategy/Svasq4Strategy.java
+++ /dev/null
@@ -1,150 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.core.quantization.strategy;
-import com.spectrayan.spector.commons.error.SpectorException;
-
-import com.spectrayan.spector.core.quantization.svasq.Svasq4Encoder;
-import com.spectrayan.spector.core.quantization.svasq.Svasq4QueryPrep;
-import com.spectrayan.spector.core.quantization.svasq.SvasqParams;
-import com.spectrayan.spector.core.similarity.SimilarityFunction;
-
-import java.lang.foreign.MemorySegment;
-import java.lang.foreign.ValueLayout;
-import com.spectrayan.spector.commons.error.ErrorCode;
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-
-/**
- * Quantization strategy for SVASQ-4 (FWHT-rotated asymmetric INT4 quantization).
- *
- * <h3>Memory layout per vector</h3>
- * <pre>
- *   [float32 exactNormSq (4 bytes)] [nibble-packed INT4 × paddedDim/2 bytes]
- * </pre>
- *
- * <h3>Distance computation</h3>
- * <p>{@link #prepareQueryContext} applies FWHT rotation, pre-scaling, deinterleaving,
- * and offset-bias folding <em>once per query</em>. The resulting
- * {@link DistanceContext.Svasq4Ctx} is reused for every candidate via
- * {@link SimilarityFunction#computeSvasq4}, which dispatches to the Panama SIMD kernel
- * ({@link com.spectrayan.spector.core.quantization.svasq.Svasq4SimdKernel}) with zero
- * heap allocations on the hot path.</p>
- *
- * <h3>Thread safety</h3>
- * <p>This class is immutable after construction. The {@link DistanceContext.Svasq4Ctx}
- * returned by {@link #prepareQueryContext} is a per-call value that must not be
- * shared across concurrent searches.</p>
- */
-public final class Svasq4Strategy implements QuantizationStrategy {
-
-    private final Svasq4Encoder encoder;
-    private final Svasq4QueryPrep queryPrep;
-    private final SimilarityFunction similarityFunction;
-    private final int bpv;
-    private final int halfDim;
-
-    /**
-     * Creates a SVASQ-4 strategy from pre-calibrated 4-bit parameters.
-     *
-     * @param params             calibrated SVASQ parameters with bitWidth=4
-     * @param similarityFunction distance metric (EUCLIDEAN → L2, COSINE/DOT → dot)
-     */
-    public Svasq4Strategy(SvasqParams params, SimilarityFunction similarityFunction) {
-        this.encoder = new Svasq4Encoder(params);
-        this.queryPrep = new Svasq4QueryPrep(params);
-        this.similarityFunction = similarityFunction;
-        this.bpv = params.bytesPerVector();
-        this.halfDim = params.paddedDim() / 2;
-    }
-
-    /**
-     * Creates a SVASQ-4 strategy from a pre-built encoder.
-     *
-     * @param encoder            pre-built SVASQ-4 encoder (non-null)
-     * @param similarityFunction distance metric
-     */
-    public Svasq4Strategy(Svasq4Encoder encoder, SimilarityFunction similarityFunction) {
-        this.encoder = encoder;
-        this.queryPrep = new Svasq4QueryPrep(encoder.params());
-        this.similarityFunction = similarityFunction;
-        this.bpv = encoder.bytesPerVector();
-        this.halfDim = encoder.params().paddedDim() / 2;
-    }
-
-    /**
-     * Encodes a float32 vector directly into the off-heap segment.
-     *
-     * <p>Applies FWHT rotation, INT4 quantization, offset encoding, and writes
-     * the 4-byte norm header + nibble-packed codes — zero heap allocation.</p>
-     */
-    @Override
-    public void encode(float[] vector, MemorySegment segment, long offset) {
-        encoder.encode(vector, segment, offset);
-    }
-
-    /**
-     * Decodes an approximation of the original vector from the off-heap segment.
-     *
-     * <p>Reads the nibble-packed codes, reverses offset encoding, and reconstructs via
-     * {@code x̂ᵢ ≈ (uᵢ − 7) × scaleᵢ + μᵢ}.</p>
-     */
-    @Override
-    public float[] decode(MemorySegment segment, long offset, int dimensions) {
-        return encoder.decode(segment, offset, dimensions);
-    }
-
-    /**
-     * Computes SVASQ-4 distance between a stored (quantized) candidate and the
-     * pre-prepared query state.
-     *
-     * <p>Delegates to {@link SimilarityFunction#computeSvasq4} which dispatches to
-     * the Panama SIMD kernel — reading directly from off-heap memory, zero GC pressure.</p>
-     */
-    @Override
-    public float distance(MemorySegment segment, long offset, DistanceContext ctx) {
-        if (!(ctx instanceof DistanceContext.Svasq4Ctx vc)) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_INVALID, "Expected Svasq4Ctx, got: " + ctx.getClass().getSimpleName());
-        }
-        return similarityFunction.computeSvasq4(segment, offset, vc.halfDim(), vc.state());
-    }
-
-    /**
-     * Prepares a per-query {@link DistanceContext.Svasq4Ctx} by applying FWHT rotation,
-     * pre-scaling, deinterleaving, and offset-bias folding.
-     *
-     * <p>This is the O(D log D) step. Call it <em>once per search</em>, then reuse
-     * the returned context for every candidate's {@link #distance} call.</p>
-     */
-    @Override
-    public DistanceContext prepareQueryContext(float[] query) {
-        return new DistanceContext.Svasq4Ctx(queryPrep.prepare(query), halfDim);
-    }
-
-    /** Returns the bytes per SVASQ-4 encoded vector (4-byte header + paddedDim/2 nibble-packed codes). */
-    @Override
-    public int bytesPerVector() {
-        return bpv;
-    }
-
-    @Override
-    public int compressionFactor(int dimensions) {
-        return Math.max(1, (dimensions * 4) / bpv);
-    }
-
-    /** Returns the backing SVASQ-4 encoder. */
-    public Svasq4Encoder encoder() {
-        return encoder;
-    }
-}
\ No newline at end of file
diff --git a/spector-core/src/main/java/com/spectrayan/spector/core/quantization/strategy/SvasqStrategy.java b/spector-core/src/main/java/com/spectrayan/spector/core/quantization/strategy/SvasqStrategy.java
deleted file mode 100644
index ea579c7..0000000
--- a/spector-core/src/main/java/com/spectrayan/spector/core/quantization/strategy/SvasqStrategy.java
+++ /dev/null
@@ -1,159 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.core.quantization.strategy;
-import com.spectrayan.spector.commons.error.SpectorException;
-
-import com.spectrayan.spector.core.quantization.svasq.SvasqEncoder;
-import com.spectrayan.spector.core.quantization.svasq.SvasqParams;
-import com.spectrayan.spector.core.quantization.svasq.SvasqQueryPrep;
-import com.spectrayan.spector.core.similarity.SimilarityFunction;
-
-import java.lang.foreign.MemorySegment;
-import java.lang.foreign.ValueLayout;
-import com.spectrayan.spector.commons.error.ErrorCode;
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-
-/**
- * Quantization strategy for SVASQ (FWHT-rotated asymmetric INT8 quantization).
- *
- * <h3>Memory layout per vector</h3>
- * <pre>
- *   [float32 exactNormSq (4 bytes)] [INT8 × paddedDim signed codes]
- * </pre>
- *
- * <h3>Distance computation</h3>
- * <p>The core efficiency win: {@link #prepareQueryContext} applies the FWHT rotation
- * and scale pre-multiplication <em>once per query</em>. The resulting
- * {@link DistanceContext.SvasqCtx} is reused for every candidate via
- * {@link SimilarityFunction#computeSvasq}, which dispatches to the Panama SIMD kernel
- * ({@link com.spectrayan.spector.core.quantization.svasq.SvasqSimdKernel}) with zero
- * additional allocations in the hot path.</p>
- *
- * <h3>Thread safety</h3>
- * <p>This class is immutable after construction. The {@link DistanceContext.SvasqCtx}
- * returned by {@link #prepareQueryContext} is a per-call value object that must not
- * be shared across concurrent searches.</p>
- */
-public final class SvasqStrategy implements QuantizationStrategy {
-
-    private final SvasqEncoder encoder;
-    private final SvasqQueryPrep queryPrep;
-    private final SimilarityFunction similarityFunction;
-    private final int bpv;
-    private final int paddedDim;
-
-    /**
-     * Creates a SVASQ strategy from pre-calibrated parameters.
-     *
-     * @param params             calibrated SVASQ parameters
-     * @param similarityFunction distance metric to use (EUCLIDEAN → L2, COSINE/DOT → dot)
-     */
-    public SvasqStrategy(SvasqParams params, SimilarityFunction similarityFunction) {
-        this.encoder = new SvasqEncoder(params);
-        this.queryPrep = new SvasqQueryPrep(params);
-        this.similarityFunction = similarityFunction;
-        this.bpv = params.bytesPerVector();
-        this.paddedDim = params.paddedDim();
-    }
-
-    /**
-     * Creates a SVASQ strategy from a pre-built encoder (avoids double-allocation
-     * when an encoder is already available).
-     *
-     * @param encoder            pre-built SVASQ encoder (non-null)
-     * @param similarityFunction distance metric to use
-     */
-    public SvasqStrategy(SvasqEncoder encoder, SimilarityFunction similarityFunction) {
-        this.encoder = encoder;
-        this.queryPrep = new SvasqQueryPrep(encoder.params());
-        this.similarityFunction = similarityFunction;
-        this.bpv = encoder.bytesPerVector();
-        this.paddedDim = encoder.params().paddedDim();
-    }
-
-    /**
-     * Encodes a float32 vector directly into the off-heap segment.
-     *
-     * <p>Applies FWHT rotation, INT8 quantization, and writes the 4-byte norm
-     * header + INT8 codes — zero heap allocation in the store path.</p>
-     */
-    @Override
-    public void encode(float[] vector, MemorySegment segment, long offset) {
-        encoder.encode(vector, segment, offset);
-    }
-
-    /**
-     * Decodes an approximation of the original vector from the off-heap segment.
-     *
-     * <p>Skips the 4-byte norm header; reads INT8 codes and reconstructs via
-     * {@code x̂ᵢ ≈ zᵢ × scaleᵢ + μᵢ} for {@code i < originalDim}.</p>
-     */
-    @Override
-    public float[] decode(MemorySegment segment, long offset, int dimensions) {
-        SvasqParams params = encoder.params();
-        float[] scales = params.scales();
-        float[] means  = params.means();
-        float[] result = new float[dimensions];
-        for (int i = 0; i < dimensions; i++) {
-            int code = segment.get(ValueLayout.JAVA_BYTE, offset + 4L + i);
-            result[i] = code * scales[i] + means[i];
-        }
-        return result;
-    }
-
-    /**
-     * Computes SVASQ distance between a stored (quantized) candidate and the
-     * pre-prepared query state.
-     *
-     * <p>Delegates to {@link SimilarityFunction#computeSvasq} which dispatches to
-     * the Panama SIMD kernel — reading directly from off-heap memory, zero GC pressure.</p>
-     */
-    @Override
-    public float distance(MemorySegment segment, long offset, DistanceContext ctx) {
-        if (!(ctx instanceof DistanceContext.SvasqCtx vc)) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_INVALID, "context", "expected SvasqCtx but got " + ctx.getClass().getSimpleName());
-        }
-        return similarityFunction.computeSvasq(segment, offset, vc.paddedDim(), vc.state());
-    }
-
-    /**
-     * Prepares a per-query {@link DistanceContext.SvasqCtx} by applying FWHT rotation
-     * and scale pre-multiplication to the query vector.
-     *
-     * <p>This is the O(D log D) step. Call it <em>once per search</em>, then reuse
-     * the returned context for every candidate's {@link #distance} call.</p>
-     */
-    @Override
-    public DistanceContext prepareQueryContext(float[] query) {
-        return new DistanceContext.SvasqCtx(queryPrep.prepare(query), paddedDim);
-    }
-
-    /** Returns the number of bytes per SVASQ-encoded vector (4-byte header + paddedDim codes). */
-    @Override
-    public int bytesPerVector() {
-        return bpv;
-    }
-
-    @Override
-    public int compressionFactor(int dimensions) {
-        return Math.max(1, (dimensions * 4) / bpv);
-    }
-
-    /** Returns the backing SVASQ encoder (for direct segment access by index layers). */
-    public SvasqEncoder encoder() {
-        return encoder;
-    }
-}
\ No newline at end of file
diff --git a/spector-core/src/main/java/com/spectrayan/spector/core/quantization/strategy/TurboQuantStrategy.java b/spector-core/src/main/java/com/spectrayan/spector/core/quantization/strategy/TurboQuantStrategy.java
deleted file mode 100644
index d9d7fe9..0000000
--- a/spector-core/src/main/java/com/spectrayan/spector/core/quantization/strategy/TurboQuantStrategy.java
+++ /dev/null
@@ -1,88 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.core.quantization.strategy;
-import com.spectrayan.spector.commons.error.SpectorException;
-
-import com.spectrayan.spector.core.quantization.TurboQuantizer;
-import com.spectrayan.spector.core.similarity.SimilarityFunction;
-
-import java.lang.foreign.MemorySegment;
-import java.lang.foreign.ValueLayout;
-import com.spectrayan.spector.commons.error.ErrorCode;
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-
-/**
- * Quantization strategy for TurboQuant (random-rotation + optimal scalar quantization).
- *
- * <p>Memory layout per vector: packed bytes per {@link TurboQuantizer#bytesPerVector()},
- * bit-width configurable (2/4/8 bits per dimension).</p>
- *
- * <h3>Distance computation</h3>
- * <p>Uses {@link TurboQuantizer#distanceFromRotatedQuery} with a pre-rotated query
- * (rotate-once, evaluate-N-times pattern via {@link DistanceContext.TurboContext}).
- * Supports L2 and dot product families.</p>
- */
-final class TurboQuantStrategy implements QuantizationStrategy {
-
-    private final TurboQuantizer quantizer;
-    private final SimilarityFunction similarityFunction;
-    private final int bpv;
-
-    TurboQuantStrategy(TurboQuantizer quantizer, SimilarityFunction similarityFunction) {
-        this.quantizer = quantizer;
-        this.similarityFunction = similarityFunction;
-        this.bpv = quantizer.bytesPerVector();
-    }
-
-    @Override
-    public void encode(float[] vector, MemorySegment segment, long offset) {
-        byte[] packed = quantizer.encodeToBytes(vector);
-        MemorySegment.copy(packed, 0, segment, ValueLayout.JAVA_BYTE, offset, packed.length);
-    }
-
-    @Override
-    public float[] decode(MemorySegment segment, long offset, int dimensions) {
-        byte[] packed = new byte[bpv];
-        MemorySegment.copy(segment, ValueLayout.JAVA_BYTE, offset, packed, 0, bpv);
-        return quantizer.decodeFromBytes(packed);
-    }
-
-    @Override
-    public float distance(MemorySegment segment, long offset, DistanceContext ctx) {
-        if (!(ctx instanceof DistanceContext.TurboContext tc)) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_INVALID, "context", "expected TurboContext but got " + ctx.getClass().getSimpleName());
-        }
-        byte[] packed = new byte[bpv];
-        MemorySegment.copy(segment, ValueLayout.JAVA_BYTE, offset, packed, 0, bpv);
-        return quantizer.distanceFromRotatedQuery(tc.rotatedQuery(), packed);
-    }
-
-    @Override
-    public DistanceContext prepareQueryContext(float[] query) {
-        // Rotate query once; reuse across all candidates
-        return new DistanceContext.TurboContext(quantizer.rotateQuery(query));
-    }
-
-    @Override
-    public int bytesPerVector() {
-        return bpv;
-    }
-
-    @Override
-    public int compressionFactor(int dimensions) {
-        return Math.max(1, (dimensions * 4) / bpv);
-    }
-}
\ No newline at end of file
diff --git a/spector-core/src/main/java/com/spectrayan/spector/core/quantization/svasq/Svasq4Encoder.java b/spector-core/src/main/java/com/spectrayan/spector/core/quantization/svasq/Svasq4Encoder.java
deleted file mode 100644
index 586da80..0000000
--- a/spector-core/src/main/java/com/spectrayan/spector/core/quantization/svasq/Svasq4Encoder.java
+++ /dev/null
@@ -1,187 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.core.quantization.svasq;
-import com.spectrayan.spector.commons.error.SpectorException;
-
-import java.lang.foreign.MemorySegment;
-import java.lang.foreign.ValueLayout;
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-import com.spectrayan.spector.commons.error.ErrorCode;
-
-/**
- * SVASQ-4 encoder — FWHT rotation + offset-encoded INT4 quantization with nibble packing.
- *
- * <h3>Encoding pipeline</h3>
- * <ol>
- *   <li>Compute exact L2 norm² of the original vector.</li>
- *   <li>FWHT-rotate the vector (sign-flip → butterfly → normalize).</li>
- *   <li>Affine-quantize each rotated dimension: {@code z = round((x - μ) × invScale)}</li>
- *   <li>Clamp to [-7, 7] and offset-encode to [0, 14]: {@code u = z + 7}</li>
- *   <li>Nibble-pack: two unsigned 4-bit values per byte (high nibble first).</li>
- *   <li>Write to off-heap {@link MemorySegment}: 4-byte float32 norm header + nibble-packed codes.</li>
- * </ol>
- *
- * <h3>Memory layout (per vector)</h3>
- * <pre>
- *   [float32 exactNormSq (4 bytes)] [nibble-packed codes (paddedDim/2 bytes)]
- *   Total: 4 + paddedDim/2 bytes per vector
- * </pre>
- *
- * <h3>Thread safety</h3>
- * <p>Instances are immutable after construction. Per-thread scratch buffers are managed
- * via {@link ThreadLocal}, making concurrent encoding safe with zero heap allocation
- * on the hot path.</p>
- *
- * @see SvasqEncoder
- * @see Svasq4SimdKernel
- */
-public final class Svasq4Encoder {
-
-    /** Offset applied to signed quantized values [-7, 7] → unsigned [0, 14]. */
-    static final int OFFSET = 7;
-
-    private final SvasqParams params;
-    private final int paddedDim;
-    private final int bytesPerVector;
-
-    /**
-     * Per-thread scratch buffer for the FWHT rotation output.
-     * Avoids allocating a new {@code float[paddedDim]} on every encode call.
-     */
-    private final ThreadLocal<float[]> rotScratch;
-
-    /**
-     * Creates a SVASQ-4 encoder from pre-calibrated 4-bit parameters.
-     *
-     * @param params calibrated {@link SvasqParams} with {@link SvasqParams#BIT_WIDTH_4}
-     * @throws SpectorValidationException if params.bitWidth() is not 4
-     */
-    public Svasq4Encoder(SvasqParams params) {
-        if (params == null) throw new SpectorValidationException(ErrorCode.ARGUMENT_NULL, "params");
-        if (params.bitWidth() != SvasqParams.BIT_WIDTH_4) {
-            throw new SpectorValidationException(ErrorCode.BIT_WIDTH_INVALID, "4", params.bitWidth());
-        }
-        this.params = params;
-        this.paddedDim = params.paddedDim();
-        this.bytesPerVector = params.bytesPerVector();
-        this.rotScratch = ThreadLocal.withInitial(() -> new float[paddedDim]);
-    }
-
-    /**
-     * Encodes a float32 vector directly into an off-heap {@link MemorySegment}.
-     *
-     * <p><b>Zero heap allocation</b> on the hot path — uses thread-local scratch
-     * for the FWHT rotation, and writes nibble-packed codes directly into the segment.</p>
-     *
-     * @param vector  the original float32 vector (length = originalDim)
-     * @param segment off-heap memory segment to write into
-     * @param offset  byte offset within the segment for this vector's storage
-     * @throws SpectorValidationException if vector.length ≠ originalDim
-     */
-    public void encode(float[] vector, MemorySegment segment, long offset) {
-        int originalDim = params.originalDim();
-        if (vector.length != originalDim) {
-            throw new SpectorValidationException(ErrorCode.DIMENSIONS_MISMATCH, originalDim, vector.length);
-        }
-
-        float[] means     = params.means();
-        float[] invScales = params.invScales();
-
-        // 1. Compute exact L2 norm² (double accumulator for precision)
-        double normSqAcc = 0.0;
-        for (float v : vector) normSqAcc += (double) v * v;
-        segment.set(ValueLayout.JAVA_FLOAT, offset, (float) normSqAcc);
-
-        // 2. FWHT rotate into thread-local scratch (zero allocation)
-        float[] rotated = rotScratch.get();
-        params.fwht().rotate(vector, rotated);
-
-        // 3. Quantize → clamp → offset-encode → nibble-pack → write
-        long codeOffset = offset + 4L;
-        int halfDim = paddedDim / 2;
-
-        for (int k = 0; k < halfDim; k++) {
-            int d0 = 2 * k;       // even-indexed dimension (high nibble)
-            int d1 = 2 * k + 1;   // odd-indexed dimension  (low nibble)
-
-            // Affine quantize: z = round((x - μ) × invScale)
-            int z0 = Math.round((rotated[d0] - means[d0]) * invScales[d0]);
-            int z1 = Math.round((rotated[d1] - means[d1]) * invScales[d1]);
-
-            // Clamp to [-7, 7]
-            z0 = Math.clamp(z0, -OFFSET, OFFSET);
-            z1 = Math.clamp(z1, -OFFSET, OFFSET);
-
-            // Offset-encode to [0, 14]
-            int u0 = z0 + OFFSET;
-            int u1 = z1 + OFFSET;
-
-            // Nibble-pack: high nibble = u0, low nibble = u1
-            byte packed = (byte) ((u0 << 4) | (u1 & 0x0F));
-            segment.set(ValueLayout.JAVA_BYTE, codeOffset + k, packed);
-        }
-    }
-
-    /**
-     * Decodes an approximate float32 vector from the off-heap segment.
-     *
-     * <p>Reads nibble-packed codes, reverse offset-encodes, and applies the
-     * affine reconstruction: {@code x̂ᵢ ≈ zᵢ × scaleᵢ + μᵢ}.</p>
-     *
-     * <p>Only the first {@code dimensions} values are returned (padded dimensions excluded).</p>
-     *
-     * @param segment    off-heap segment containing the encoded vector
-     * @param offset     byte offset of the vector's norm header
-     * @param dimensions number of dimensions to reconstruct (typically originalDim)
-     * @return approximate float32 vector of length {@code dimensions}
-     */
-    public float[] decode(MemorySegment segment, long offset, int dimensions) {
-        float[] scales = params.scales();
-        float[] means  = params.means();
-        float[] result = new float[dimensions];
-
-        long codeOffset = offset + 4L;
-
-        for (int d = 0; d < dimensions; d++) {
-            int k = d / 2;
-            byte packed = segment.get(ValueLayout.JAVA_BYTE, codeOffset + k);
-
-            // Extract nibble (high for even d, low for odd d)
-            int u = (d % 2 == 0) ? ((packed >>> 4) & 0x0F) : (packed & 0x0F);
-
-            // Reverse offset → signed value
-            int z = u - OFFSET;
-
-            // Affine reconstruction
-            result[d] = z * scales[d] + means[d];
-        }
-        return result;
-    }
-
-    /**
-     * Returns the calibration parameters backing this encoder.
-     *
-     * @return SVASQ-4 params (bitWidth=4)
-     */
-    public SvasqParams params() { return params; }
-
-    /**
-     * Returns the number of bytes per encoded vector (4-byte header + paddedDim/2 code bytes).
-     *
-     * @return bytes per vector
-     */
-    public int bytesPerVector() { return bytesPerVector; }
-}
\ No newline at end of file
diff --git a/spector-core/src/main/java/com/spectrayan/spector/core/quantization/svasq/Svasq4QueryPrep.java b/spector-core/src/main/java/com/spectrayan/spector/core/quantization/svasq/Svasq4QueryPrep.java
deleted file mode 100644
index 1a52d4a..0000000
--- a/spector-core/src/main/java/com/spectrayan/spector/core/quantization/svasq/Svasq4QueryPrep.java
+++ /dev/null
@@ -1,150 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.core.quantization.svasq;
-import com.spectrayan.spector.commons.error.SpectorException;
-
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-import com.spectrayan.spector.commons.error.ErrorCode;
-
-/**
- * Prepares a {@link Svasq4QueryState} from a raw float32 query vector.
- *
- * <p>Call {@link #prepare(float[])} exactly <em>once per query</em> before the
- * HNSW/IVF graph traversal loop. The resulting {@link Svasq4QueryState} is then
- * passed to {@link Svasq4SimdKernel} for every candidate distance evaluation.</p>
- *
- * <h3>Preparation steps</h3>
- * <ol>
- *   <li>Compute exact query norm: {@code qNormSq = ‖q‖²}.</li>
- *   <li>FWHT-rotate the query: {@code qRot = FWHT(signFlip(q_padded)) / √paddedDim}.</li>
- *   <li>Pre-scale: {@code q̃ᵢ = qRotᵢ × scaleᵢ} and accumulate
- *       {@code C(q) = Σ qRotᵢ × μᵢ}.</li>
- *   <li>Compute nibble bias: {@code nibbleBias = 7 × Σᵢ q̃ᵢ}.</li>
- *   <li>Deinterleave q̃ into hi/lo arrays for SIMD kernel alignment.</li>
- *   <li>Compute adjusted constants:
- *       {@code constL2Q = qNormSq − 2·C(q) + 2·nibbleBias}.</li>
- * </ol>
- *
- * <h3>Allocation budget</h3>
- * <p>Uses per-thread {@link ThreadLocal} scratch buffers for the FWHT rotation
- * and the deinterleaved output arrays. Zero per-call heap allocation on the hot path.</p>
- *
- * <h3>Lifetime contract</h3>
- * <p>The returned {@link Svasq4QueryState} references thread-local storage and must
- * not be stored beyond the current search call.</p>
- *
- * <p>Instances are immutable after construction and safe for concurrent use.</p>
- */
-public final class Svasq4QueryPrep {
-
-    private final SvasqParams params;
-    private final int paddedDim;
-    private final int halfDim;
-
-    /**
-     * Per-thread scratch: [0] = qRot(paddedDim), [1] = qTildeHi(halfDim), [2] = qTildeLo(halfDim).
-     */
-    private final ThreadLocal<float[][]> queryScratch;
-
-    /**
-     * Creates a query preparer backed by the given 4-bit calibration parameters.
-     *
-     * @param params calibrated SVASQ-4 parameters (non-null, bitWidth must be 4)
-     * @throws SpectorValidationException if params.bitWidth() ≠ 4
-     */
-    public Svasq4QueryPrep(SvasqParams params) {
-        if (params == null) throw new SpectorValidationException(ErrorCode.ARGUMENT_NULL, "params");
-        if (params.bitWidth() != SvasqParams.BIT_WIDTH_4) {
-            throw new SpectorValidationException(ErrorCode.BIT_WIDTH_INVALID, "4", params.bitWidth());
-        }
-        this.params = params;
-        this.paddedDim = params.paddedDim();
-        this.halfDim = paddedDim / 2;
-        this.queryScratch = ThreadLocal.withInitial(() -> new float[][] {
-                new float[paddedDim],   // [0] qRot
-                new float[halfDim],     // [1] qTildeHi (even dims)
-                new float[halfDim]      // [2] qTildeLo (odd dims)
-        });
-    }
-
-    /**
-     * Prepares a {@link Svasq4QueryState} from a float32 query vector.
-     *
-     * <p>Uses thread-local scratch buffers — zero per-call heap allocation.</p>
-     *
-     * <p><b>Lifetime contract:</b> the returned state references thread-local storage
-     * and must not be stored beyond the current search call.</p>
-     *
-     * @param query the float32 query vector (length must equal {@code params.originalDim()})
-     * @return a {@link Svasq4QueryState} ready for {@link Svasq4SimdKernel}
-     * @throws SpectorValidationException if query.length ≠ originalDim
-     */
-    public Svasq4QueryState prepare(float[] query) {
-        int originalDim  = params.originalDim();
-        float[] means    = params.means();
-        float[] scales   = params.scales();
-
-        if (query.length != originalDim) {
-            throw new SpectorValidationException(ErrorCode.DIMENSIONS_MISMATCH, originalDim, query.length);
-        }
-
-        // 1. Exact query norm squared (double accumulator for precision)
-        double qNormSqAcc = 0.0;
-        for (float v : query) qNormSqAcc += (double) v * v;
-        float qNormSq = (float) qNormSqAcc;
-
-        // 2. Rotate query into thread-local scratch — zero allocation
-        float[][] scratch  = queryScratch.get();
-        float[] qRot       = scratch[0];
-        float[] qTildeHi   = scratch[1];
-        float[] qTildeLo   = scratch[2];
-        params.fwht().rotate(query, qRot);
-
-        // 3. Pre-scale and accumulate C(q) + nibbleBias
-        double cQ = 0.0;
-        double nibbleBias = 0.0;
-
-        for (int i = 0; i < paddedDim; i++) {
-            float qTilde_i = qRot[i] * scales[i];
-            cQ += (double) qRot[i] * means[i];
-            nibbleBias += qTilde_i;
-
-            // 4. Deinterleave into hi/lo arrays
-            int k = i / 2;
-            if ((i & 1) == 0) {
-                qTildeHi[k] = qTilde_i;   // even dims → high nibble array
-            } else {
-                qTildeLo[k] = qTilde_i;   // odd dims  → low nibble array
-            }
-        }
-        nibbleBias *= Svasq4Encoder.OFFSET;  // nibbleBias = 7 × Σ q̃ᵢ
-
-        // 5. Adjusted L2 constant: absorbs offset-encoding bias
-        //    L2 = exactNormSq + constL2Q − 2 × dotUnsigned
-        //    where constL2Q = qNormSq − 2·C(q) + 2·nibbleBias
-        float constL2Q  = qNormSq - 2f * (float) cQ + 2f * (float) nibbleBias;
-        float dotOffset = (float) cQ - (float) nibbleBias;
-
-        return new Svasq4QueryState(qTildeHi, qTildeLo, constL2Q, dotOffset, qNormSq);
-    }
-
-    /**
-     * Returns the calibration parameters backing this query preparer.
-     *
-     * @return SVASQ-4 params
-     */
-    public SvasqParams params() { return params; }
-}
\ No newline at end of file
diff --git a/spector-core/src/main/java/com/spectrayan/spector/core/quantization/svasq/Svasq4QueryState.java b/spector-core/src/main/java/com/spectrayan/spector/core/quantization/svasq/Svasq4QueryState.java
deleted file mode 100644
index 54fe52f..0000000
--- a/spector-core/src/main/java/com/spectrayan/spector/core/quantization/svasq/Svasq4QueryState.java
+++ /dev/null
@@ -1,115 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.core.quantization.svasq;
-
-/**
- * Precomputed query context for SVASQ-4 (INT4) asymmetric distance computation.
- *
- * <p>Created once per query by {@link Svasq4QueryPrep#prepare} and reused for every
- * candidate distance evaluation in the HNSW/IVF traversal loop.</p>
- *
- * <h3>Deinterleaved layout for SIMD efficiency</h3>
- * <p>SVASQ-4 nibble-packed bytes contain two values per byte: the high nibble holds
- * even-indexed FWHT dimensions, the low nibble holds odd-indexed dimensions. To
- * enable straight-through SIMD processing, the query's pre-scaled coefficients are
- * deinterleaved into two contiguous arrays:</p>
- * <ul>
- *   <li>{@link #qTildeHi()} — pre-scaled coefficients for even dims: q̃[0], q̃[2], q̃[4], ...</li>
- *   <li>{@link #qTildeLo()} — pre-scaled coefficients for odd dims:  q̃[1], q̃[3], q̃[5], ...</li>
- * </ul>
- *
- * <h3>Offset-encoding bias</h3>
- * <p>Since stored codes are offset-encoded ({@code u = z + 7}), the dot product is:
- * {@code Σ uᵢ × q̃ᵢ = Σ zᵢ × q̃ᵢ + 7 × Σ q̃ᵢ}. The constant term
- * ({@code 7 × Σ q̃ᵢ}) is absorbed into {@link #constL2Q()} so the SIMD kernel
- * computes only the unsigned dot product.</p>
- *
- * <h3>Full L2 distance formula</h3>
- * <pre>
- *   L2 = exactNormSq + constL2Q − 2 × (Σ uᵢ_hi × qTildeHi[i] + Σ uᵢ_lo × qTildeLo[i])
- * </pre>
- *
- * <p>Instances are immutable-by-contract and safe for concurrent use.</p>
- *
- * @see Svasq4QueryPrep
- * @see Svasq4SimdKernel
- */
-public final class Svasq4QueryState {
-
-    private final float[] qTildeHi;   // pre-scaled query, even dims [halfDim]
-    private final float[] qTildeLo;   // pre-scaled query, odd dims  [halfDim]
-    private final float constL2Q;     // ‖q‖² − 2·C(q) + 2·nibbleBias (query-side L2 constant)
-    private final float dotOffset;    // C(q) − nibbleBias (for dot product reconstruction)
-    private final float qNormSq;      // ‖q‖² (stored for diagnostics)
-
-    Svasq4QueryState(float[] qTildeHi, float[] qTildeLo,
-                    float constL2Q, float dotOffset, float qNormSq) {
-        this.qTildeHi = qTildeHi;
-        this.qTildeLo = qTildeLo;
-        this.constL2Q = constL2Q;
-        this.dotOffset = dotOffset;
-        this.qNormSq = qNormSq;
-    }
-
-    /**
-     * Pre-scaled query coefficients for even-indexed FWHT dimensions (high nibbles).
-     *
-     * <p>Layout: {@code qTildeHi[k] = qRot[2k] × scale[2k]}, length = paddedDim/2.</p>
-     *
-     * <p><strong>Do not modify the returned array</strong> — it may be shared.</p>
-     *
-     * @return deinterleaved high-nibble query array
-     */
-    public float[] qTildeHi() { return qTildeHi; }
-
-    /**
-     * Pre-scaled query coefficients for odd-indexed FWHT dimensions (low nibbles).
-     *
-     * <p>Layout: {@code qTildeLo[k] = qRot[2k+1] × scale[2k+1]}, length = paddedDim/2.</p>
-     *
-     * <p><strong>Do not modify the returned array</strong> — it may be shared.</p>
-     *
-     * @return deinterleaved low-nibble query array
-     */
-    public float[] qTildeLo() { return qTildeLo; }
-
-    /**
-     * Query-side L2 constant incorporating the offset-encoding bias.
-     *
-     * <p>{@code constL2Q = ‖q‖² − 2·C(q) + 2·nibbleBias}, where
-     * {@code nibbleBias = 7 × Σᵢ q̃ᵢ}.</p>
-     *
-     * <p>The full L2 distance is: {@code L2 = exactNormSq + constL2Q − 2 × dotUnsigned}.</p>
-     *
-     * @return query-side L2 constant
-     */
-    public float constL2Q() { return constL2Q; }
-
-    /**
-     * Dot-product offset for reconstructing the approximate inner product:
-     * {@code approxIP = dotUnsigned + dotOffset}.
-     *
-     * @return dot product offset
-     */
-    public float dotOffset() { return dotOffset; }
-
-    /**
-     * Exact query L2 norm squared: {@code ‖q‖²}.
-     *
-     * @return query norm squared
-     */
-    public float qNormSq() { return qNormSq; }
-}
diff --git a/spector-core/src/main/java/com/spectrayan/spector/core/quantization/svasq/Svasq4SimdKernel.java b/spector-core/src/main/java/com/spectrayan/spector/core/quantization/svasq/Svasq4SimdKernel.java
deleted file mode 100644
index 9e5082e..0000000
--- a/spector-core/src/main/java/com/spectrayan/spector/core/quantization/svasq/Svasq4SimdKernel.java
+++ /dev/null
@@ -1,211 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.core.quantization.svasq;
-
-import com.spectrayan.spector.core.simd.SimdCapability;
-
-import jdk.incubator.vector.ByteVector;
-import jdk.incubator.vector.FloatVector;
-import jdk.incubator.vector.VectorOperators;
-import jdk.incubator.vector.VectorShape;
-import jdk.incubator.vector.VectorSpecies;
-
-import java.lang.foreign.MemorySegment;
-import java.lang.foreign.ValueLayout;
-import java.nio.ByteOrder;
-
-/**
- * SIMD-accelerated SVASQ-4 distance kernel for nibble-packed INT4 codes.
- *
- * <h3>Nibble Packing Format</h3>
- * <p>Each stored byte contains two offset-encoded unsigned 4-bit values [0, 14]:</p>
- * <pre>
- *   byte[k] = (u_even &lt;&lt; 4) | (u_odd &amp; 0x0F)
- *   where u_even = dim[2k] + 7,  u_odd = dim[2k+1] + 7
- * </pre>
- *
- * <h3>The Hot Loop (L2 Distance)</h3>
- * <pre>
- *   For each VL-byte block at position i (processes 2×VL dimensions):
- *     packed = loadBytes(segment, codeOffset + i)        // VL bytes = 2×VL nibbles
- *     hi     = (packed &gt;&gt;&gt; 4) &amp; 0x0F                    // even dims [0, 14]
- *     lo     = packed &amp; 0x0F                             // odd dims  [0, 14]
- *     hiF    = castShape(hi)                             // unsigned widening → float32
- *     loF    = castShape(lo)                             // unsigned widening → float32
- *     accHi += hiF × qTildeHi[i]                        // FMA for even dims
- *     accLo += loF × qTildeLo[i]                        // FMA for odd dims (ILP)
- *   dot = reduceLanes(accHi + accLo)
- *   L2  = exactNormSq + constL2Q − 2 × dot
- * </pre>
- *
- * <h3>Unsigned Widening</h3>
- * <p>After masking, all byte values are in [0, 14] (non-negative in signed byte range).
- * {@code castShape} performs signed widening ({@code vpmovsxbd}), which produces
- * correct float32 values for [0, 14] since the sign bit is always 0.</p>
- *
- * <h3>ILP via High/Low Split</h3>
- * <p>Processing high and low nibbles independently exposes instruction-level parallelism:
- * the CPU can pipeline the high-nibble FMA while loading/masking the low nibble from
- * the same byte vector. This is analogous to the 2× unrolling in {@link SvasqSimdKernel}.</p>
- *
- * <p>All methods are stateless and safe for concurrent use.</p>
- *
- * @see Svasq4QueryState
- * @see Svasq4QueryPrep
- * @see SvasqSimdKernel
- */
-public final class Svasq4SimdKernel {
-
-    // Preferred float species: AVX2 → 8 lanes (256-bit), AVX-512 → 16 lanes (512-bit)
-    private static final VectorSpecies<Float> F_SPECIES = SimdCapability.PREFERRED_SPECIES;
-
-    // Byte species with the SAME lane count as F_SPECIES.
-    private static final VectorSpecies<Byte> B_SPECIES =
-            VectorSpecies.of(byte.class,
-                    VectorShape.forBitSize(F_SPECIES.length() * Byte.SIZE));
-
-    /** Number of float lanes per SIMD register. */
-    private static final int VL = F_SPECIES.length();
-
-    /** Mask for extracting the low nibble (bits 3..0). */
-    private static final byte NIBBLE_MASK = 0x0F;
-
-    static {
-        assert B_SPECIES.length() == F_SPECIES.length()
-                : "B_SPECIES lanes must equal F_SPECIES lanes";
-    }
-
-    private Svasq4SimdKernel() {}
-
-    /**
-     * Computes the approximate squared L2 distance between a prepared SVASQ-4 query
-     * and a nibble-packed encoded vector in a {@link MemorySegment}.
-     *
-     * <p>Formula: {@code L2 ≈ exactNormSq + constL2Q − 2 × dotUnsigned}</p>
-     * <p>where {@code dotUnsigned = Σ uHi × qTildeHi + Σ uLo × qTildeLo}.</p>
-     *
-     * <p>Reads directly from off-heap memory with zero JVM GC allocations.</p>
-     *
-     * @param segment    off-heap memory segment containing the encoded vector database
-     * @param offset     byte offset of the target vector's 4-byte float32 norm header
-     * @param halfDim    half of paddedDim (= number of nibble-packed bytes to process)
-     * @param qs         pre-prepared SVASQ-4 query state (from {@link Svasq4QueryPrep#prepare})
-     * @return approximate squared L2 distance (non-negative)
-     */
-    public static float computeL2(MemorySegment segment, long offset,
-                                   int halfDim, Svasq4QueryState qs) {
-        float exactNormSq = segment.get(ValueLayout.JAVA_FLOAT, offset);
-        long  codeOffset  = offset + 4L;
-        float[] qTildeHi  = qs.qTildeHi();
-        float[] qTildeLo  = qs.qTildeLo();
-
-        FloatVector accHi = FloatVector.zero(F_SPECIES);
-        FloatVector accLo = FloatVector.zero(F_SPECIES);
-
-        // Main SIMD loop — processes VL packed bytes (= 2×VL dimensions) per iteration
-        int i = 0;
-        for (; i + VL <= halfDim; i += VL) {
-            // Load VL packed bytes from off-heap segment
-            ByteVector packed = ByteVector.fromMemorySegment(
-                    B_SPECIES, segment, codeOffset + i, ByteOrder.nativeOrder());
-
-            // Extract high nibbles → even-indexed dimensions [0, 14]
-            ByteVector hi = packed.lanewise(VectorOperators.LSHR, 4).and(NIBBLE_MASK);
-            FloatVector hiF = (FloatVector) hi.castShape(F_SPECIES, 0);
-            FloatVector qHi = FloatVector.fromArray(F_SPECIES, qTildeHi, i);
-            accHi = hiF.fma(qHi, accHi);
-
-            // Extract low nibbles → odd-indexed dimensions [0, 14]
-            ByteVector lo = packed.and(NIBBLE_MASK);
-            FloatVector loF = (FloatVector) lo.castShape(F_SPECIES, 0);
-            FloatVector qLo = FloatVector.fromArray(F_SPECIES, qTildeLo, i);
-            accLo = loF.fma(qLo, accLo);
-        }
-
-        // Scalar cleanup for tail (rare: only when halfDim is not a multiple of VL)
-        float scalarDot = 0f;
-        for (; i < halfDim; i++) {
-            byte packed = segment.get(ValueLayout.JAVA_BYTE, codeOffset + i);
-            int hiVal = (packed >>> 4) & 0x0F;
-            int loVal = packed & 0x0F;
-            scalarDot += hiVal * qTildeHi[i] + loVal * qTildeLo[i];
-        }
-
-        float dot = accHi.add(accLo).reduceLanes(VectorOperators.ADD) + scalarDot;
-
-        return exactNormSq + qs.constL2Q() - 2f * dot;
-    }
-
-    /**
-     * Computes the approximate inner product between a prepared SVASQ-4 query
-     * and a nibble-packed encoded vector.
-     *
-     * <p>Formula: {@code IP ≈ dotUnsigned + dotOffset}</p>
-     *
-     * @param segment    off-heap memory segment
-     * @param offset     byte offset of the target vector's norm header
-     * @param halfDim    half of paddedDim (number of nibble-packed bytes)
-     * @param qs         pre-prepared SVASQ-4 query state
-     * @return approximate inner product
-     */
-    public static float computeDot(MemorySegment segment, long offset,
-                                    int halfDim, Svasq4QueryState qs) {
-        long    codeOffset = offset + 4L;
-        float[] qTildeHi   = qs.qTildeHi();
-        float[] qTildeLo   = qs.qTildeLo();
-
-        FloatVector accHi = FloatVector.zero(F_SPECIES);
-        FloatVector accLo = FloatVector.zero(F_SPECIES);
-
-        int i = 0;
-        for (; i + VL <= halfDim; i += VL) {
-            ByteVector packed = ByteVector.fromMemorySegment(
-                    B_SPECIES, segment, codeOffset + i, ByteOrder.nativeOrder());
-
-            ByteVector hi = packed.lanewise(VectorOperators.LSHR, 4).and(NIBBLE_MASK);
-            FloatVector hiF = (FloatVector) hi.castShape(F_SPECIES, 0);
-            accHi = hiF.fma(FloatVector.fromArray(F_SPECIES, qTildeHi, i), accHi);
-
-            ByteVector lo = packed.and(NIBBLE_MASK);
-            FloatVector loF = (FloatVector) lo.castShape(F_SPECIES, 0);
-            accLo = loF.fma(FloatVector.fromArray(F_SPECIES, qTildeLo, i), accLo);
-        }
-
-        // Scalar cleanup
-        float scalarDot = 0f;
-        for (; i < halfDim; i++) {
-            byte packed = segment.get(ValueLayout.JAVA_BYTE, codeOffset + i);
-            int hiVal = (packed >>> 4) & 0x0F;
-            int loVal = packed & 0x0F;
-            scalarDot += hiVal * qTildeHi[i] + loVal * qTildeLo[i];
-        }
-
-        return accHi.add(accLo).reduceLanes(VectorOperators.ADD) + scalarDot + qs.dotOffset();
-    }
-
-    /**
-     * Returns the number of float lanes per SIMD register.
-     *
-     * @return lane count (e.g. 8 for AVX2, 16 for AVX-512)
-     */
-    public static int laneCount() { return VL; }
-
-    /** Returns the float vector species used by this kernel. */
-    public static VectorSpecies<Float> floatSpecies() { return F_SPECIES; }
-
-    /** Returns the byte vector species used for packed loads. */
-    public static VectorSpecies<Byte> byteSpecies() { return B_SPECIES; }
-}
diff --git a/spector-core/src/main/java/com/spectrayan/spector/core/quantization/svasq/SvasqCalibrator.java b/spector-core/src/main/java/com/spectrayan/spector/core/quantization/svasq/SvasqCalibrator.java
deleted file mode 100644
index 13cd3ce..0000000
--- a/spector-core/src/main/java/com/spectrayan/spector/core/quantization/svasq/SvasqCalibrator.java
+++ /dev/null
@@ -1,449 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.core.quantization.svasq;
-import com.spectrayan.spector.commons.error.SpectorException;
-
-import java.util.Arrays;
-import java.util.List;
-import java.util.Random;
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-import com.spectrayan.spector.commons.error.ErrorCode;
-
-/**
- * Calibrates SVASQ quantization parameters from a representative sample corpus.
- *
- * <h3>Algorithm</h3>
- * <ol>
- *   <li>Rotate all sample vectors using {@link SvasqFwht} (sign-flip + FWHT + normalize).</li>
- *   <li>For each rotated dimension {@code j}:
- *     <ul>
- *       <li>Compute the {@code clip_percentile}-th and {@code (1-clip_percentile)}-th
- *           percentiles as clipping bounds.</li>
- *       <li>Compute the mean and standard deviation of values within the clipped range.</li>
- *       <li>Derive {@code scaleᵢ = CLIP_SIGMAS × σᵢ / 127} and
- *           {@code invScaleᵢ = 127 / (CLIP_SIGMAS × σᵢ)}.</li>
- *     </ul>
- *   </li>
- * </ol>
- *
- * <p>This calibration is equivalent to the whitepaper's Algorithm 1 (SVASQ-Calibrate)
- * with two key differences: (a) calibration is done in the <em>rotated</em> space
- * (fixing the quant.md bug), and (b) the scale is derived from the clipped std dev
- * rather than raw min/max (giving better accuracy for Gaussian/sub-Gaussian embeddings).</p>
- *
- * <h3>Overloads</h3>
- * <ul>
- *   <li>{@link #calibrate(List, int, long)} — from a List of float[] vectors</li>
- *   <li>{@link #calibrate(float[][], int, int, long)} — from a float[][] array slice
- *       (avoids {@code Arrays.copyOf} + List wrapper)</li>
- *   <li>{@link #calibrate(float[], int, int, long)} — from a flat flattened buffer
- *       (used by SpectorShard to pass its contiguous flatData directly)</li>
- * </ul>
- *
- * <h3>Thread Safety</h3>
- * <p>Stateless — all methods are static and safe for concurrent use.</p>
- */
-public final class SvasqCalibrator {
-
-    /** Percentile clipping boundary: clip at 0.1th and 99.9th percentiles. */
-    static final float CLIP_PERCENTILE = 0.001f;
-
-    /**
-     * Number of standard deviations the quantization range covers.
-     * {@code 3.0} covers 99.7% of a Gaussian distribution within [-127, 127].
-     */
-    static final float CLIP_SIGMAS = 3.0f;
-
-    /**
-     * Tighter clipping for SVASQ-4 (INT4, 15 levels).
-     * {@code 2.5} reduces outlier exposure when only 15 quantization levels are available.
-     */
-    static final float CLIP_SIGMAS_4BIT = 2.5f;
-
-    /** Maximum sample vectors used for calibration. */
-    static final int MAX_SAMPLE_SIZE = 10_000;
-
-    /** Maximum quantization level for INT8 [-127, 127]. */
-    private static final int MAX_LEVEL_INT8 = 127;
-
-    /** Maximum quantization level for INT4 [0, 14] offset-encoded (signed range [-7, 7]). */
-    private static final int MAX_LEVEL_INT4 = 7;
-
-    /** Minimum allowed std dev to prevent division by zero on zero-variance dims. */
-    private static final float MIN_STD = 1e-6f;
-
-    private SvasqCalibrator() {}
-
-    // ── Public API ────────────────────────────────────────────────────────────
-
-    /**
-     * Calibrates SVASQ parameters from a list of sample vectors.
-     *
-     * <p>The sample is capped at {@link #MAX_SAMPLE_SIZE} vectors. If the list is larger,
-     * vectors are drawn uniformly at random (seeded for reproducibility).</p>
-     *
-     * @param sampleVectors representative sample (at least 100 vectors recommended)
-     * @param originalDim   vector dimensionality
-     * @param seed          FWHT sign-flip seed; must match the seed used at encode time
-     * @return calibrated {@link SvasqParams}
-     * @throws SpectorValidationException if sampleVectors is empty or dimensions don't match
-     */
-    public static SvasqParams calibrate(List<float[]> sampleVectors,
-                                        int originalDim, long seed) {
-        if (sampleVectors == null || sampleVectors.isEmpty()) {
-            throw new SpectorValidationException(ErrorCode.EMPTY_COLLECTION, "sampleVectors");
-        }
-        // Subsample if needed
-        List<float[]> sample = subsampleList(sampleVectors, MAX_SAMPLE_SIZE, seed);
-        int n = sample.size();
-        for (float[] v : sample) {
-            if (v.length != originalDim) {
-                throw new SpectorValidationException(ErrorCode.DIMENSIONS_MISMATCH, originalDim, v.length);
-            }
-        }
-        SvasqFwht fwht = new SvasqFwht(originalDim, seed);
-        int paddedDim  = fwht.paddedDim();
-
-        // Rotate all samples — one float[] per vector (unavoidable for column-wise stats)
-        float[][] rotated = new float[n][paddedDim];
-        float[] tempVec   = new float[originalDim]; // reused per vector
-        for (int i = 0; i < n; i++) {
-            float[] src = sample.get(i);
-            System.arraycopy(src, 0, tempVec, 0, originalDim);
-            fwht.rotate(tempVec, rotated[i]);
-        }
-        return computeParams(rotated, n, paddedDim, originalDim, fwht);
-    }
-
-    /**
-     * Convenience overload using {@link SvasqParams#DEFAULT_SEED}.
-     */
-    public static SvasqParams calibrate(List<float[]> sampleVectors, int originalDim) {
-        return calibrate(sampleVectors, originalDim, SvasqParams.DEFAULT_SEED);
-    }
-
-    /**
-     * Calibrates SVASQ parameters from a {@code float[][]} array, using only the
-     * first {@code n} rows. Avoids the {@code Arrays.copyOf} + {@code List} wrapper
-     * required by the List overload.
-     *
-     * <p>Used by {@link com.spectrayan.spector.index.QuantizedHnswIndex#calibrateSvasq()}
-     * to pass its {@code calibrationBuffer[0..calibrationCount-1]} directly.</p>
-     *
-     * @param samples     array of sample vectors (only indices [0, n) are used)
-     * @param n           number of valid vectors in {@code samples}
-     * @param originalDim vector dimensionality
-     * @param seed        FWHT sign-flip seed
-     * @return calibrated {@link SvasqParams}
-     */
-    public static SvasqParams calibrate(float[][] samples, int n,
-                                        int originalDim, long seed) {
-        if (samples == null || n <= 0) {
-            throw new SpectorValidationException(ErrorCode.EMPTY_COLLECTION, "samples");
-        }
-        int useN = Math.min(n, MAX_SAMPLE_SIZE);
-        // Subsample if needed — Fisher-Yates partial shuffle on the indices
-        int[] indices = subsampleIndices(n, useN, seed);
-
-        SvasqFwht fwht = new SvasqFwht(originalDim, seed);
-        int paddedDim  = fwht.paddedDim();
-
-        float[][] rotated = new float[useN][paddedDim];
-        float[] tempVec   = new float[originalDim];
-        for (int i = 0; i < useN; i++) {
-            float[] src = samples[indices[i]];
-            if (src.length != originalDim) {
-                throw new SpectorValidationException(ErrorCode.DIMENSIONS_MISMATCH, originalDim, src.length);
-            }
-            System.arraycopy(src, 0, tempVec, 0, originalDim);
-            fwht.rotate(tempVec, rotated[i]);
-        }
-        return computeParams(rotated, useN, paddedDim, originalDim, fwht);
-    }
-
-    /**
-     * Convenience overload using {@link SvasqParams#DEFAULT_SEED}.
-     */
-    public static SvasqParams calibrate(float[][] samples, int n, int originalDim) {
-        return calibrate(samples, n, originalDim, SvasqParams.DEFAULT_SEED);
-    }
-
-    /**
-     * Calibrates SVASQ parameters from a <em>flat</em> contiguous float buffer.
-     *
-     * <p>The buffer stores vectors consecutively: vector {@code i} occupies
-     * {@code flatData[i × originalDim .. (i+1) × originalDim - 1]}. This is the
-     * layout used by {@link com.spectrayan.spector.index.spectrum.SpectorShard}'s
-     * flat residual store, allowing calibration without copying into {@code float[][]}.</p>
-     *
-     * @param flatData    contiguous float buffer (length ≥ {@code n × originalDim})
-     * @param n           number of vectors stored in {@code flatData}
-     * @param originalDim per-vector dimensionality
-     * @param seed        FWHT sign-flip seed
-     * @return calibrated {@link SvasqParams}
-     */
-    public static SvasqParams calibrate(float[] flatData, int n,
-                                        int originalDim, long seed) {
-        if (flatData == null || n <= 0 || originalDim <= 0) {
-            throw new SpectorValidationException(ErrorCode.EMPTY_COLLECTION, "flatData");
-        }
-        int useN    = Math.min(n, MAX_SAMPLE_SIZE);
-        int[] idxs  = subsampleIndices(n, useN, seed);
-
-        SvasqFwht fwht = new SvasqFwht(originalDim, seed);
-        int paddedDim  = fwht.paddedDim();
-
-        float[][] rotated = new float[useN][paddedDim];
-        float[] tempVec   = new float[originalDim]; // one temp vector, reused per sample
-        for (int i = 0; i < useN; i++) {
-            int base = idxs[i] * originalDim;
-            System.arraycopy(flatData, base, tempVec, 0, originalDim);
-            fwht.rotate(tempVec, rotated[i]);
-        }
-        return computeParams(rotated, useN, paddedDim, originalDim, fwht);
-    }
-
-    /**
-     * Convenience overload using {@link SvasqParams#DEFAULT_SEED}.
-     */
-    public static SvasqParams calibrate(float[] flatData, int n, int originalDim) {
-        return calibrate(flatData, n, originalDim, SvasqParams.DEFAULT_SEED);
-    }
-
-    // ── SVASQ-4 (INT4) calibration API ────────────────────────────────────────
-
-    /**
-     * Calibrates SVASQ-4 (INT4) parameters from a list of sample vectors.
-     *
-     * <p>Produces {@link SvasqParams} with {@link SvasqParams#BIT_WIDTH_4}.
-     * Scales are computed for signed range [-7, 7] with tighter clipping
-     * ({@link #CLIP_SIGMAS_4BIT}) to maximize use of the 15 available levels.</p>
-     *
-     * @param sampleVectors representative sample
-     * @param originalDim   vector dimensionality
-     * @param seed          FWHT sign-flip seed
-     * @return calibrated {@link SvasqParams} with bitWidth=4
-     */
-    public static SvasqParams calibrate4bit(List<float[]> sampleVectors,
-                                            int originalDim, long seed) {
-        if (sampleVectors == null || sampleVectors.isEmpty()) {
-            throw new SpectorValidationException(ErrorCode.EMPTY_COLLECTION, "sampleVectors");
-        }
-        List<float[]> sample = subsampleList(sampleVectors, MAX_SAMPLE_SIZE, seed);
-        int n = sample.size();
-        for (float[] v : sample) {
-            if (v.length != originalDim) {
-                throw new SpectorValidationException(ErrorCode.DIMENSIONS_MISMATCH, originalDim, v.length);
-            }
-        }
-        SvasqFwht fwht  = new SvasqFwht(originalDim, seed);
-        int paddedDim  = fwht.paddedDim();
-
-        float[][] rotated = new float[n][paddedDim];
-        float[] tempVec   = new float[originalDim];
-        for (int i = 0; i < n; i++) {
-            System.arraycopy(sample.get(i), 0, tempVec, 0, originalDim);
-            fwht.rotate(tempVec, rotated[i]);
-        }
-        return computeParams(rotated, n, paddedDim, originalDim, fwht,
-                MAX_LEVEL_INT4, CLIP_SIGMAS_4BIT, SvasqParams.BIT_WIDTH_4);
-    }
-
-    /** Convenience overload using {@link SvasqParams#DEFAULT_SEED}. */
-    public static SvasqParams calibrate4bit(List<float[]> sampleVectors, int originalDim) {
-        return calibrate4bit(sampleVectors, originalDim, SvasqParams.DEFAULT_SEED);
-    }
-
-    /**
-     * Calibrates SVASQ-4 (INT4) parameters from a {@code float[][]} array.
-     *
-     * @param samples     array of sample vectors (only indices [0, n) are used)
-     * @param n           number of valid vectors
-     * @param originalDim vector dimensionality
-     * @param seed        FWHT sign-flip seed
-     * @return calibrated {@link SvasqParams} with bitWidth=4
-     */
-    public static SvasqParams calibrate4bit(float[][] samples, int n,
-                                            int originalDim, long seed) {
-        if (samples == null || n <= 0) {
-            throw new SpectorValidationException(ErrorCode.EMPTY_COLLECTION, "samples");
-        }
-        int useN    = Math.min(n, MAX_SAMPLE_SIZE);
-        int[] idxs  = subsampleIndices(n, useN, seed);
-
-        SvasqFwht fwht  = new SvasqFwht(originalDim, seed);
-        int paddedDim  = fwht.paddedDim();
-
-        float[][] rotated = new float[useN][paddedDim];
-        float[] tempVec   = new float[originalDim];
-        for (int i = 0; i < useN; i++) {
-            float[] src = samples[idxs[i]];
-            if (src.length != originalDim) {
-                throw new SpectorValidationException(ErrorCode.DIMENSIONS_MISMATCH, originalDim, src.length);
-            }
-            System.arraycopy(src, 0, tempVec, 0, originalDim);
-            fwht.rotate(tempVec, rotated[i]);
-        }
-        return computeParams(rotated, useN, paddedDim, originalDim, fwht,
-                MAX_LEVEL_INT4, CLIP_SIGMAS_4BIT, SvasqParams.BIT_WIDTH_4);
-    }
-
-    /** Convenience overload using {@link SvasqParams#DEFAULT_SEED}. */
-    public static SvasqParams calibrate4bit(float[][] samples, int n, int originalDim) {
-        return calibrate4bit(samples, n, originalDim, SvasqParams.DEFAULT_SEED);
-    }
-
-    /**
-     * Calibrates SVASQ-4 parameters from a flat contiguous float buffer.
-     *
-     * @see #calibrate(float[], int, int, long)
-     */
-    public static SvasqParams calibrate4bit(float[] flatData, int n,
-                                            int originalDim, long seed) {
-        if (flatData == null || n <= 0 || originalDim <= 0) {
-            throw new SpectorValidationException(ErrorCode.EMPTY_COLLECTION, "flatData");
-        }
-        int useN    = Math.min(n, MAX_SAMPLE_SIZE);
-        int[] idxs  = subsampleIndices(n, useN, seed);
-
-        SvasqFwht fwht  = new SvasqFwht(originalDim, seed);
-        int paddedDim  = fwht.paddedDim();
-
-        float[][] rotated = new float[useN][paddedDim];
-        float[] tempVec   = new float[originalDim];
-        for (int i = 0; i < useN; i++) {
-            int base = idxs[i] * originalDim;
-            System.arraycopy(flatData, base, tempVec, 0, originalDim);
-            fwht.rotate(tempVec, rotated[i]);
-        }
-        return computeParams(rotated, useN, paddedDim, originalDim, fwht,
-                MAX_LEVEL_INT4, CLIP_SIGMAS_4BIT, SvasqParams.BIT_WIDTH_4);
-    }
-
-    /** Convenience overload using {@link SvasqParams#DEFAULT_SEED}. */
-    public static SvasqParams calibrate4bit(float[] flatData, int n, int originalDim) {
-        return calibrate4bit(flatData, n, originalDim, SvasqParams.DEFAULT_SEED);
-    }
-
-    // ── Core computation (shared by all overloads) ────────────────────────────
-
-    /**
-     * Computes per-dimension percentile-clipped mean + std from pre-rotated samples,
-     * then derives SVASQ scale parameters.
-     *
-     * <p>Delegates to the parameterized overload with INT8 defaults (maxLevel=127, clipSigmas=3.0).</p>
-     */
-    private static SvasqParams computeParams(float[][] rotated, int n, int paddedDim,
-                                             int originalDim, SvasqFwht fwht) {
-        return computeParams(rotated, n, paddedDim, originalDim, fwht,
-                MAX_LEVEL_INT8, CLIP_SIGMAS, SvasqParams.BIT_WIDTH_8);
-    }
-
-    /**
-     * Core scale computation parameterized by quantization range and clipping.
-     *
-     * @param maxLevel   maximum absolute quantization level (127 for INT8, 7 for INT4)
-     * @param clipSigmas number of standard deviations the range covers
-     * @param bitWidth   {@link SvasqParams#BIT_WIDTH_8} or {@link SvasqParams#BIT_WIDTH_4}
-     */
-    private static SvasqParams computeParams(float[][] rotated, int n, int paddedDim,
-                                             int originalDim, SvasqFwht fwht,
-                                             int maxLevel, float clipSigmas, int bitWidth) {
-        float[] means     = new float[paddedDim];
-        float[] scales    = new float[paddedDim];
-        float[] invScales = new float[paddedDim];
-        float[] colBuf    = new float[n];
-
-        for (int j = 0; j < paddedDim; j++) {
-            // Collect column j
-            for (int i = 0; i < n; i++) colBuf[i] = rotated[i][j];
-
-            // Sort in-place — no Arrays.copyOf allocation
-            Arrays.sort(colBuf, 0, n);
-            float lo = colBuf[(int) (CLIP_PERCENTILE * (n - 1))];
-            float hi = colBuf[(int) ((1f - CLIP_PERCENTILE) * (n - 1))];
-
-            // Mean of clipped values (colBuf is now sorted, but sum/count are order-independent)
-            double sum = 0;
-            int cnt = 0;
-            for (int i = 0; i < n; i++) {
-                float v = colBuf[i];
-                if (v >= lo && v <= hi) { sum += v; cnt++; }
-            }
-            if (cnt == 0) {
-                means[j]     = 0f;
-                scales[j]    = 1f / maxLevel;
-                invScales[j] = (float) maxLevel;
-                continue;
-            }
-            means[j] = (float) (sum / cnt);
-
-            // Std dev of clipped values (Bessel-corrected)
-            double var = 0;
-            for (int i = 0; i < n; i++) {
-                float v = colBuf[i];
-                if (v >= lo && v <= hi) {
-                    double d = v - means[j];
-                    var += d * d;
-                }
-            }
-            float std = (float) Math.sqrt(var / Math.max(1, cnt - 1));
-            std = Math.max(std, MIN_STD);
-
-            scales[j]    = clipSigmas * std / maxLevel;
-            invScales[j] = maxLevel / (clipSigmas * std);
-        }
-
-        return new SvasqParams(originalDim, paddedDim, means, scales, invScales, fwht, bitWidth);
-    }
-
-    // ── Sampling helpers ──────────────────────────────────────────────────────
-
-    /**
-     * Returns up to {@code maxSize} elements from the list, drawn uniformly at random.
-     */
-    private static List<float[]> subsampleList(List<float[]> list, int maxSize, long seed) {
-        if (list.size() <= maxSize) return list;
-        Random rng = new Random(seed);
-        float[][] arr = list.toArray(new float[0][]);
-        for (int i = 0; i < maxSize; i++) {
-            int j = i + rng.nextInt(arr.length - i);
-            float[] tmp = arr[i]; arr[i] = arr[j]; arr[j] = tmp;
-        }
-        return Arrays.asList(Arrays.copyOf(arr, maxSize));
-    }
-
-    /**
-     * Returns up to {@code maxSize} distinct indices in [0, n), sampled without replacement.
-     * If {@code maxSize >= n}, returns all indices in their natural order.
-     */
-    private static int[] subsampleIndices(int n, int maxSize, long seed) {
-        if (maxSize >= n) {
-            int[] all = new int[n];
-            for (int i = 0; i < n; i++) all[i] = i;
-            return all;
-        }
-        Random rng = new Random(seed);
-        int[] indices = new int[n];
-        for (int i = 0; i < n; i++) indices[i] = i;
-        // Fisher-Yates partial shuffle
-        for (int i = 0; i < maxSize; i++) {
-            int j = i + rng.nextInt(n - i);
-            int tmp = indices[i]; indices[i] = indices[j]; indices[j] = tmp;
-        }
-        return Arrays.copyOf(indices, maxSize);
-    }
-}
\ No newline at end of file
diff --git a/spector-core/src/main/java/com/spectrayan/spector/core/quantization/svasq/SvasqEncoder.java b/spector-core/src/main/java/com/spectrayan/spector/core/quantization/svasq/SvasqEncoder.java
deleted file mode 100644
index dacd6f5..0000000
--- a/spector-core/src/main/java/com/spectrayan/spector/core/quantization/svasq/SvasqEncoder.java
+++ /dev/null
@@ -1,133 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.core.quantization.svasq;
-import com.spectrayan.spector.commons.error.SpectorException;
-
-import java.lang.foreign.MemorySegment;
-import java.lang.foreign.ValueLayout;
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-import com.spectrayan.spector.commons.error.ErrorCode;
-
-/**
- * Encodes float32 vectors into the SVASQ off-heap binary format.
- *
- * <h3>Memory Layout (per vector)</h3>
- * <pre>
- *   ┌─────────────────────┬──────────────────────────────────────────┐
- *   │ float32 exactNormSq │ INT8[paddedDim] signed quantized codes   │
- *   │ (4 bytes, offset 0) │ (paddedDim bytes, offset 4)              │
- *   └─────────────────────┴──────────────────────────────────────────┘
- * </pre>
- *
- * <h3>Encoding Steps</h3>
- * <ol>
- *   <li>Compute {@code exactNormSq = ‖x‖²} on the original float32 vector.</li>
- *   <li>Rotate: sign-flip, FWHT, normalize → {@code x_rot ∈ ℝ^paddedDim}.</li>
- *   <li>Quantize each dimension: {@code zᵢ = clip(round((x_rot_i - μᵢ) × invScaleᵢ), -127, 127)}.</li>
- *   <li>Write the 4-byte norm header and {@code paddedDim} signed byte codes.</li>
- * </ol>
- *
- * <h3>Allocation Budget</h3>
- * <p>The rotate step requires a {@code float[paddedDim]} scratch buffer. This encoder
- * uses a per-instance {@link ThreadLocal} so the buffer is allocated once per thread
- * and reused across all subsequent encode calls — eliminating the hot-path allocation
- * that previously occurred on every {@link #encode(float[], MemorySegment, long)} call.</p>
- *
- * <p>Instances are immutable after construction and safe for concurrent use
- * (each thread gets its own scratch buffer via ThreadLocal).</p>
- */
-public final class SvasqEncoder {
-
-    private final SvasqParams params;
-
-    /**
-     * Per-thread scratch buffer for the FWHT rotate step.
-     * Allocated once per thread on first use; sized to {@code paddedDim}.
-     */
-    private final ThreadLocal<float[]> rotateScratch;
-
-    /**
-     * Creates an encoder backed by the given calibration parameters.
-     *
-     * @param params calibrated SVASQ parameters (non-null)
-     */
-    public SvasqEncoder(SvasqParams params) {
-        if (params == null) throw new SpectorValidationException(ErrorCode.ARGUMENT_NULL, "params");
-        this.params = params;
-        final int paddedDim = params.paddedDim();
-        this.rotateScratch  = ThreadLocal.withInitial(() -> new float[paddedDim]);
-    }
-
-    /**
-     * Encodes a float32 vector, writing the result directly into an off-heap {@link MemorySegment}.
-     *
-     * <p>The segment must have at least {@code offset + bytesPerVector()} bytes available.</p>
-     *
-     * <p>Uses a thread-local scratch buffer for the FWHT rotate step — zero per-call
-     * heap allocations on the hot path.</p>
-     *
-     * @param vector  the float32 input vector (length must equal {@link SvasqParams#originalDim()})
-     * @param segment the off-heap memory segment to write into
-     * @param offset  byte offset within the segment for this vector's header
-     * @throws SpectorValidationException if vector.length ≠ originalDim
-     */
-    public void encode(float[] vector, MemorySegment segment, long offset) {
-        int originalDim  = params.originalDim();
-        int paddedDim    = params.paddedDim();
-        float[] means    = params.means();
-        float[] invScales = params.invScales();
-
-        if (vector.length != originalDim) {
-            throw new SpectorValidationException(ErrorCode.DIMENSIONS_MISMATCH, originalDim, vector.length);
-        }
-
-        // 1. Exact L2 norm squared (pre-rotation; rotation is orthogonal so ‖x‖=‖Rx‖)
-        double normSqAcc = 0.0;
-        for (float v : vector) normSqAcc += (double) v * v;
-        segment.set(ValueLayout.JAVA_FLOAT, offset, (float) normSqAcc);
-
-        // 2. Rotate into thread-local scratch — zero allocation per call
-        float[] rotated = rotateScratch.get();
-        params.fwht().rotate(vector, rotated);
-
-        // 3. Quantize to signed INT8 [-127, 127] and write into segment
-        for (int i = 0; i < paddedDim; i++) {
-            int q = Math.round((rotated[i] - means[i]) * invScales[i]);
-            // Clamp to [-127, 127] — symmetric range avoids INT8_MIN=-128 asymmetry
-            q = q < -127 ? -127 : (q > 127 ? 127 : q);
-            segment.set(ValueLayout.JAVA_BYTE, offset + 4L + i, (byte) q);
-        }
-    }
-
-    /**
-     * Returns the number of bytes per encoded vector:
-     * {@code 4 (float32 norm header) + paddedDim (signed INT8 codes)}.
-     *
-     * @return bytes per vector
-     */
-    public int bytesPerVector() {
-        return params.bytesPerVector();
-    }
-
-    /**
-     * Returns the calibration parameters backing this encoder.
-     *
-     * @return SVASQ params
-     */
-    public SvasqParams params() {
-        return params;
-    }
-}
\ No newline at end of file
diff --git a/spector-core/src/main/java/com/spectrayan/spector/core/quantization/svasq/SvasqFwht.java b/spector-core/src/main/java/com/spectrayan/spector/core/quantization/svasq/SvasqFwht.java
deleted file mode 100644
index de95849..0000000
--- a/spector-core/src/main/java/com/spectrayan/spector/core/quantization/svasq/SvasqFwht.java
+++ /dev/null
@@ -1,194 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.core.quantization.svasq;
-import com.spectrayan.spector.commons.error.SpectorException;
-
-import java.util.Arrays;
-import java.util.Random;
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-import com.spectrayan.spector.commons.error.ErrorCode;
-
-/**
- * Fast Walsh-Hadamard Transform (FWHT) with random sign flip for variance isotropization.
- *
- * <p>Applies the following pipeline to an input vector of {@code originalDim} floats:</p>
- * <ol>
- *   <li>Zero-pad to {@link #paddedDim()} (next power-of-two ≥ originalDim).</li>
- *   <li>Element-wise multiply by a fixed ±1 sign array (pseudo-random, seeded).</li>
- *   <li>In-place iterative Walsh-Hadamard butterfly transform — O(N log N) additions, zero multiplications.</li>
- *   <li>Normalize by {@code 1/√N} so the transform is orthogonal (preserves L2 norm).</li>
- * </ol>
- *
- * <p>The combined transform is an orthogonal linear map, meaning:</p>
- * <ul>
- *   <li>‖rotate(v)‖ = ‖v‖  (exact, up to float32 rounding)</li>
- *   <li>⟨rotate(a), rotate(b)⟩ ≈ ⟨a, b⟩  (inner products preserved)</li>
- *   <li>The random sign flip ensures the WHT basis is randomized, providing
- *       isotropization guarantees equivalent to a random orthogonal rotation.</li>
- * </ul>
- *
- * <p>Instances are immutable after construction and safe for concurrent use.</p>
- */
-public final class SvasqFwht {
-
-    private final int originalDim;
-    private final int paddedDim;
-    private final float[] signFlip;   // ±1f per padded dimension, fixed at construction
-    private final float normFactor;   // 1 / sqrt(paddedDim)
-
-    /**
-     * Constructs a FWHT rotator for vectors of the given dimensionality.
-     *
-     * @param originalDim the actual vector dimensionality (e.g. 768)
-     * @param seed        random seed for the sign flip array; use a fixed constant
-     *                    (e.g. {@code 42L}) for reproducibility across restarts
-     */
-    public SvasqFwht(int originalDim, long seed) {
-        if (originalDim < 1) throw new SpectorValidationException(ErrorCode.DIMENSIONS_INVALID, 0);
-        this.originalDim = originalDim;
-        this.paddedDim = nextPowerOfTwo(originalDim);
-        this.normFactor = (float) (1.0 / Math.sqrt(paddedDim));
-
-        Random rng = new Random(seed);
-        this.signFlip = new float[paddedDim];
-        for (int i = 0; i < paddedDim; i++) {
-            signFlip[i] = rng.nextBoolean() ? 1f : -1f;
-        }
-    }
-
-    /**
-     * Rotates a vector, returning a new {@code float[paddedDim]} array.
-     *
-     * <p>The input {@code src} must have exactly {@code originalDim} elements.
-     * The output is zero-padded, sign-flipped, WHT-transformed, and normalized.</p>
-     *
-     * @param src the input vector (length must equal {@link #originalDim()})
-     * @return rotated vector of length {@link #paddedDim()}
-     * @throws SpectorValidationException if src.length ≠ originalDim
-     */
-    public float[] rotate(float[] src) {
-        if (src.length != originalDim) {
-            throw new SpectorValidationException(ErrorCode.DIMENSIONS_MISMATCH, originalDim, src.length);
-        }
-        float[] dst = new float[paddedDim]; // zero-filled by JVM
-        rotate(src, dst);
-        return dst;
-    }
-
-    /**
-     * Rotates a vector into a pre-allocated buffer (zero-copy variant).
-     *
-     * <p>The destination {@code dst} must have length ≥ {@link #paddedDim()}.
-     * Any existing content beyond {@code originalDim} is treated as zero (padding).</p>
-     *
-     * @param src the input vector (length must equal {@link #originalDim()})
-     * @param dst the output buffer (length must equal {@link #paddedDim()})
-     * @throws SpectorValidationException if src.length ≠ originalDim or dst.length ≠ paddedDim
-     */
-    public void rotate(float[] src, float[] dst) {
-        if (src.length != originalDim) {
-            throw new SpectorValidationException(ErrorCode.DIMENSIONS_MISMATCH, originalDim, src.length);
-        }
-        if (dst.length != paddedDim) {
-            throw new SpectorValidationException(ErrorCode.DIMENSIONS_MISMATCH, paddedDim, dst.length);
-        }
-
-        // 1. Copy src into dst, zero-pad the rest
-        System.arraycopy(src, 0, dst, 0, originalDim);
-        Arrays.fill(dst, originalDim, paddedDim, 0f);
-
-        // 2. Apply random sign flip
-        for (int i = 0; i < paddedDim; i++) {
-            dst[i] *= signFlip[i];
-        }
-
-        // 3. In-place Walsh-Hadamard butterfly transform
-        applyFwht(dst);
-
-        // 4. Normalize: multiply by 1/sqrt(paddedDim) — makes transform orthogonal
-        for (int i = 0; i < paddedDim; i++) {
-            dst[i] *= normFactor;
-        }
-    }
-
-    /**
-     * The original (unpadded) vector dimensionality passed to the constructor.
-     *
-     * @return original dimension count
-     */
-    public int originalDim() {
-        return originalDim;
-    }
-
-    /**
-     * The padded dimensionality used internally (next power-of-two ≥ originalDim).
-     *
-     * <p>Encoded vectors are {@link #paddedDim()} bytes long (one signed INT8 per padded dim),
-     * plus a 4-byte float32 exact-norm header.</p>
-     *
-     * @return padded dimension count
-     */
-    public int paddedDim() {
-        return paddedDim;
-    }
-
-    /**
-     * Returns a copy of the sign-flip array for serialization / inspection.
-     *
-     * @return ±1f array of length {@link #paddedDim()}
-     */
-    public float[] signFlip() {
-        return Arrays.copyOf(signFlip, paddedDim);
-    }
-
-    // ── Internal ─────────────────────────────────────────────────────────────
-
-    /**
-     * In-place iterative Walsh-Hadamard Transform.
-     *
-     * <p>The standard Cooley-Tukey-style butterfly decomposition:
-     * for each stride {@code h}, process pairs (data[j], data[j+h]) simultaneously.
-     * Requires exactly {@code N log₂ N} additions and zero multiplications.</p>
-     *
-     * @param data array of length equal to a power of two (guaranteed by caller)
-     */
-    public static void applyFwht(float[] data) {
-        int n = data.length;
-        for (int h = 1; h < n; h <<= 1) {
-            for (int i = 0; i < n; i += h << 1) {
-                for (int j = i; j < i + h; j++) {
-                    float x = data[j];
-                    float y = data[j + h];
-                    data[j]     = x + y;
-                    data[j + h] = x - y;
-                }
-            }
-        }
-    }
-
-    /**
-     * Returns the smallest power of two that is ≥ n.
-     *
-     * @param n positive integer
-     * @return next power of two
-     */
-    public static int nextPowerOfTwo(int n) {
-        if (n <= 1) return 1;
-        int p = 1;
-        while (p < n) p <<= 1;
-        return p;
-    }
-}
\ No newline at end of file
diff --git a/spector-core/src/main/java/com/spectrayan/spector/core/quantization/svasq/SvasqParams.java b/spector-core/src/main/java/com/spectrayan/spector/core/quantization/svasq/SvasqParams.java
deleted file mode 100644
index fac4013..0000000
--- a/spector-core/src/main/java/com/spectrayan/spector/core/quantization/svasq/SvasqParams.java
+++ /dev/null
@@ -1,181 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.core.quantization.svasq;
-import com.spectrayan.spector.commons.error.SpectorException;
-
-import java.util.Arrays;
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-import com.spectrayan.spector.commons.error.ErrorCode;
-
-/**
- * Immutable calibration parameters for the SVASQ quantizer.
- *
- * <p>Produced by {@link SvasqCalibrator#calibrate} from a representative sample corpus.
- * Contains all parameters needed for encoding vectors and preparing query states.</p>
- *
- * <h3>Parameter Semantics</h3>
- * <p>All arrays are indexed over the <em>padded</em> dimension (length = {@link #paddedDim()}),
- * i.e. over the FWHT-rotated space. Statistics for padded dimensions beyond the original
- * dimension are near-zero (the FWHT distributes zero-padded values uniformly).</p>
- *
- * <ul>
- *   <li>{@link #means()} — per-dimension mean in rotated space (μᵢ)</li>
- *   <li>{@link #scales()} — per-dimension dequantization scale (σᵢ = clipSigmas·σᵢ/127)</li>
- *   <li>{@link #invScales()} — per-dimension quantization scale (1/σᵢ, precomputed for encode speed)</li>
- * </ul>
- *
- * <p>Instances are immutable and safe for concurrent use.</p>
- */
-public final class SvasqParams {
-
-    /** Number of ±1 sign-flip seed to use when no explicit seed is provided. */
-    public static final long DEFAULT_SEED = 42L;
-
-    /** Standard SVASQ bit width — signed INT8 [-127, 127], 1 byte per dimension. */
-    public static final int BIT_WIDTH_8 = 8;
-
-    /** Half-precision SVASQ bit width — offset-encoded INT4 [0, 14], nibble-packed. */
-    public static final int BIT_WIDTH_4 = 4;
-
-    private final int originalDim;
-    private final int paddedDim;
-    private final int bitWidth;       // 8 (SVASQ-8) or 4 (SVASQ-4)
-    private final float[] means;      // μᵢ per rotated dim  [paddedDim]
-    private final float[] scales;     // scaleᵢ per rotated dim  [paddedDim]
-    private final float[] invScales;  // invScaleᵢ per rotated dim  [paddedDim]
-    private final SvasqFwht fwht;
-
-    /**
-     * Package-private constructor for SVASQ-8 (INT8) — backward-compatible.
-     *
-     * <p>Created exclusively by {@link SvasqCalibrator}. Defaults to
-     * {@link #BIT_WIDTH_8} (signed INT8).</p>
-     */
-    SvasqParams(int originalDim, int paddedDim,
-               float[] means, float[] scales, float[] invScales,
-               SvasqFwht fwht) {
-        this(originalDim, paddedDim, means, scales, invScales, fwht, BIT_WIDTH_8);
-    }
-
-    /**
-     * Package-private constructor with explicit bit width.
-     *
-     * @param bitWidth {@link #BIT_WIDTH_8} for signed INT8 or {@link #BIT_WIDTH_4} for offset INT4
-     */
-    SvasqParams(int originalDim, int paddedDim,
-               float[] means, float[] scales, float[] invScales,
-               SvasqFwht fwht, int bitWidth) {
-        if (bitWidth != BIT_WIDTH_8 && bitWidth != BIT_WIDTH_4) {
-            throw new SpectorValidationException(ErrorCode.BIT_WIDTH_INVALID, "4, 8", bitWidth);
-        }
-        this.originalDim = originalDim;
-        this.paddedDim   = paddedDim;
-        this.bitWidth    = bitWidth;
-        this.means       = means;
-        this.scales      = scales;
-        this.invScales   = invScales;
-        this.fwht        = fwht;
-    }
-
-    /**
-     * The original (unpadded) vector dimensionality.
-     *
-     * @return original dimension count
-     */
-    public int originalDim() { return originalDim; }
-
-    /**
-     * The FWHT-padded dimension (next power-of-two ≥ originalDim).
-     *
-     * @return padded dimension
-     */
-    public int paddedDim() { return paddedDim; }
-
-    /**
-     * The quantization bit width: 8 for SVASQ-8 (INT8), 4 for SVASQ-4 (INT4).
-     *
-     * @return bit width (4 or 8)
-     */
-    public int bitWidth() { return bitWidth; }
-
-    /**
-     * Per-dimension means in the rotated space (μᵢ).
-     *
-     * <p><strong>Do not modify the returned array.</strong></p>
-     *
-     * @return means array of length {@link #paddedDim()}
-     */
-    public float[] means() { return means; }
-
-    /**
-     * Per-dimension dequantization scales (scaleᵢ = clipSigmas·σᵢ/127).
-     *
-     * <p>Used in query preparation: {@code q̃ᵢ = q_rot_i × scaleᵢ}.<br>
-     * <strong>Do not modify the returned array.</strong></p>
-     *
-     * @return scales array of length {@link #paddedDim()}
-     */
-    public float[] scales() { return scales; }
-
-    /**
-     * Per-dimension quantization inverse-scales (invScaleᵢ = 127/(clipSigmas·σᵢ)).
-     *
-     * <p>Used in encoding: {@code zᵢ = round((x_rot_i - μᵢ) × invScaleᵢ)}.<br>
-     * Precomputed to avoid division in the encode hot path.<br>
-     * <strong>Do not modify the returned array.</strong></p>
-     *
-     * @return invScales array of length {@link #paddedDim()}
-     */
-    public float[] invScales() { return invScales; }
-
-    /**
-     * The FWHT rotator configured with this calibration's seed.
-     *
-     * @return FWHT instance
-     */
-    public SvasqFwht fwht() { return fwht; }
-
-    /**
-     * Returns the number of bytes required to store one encoded vector in a MemorySegment.
-     *
-     * <ul>
-     *   <li>SVASQ-8: {@code 4 (float32 norm) + paddedDim (1 byte per dim)}</li>
-     *   <li>SVASQ-4: {@code 4 (float32 norm) + paddedDim/2 (nibble-packed, 2 dims per byte)}</li>
-     * </ul>
-     *
-     * @return bytes per vector
-     */
-    public int bytesPerVector() {
-        int codeBytes = (bitWidth == BIT_WIDTH_4) ? paddedDim / 2 : paddedDim;
-        return 4 + codeBytes;
-    }
-
-    /**
-     * Returns the number of bytes used to store the quantized codes (excluding the norm header).
-     *
-     * @return code bytes per vector
-     */
-    public int codeBytesPerVector() {
-        return (bitWidth == BIT_WIDTH_4) ? paddedDim / 2 : paddedDim;
-    }
-
-    @Override
-    public String toString() {
-        return String.format(
-                "SvasqParams{originalDim=%d, paddedDim=%d, bitWidth=%d, bytesPerVector=%d}",
-                originalDim, paddedDim, bitWidth, bytesPerVector());
-    }
-}
\ No newline at end of file
diff --git a/spector-core/src/main/java/com/spectrayan/spector/core/quantization/svasq/SvasqQueryPrep.java b/spector-core/src/main/java/com/spectrayan/spector/core/quantization/svasq/SvasqQueryPrep.java
deleted file mode 100644
index 7c373e9..0000000
--- a/spector-core/src/main/java/com/spectrayan/spector/core/quantization/svasq/SvasqQueryPrep.java
+++ /dev/null
@@ -1,141 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.core.quantization.svasq;
-import com.spectrayan.spector.commons.error.SpectorException;
-
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-import com.spectrayan.spector.commons.error.ErrorCode;
-
-/**
- * Prepares a {@link SvasqQueryState} from a raw float32 query vector.
- *
- * <p>Call {@link #prepare(float[])} exactly <em>once per query</em> before the
- * HNSW/IVF graph traversal loop. The resulting {@link SvasqQueryState} is then
- * passed to {@link SvasqSimdKernel} for every candidate distance evaluation.</p>
- *
- * <h3>Preparation Steps</h3>
- * <ol>
- *   <li>Compute exact query norm: {@code qNormSq = ‖q‖²} (on original vector).</li>
- *   <li>Rotate: {@code q_rot = FWHT(signFlip(q_padded)) / √paddedDim}.</li>
- *   <li>For each dimension {@code i}:
- *     <ul>
- *       <li>{@code q̃ᵢ = q_rot_i × scaleᵢ}  (pre-scale for FMA kernel)</li>
- *       <li>Accumulate {@code C(q) += q_rot_i × μᵢ}  (mean correction)</li>
- *     </ul>
- *   </li>
- *   <li>Compute {@code constL2Q = qNormSq - 2 × C(q)}  (query-side L2 constant).</li>
- * </ol>
- *
- * <h3>Allocation Budget</h3>
- * <p>Uses a per-instance {@link ThreadLocal} holding two {@code float[paddedDim]} arrays:
- * {@code qRot} (intermediate rotate output) and {@code qTilde} (scaled query for the
- * SIMD kernel). Both are allocated once per thread on first use and reused across
- * all subsequent calls, eliminating the per-query allocation that previously occurred.</p>
- *
- * <h3>Contract: SvasqQueryState Lifetime</h3>
- * <p>The returned {@link SvasqQueryState} holds a direct reference to the thread-local
- * {@code qTilde} buffer. It must <em>not</em> be stored beyond the current search call —
- * reuse of the buffer by a subsequent {@link #prepare} call on the same thread would
- * silently corrupt the stale state. In practice, the state is always consumed within
- * the HNSW search and discarded before the method returns, making this safe.</p>
- *
- * <p>Instances are immutable after construction and safe for concurrent use
- * (each thread has its own scratch buffers via ThreadLocal).</p>
- */
-public final class SvasqQueryPrep {
-
-    private final SvasqParams params;
-
-    /**
-     * Per-thread scratch: [0] = qRot (paddedDim), [1] = qTilde (paddedDim).
-     * The qTilde array is directly referenced by the returned SvasqQueryState.
-     */
-    private final ThreadLocal<float[][]> queryScratch;
-
-    /**
-     * Creates a query preparer backed by the given calibration parameters.
-     *
-     * @param params calibrated SVASQ parameters (non-null)
-     */
-    public SvasqQueryPrep(SvasqParams params) {
-        if (params == null) throw new SpectorValidationException(ErrorCode.ARGUMENT_NULL, "params");
-        this.params = params;
-        final int paddedDim = params.paddedDim();
-        this.queryScratch   = ThreadLocal.withInitial(() -> new float[][] {
-                new float[paddedDim],   // [0] qRot
-                new float[paddedDim]    // [1] qTilde — referenced by SvasqQueryState
-        });
-    }
-
-    /**
-     * Prepares a {@link SvasqQueryState} from a float32 query vector.
-     *
-     * <p>Uses thread-local scratch buffers for both the rotate step and the scaled
-     * query vector — zero per-call heap allocations on the hot path.</p>
-     *
-     * <p><b>Lifetime contract:</b> the returned state references thread-local storage
-     * and must not be stored beyond the current search call.</p>
-     *
-     * @param query the float32 query vector (length must equal {@code params.originalDim()})
-     * @return an immutable-by-contract {@link SvasqQueryState} ready for {@link SvasqSimdKernel}
-     * @throws SpectorValidationException if query.length ≠ originalDim
-     */
-    public SvasqQueryState prepare(float[] query) {
-        int originalDim = params.originalDim();
-        int paddedDim   = params.paddedDim();
-        float[] means   = params.means();
-        float[] scales  = params.scales();
-
-        if (query.length != originalDim) {
-            throw new SpectorValidationException(ErrorCode.DIMENSIONS_MISMATCH, originalDim, query.length);
-        }
-
-        // 1. Exact query norm squared (double accumulator for precision)
-        double qNormSqAcc = 0.0;
-        for (float v : query) qNormSqAcc += (double) v * v;
-        float qNormSq = (float) qNormSqAcc;
-
-        // 2. Rotate query into thread-local qRot — zero allocation
-        float[][] scratch = queryScratch.get();
-        float[] qRot   = scratch[0];
-        float[] qTilde = scratch[1];
-        params.fwht().rotate(query, qRot);
-
-        // 3. Fill qTilde and accumulate C(q) = Σ q_rot_i × μᵢ
-        double cQ = 0.0;
-        for (int i = 0; i < paddedDim; i++) {
-            qTilde[i] = qRot[i] * scales[i];
-            cQ        += (double) qRot[i] * means[i];
-        }
-
-        // 4. Query-side L2 constant: ‖q‖² - 2·C(q)  ← CORRECT sign
-        float constL2Q  = qNormSq - 2f * (float) cQ;
-        float dotOffset = (float) cQ;
-
-        // qTilde is the thread-local array — referenced (not copied) by SvasqQueryState.
-        // Safe because the state is only used within the current search call.
-        return new SvasqQueryState(qTilde, constL2Q, dotOffset, qNormSq);
-    }
-
-    /**
-     * Returns the calibration parameters backing this query preparer.
-     *
-     * @return SVASQ params
-     */
-    public SvasqParams params() {
-        return params;
-    }
-}
\ No newline at end of file
diff --git a/spector-core/src/main/java/com/spectrayan/spector/core/quantization/svasq/SvasqQueryState.java b/spector-core/src/main/java/com/spectrayan/spector/core/quantization/svasq/SvasqQueryState.java
deleted file mode 100644
index 674eb88..0000000
--- a/spector-core/src/main/java/com/spectrayan/spector/core/quantization/svasq/SvasqQueryState.java
+++ /dev/null
@@ -1,88 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.core.quantization.svasq;
-
-/**
- * Immutable, precomputed query context for SVASQ asymmetric distance computation.
- *
- * <p>Created once per query by {@link SvasqQueryPrep#prepare} and then reused for every
- * candidate distance evaluation during HNSW/IVF graph traversal. Doing this once per
- * query rather than per candidate is the core efficiency win of the asymmetric approach.</p>
- *
- * <h3>Contents</h3>
- * <ul>
- *   <li><strong>qTilde</strong> ({@code q̃ᵢ = q_rot_i × scaleᵢ}) — the pre-scaled query
- *       coefficients. The SIMD hot loop computes {@code Σ q̃ᵢ × zᵢ} directly.</li>
- *   <li><strong>constL2Q</strong> ({@code ‖q‖² - 2·C(q)}) — the query-side L2 constant.
- *       The full L2 distance expands to:
- *       {@code L2 = exactNormSq + constL2Q - 2 × dot(qTilde, z)}.
- *       Sign: positive when C(q) is negative (typical for zero-mean embeddings).</li>
- *   <li><strong>dotOffset</strong> ({@code C(q) = Σ q_rot_i × μᵢ}) — the query-side
- *       mean correction, stored separately so callers can reconstruct the approximate
- *       inner product as {@code dot(qTilde, z) + dotOffset}.</li>
- * </ul>
- *
- * <p>Instances are immutable and safe for concurrent use across virtual threads.</p>
- */
-public final class SvasqQueryState {
-
-    private final float[] qTilde;    // q̃ᵢ = q_rot_i × scaleᵢ  [paddedDim]
-    private final float constL2Q;    // ‖q‖² - 2·C(q)  (query-side L2 constant)
-    private final float dotOffset;   // C(q) = Σ q_rot_i × μᵢ
-    private final float qNormSq;     // ‖q‖² (stored for diagnostics)
-
-    SvasqQueryState(float[] qTilde, float constL2Q, float dotOffset, float qNormSq) {
-        this.qTilde    = qTilde;
-        this.constL2Q  = constL2Q;
-        this.dotOffset = dotOffset;
-        this.qNormSq   = qNormSq;
-    }
-
-    /**
-     * Pre-scaled query vector ({@code q̃ᵢ = q_rot_i × scaleᵢ}).
-     *
-     * <p><strong>Do not modify the returned array</strong> — it is shared across calls.</p>
-     *
-     * @return qTilde array of length {@code paddedDim}
-     */
-    public float[] qTilde() { return qTilde; }
-
-    /**
-     * Query-side L2 constant: {@code ‖q‖² - 2·C(q)}.
-     *
-     * <p>The full approximate L2 distance formula is:
-     * {@code L2 ≈ exactNormSq + constL2Q - 2 × Σ(q̃ᵢ × zᵢ)}</p>
-     *
-     * @return query-side L2 constant
-     */
-    public float constL2Q() { return constL2Q; }
-
-    /**
-     * Mean-correction offset for inner product: {@code C(q) = Σ q_rot_i × μᵢ}.
-     *
-     * <p>Approximate inner product is: {@code Σ(q̃ᵢ × zᵢ) + dotOffset()}</p>
-     *
-     * @return dot product offset
-     */
-    public float dotOffset() { return dotOffset; }
-
-    /**
-     * Exact query L2 norm squared: {@code ‖q‖²}.
-     *
-     * @return query norm squared
-     */
-    public float qNormSq() { return qNormSq; }
-}
diff --git a/spector-core/src/main/java/com/spectrayan/spector/core/quantization/svasq/SvasqSimdKernel.java b/spector-core/src/main/java/com/spectrayan/spector/core/quantization/svasq/SvasqSimdKernel.java
deleted file mode 100644
index f65f3bb..0000000
--- a/spector-core/src/main/java/com/spectrayan/spector/core/quantization/svasq/SvasqSimdKernel.java
+++ /dev/null
@@ -1,228 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.core.quantization.svasq;
-
-import com.spectrayan.spector.core.simd.SimdCapability;
-
-import jdk.incubator.vector.ByteVector;
-import jdk.incubator.vector.FloatVector;
-import jdk.incubator.vector.VectorOperators;
-import jdk.incubator.vector.VectorShape;
-import jdk.incubator.vector.VectorSpecies;
-
-import java.lang.foreign.MemorySegment;
-import java.lang.foreign.ValueLayout;
-import java.nio.ByteOrder;
-
-/**
- * SIMD-accelerated SVASQ distance kernel using Java Panama Vector API.
- *
- * <h3>The Hot Loop (L2 Distance)</h3>
- * <pre>
- *   For each pair of {@code vecLen} blocks:
- *     z0 = castShape(loadBytes(segment, offset + i))       // INT8 → float32 block 0
- *     z1 = castShape(loadBytes(segment, offset + i + vl))  // INT8 → float32 block 1
- *     acc0 += z0 × qTilde[i]                               // FMA block 0
- *     acc1 += z1 × qTilde[i + vl]                          // FMA block 1 (ILP)
- *   dot = reduceLanes(acc0 + acc1)
- *   L2  = exactNormSq + constL2Q - 2 × dot
- * </pre>
- *
- * <h3>2× Loop Unrolling</h3>
- * <p>The inner loop processes two SIMD blocks per iteration instead of one.
- * This exposes instruction-level parallelism (ILP): while the CPU is doing the
- * FMA for block 0, it can simultaneously load/widen block 1. Typical gain:
- * 10–20% throughput on L2-resident data at D≥256.</p>
- *
- * <p>If {@code paddedDim / vecLen} is odd (i.e., there is one leftover block),
- * the residual block is handled by the cleanup loop. Since {@code paddedDim} is
- * always a power-of-two and {@code vecLen} is always a power-of-two, the only
- * case where the cleanup fires is when {@code paddedDim == vecLen} (e.g., AVX-512
- * with 16 lanes and paddedDim=16), which is extremely rare and still handled correctly.</p>
- *
- * <h3>Key Implementation Decisions</h3>
- * <ul>
- *   <li><strong>Species sizing:</strong> {@code B_SPECIES} has the same lane count as
- *       {@code F_SPECIES} (e.g., 8 bytes for AVX2's 8 floats). This avoids the
- *       4× throughput loss from using {@code SPECIES_256} bytes with 256-bit floats.</li>
- *   <li><strong>FMA:</strong> {@code zFloat.fma(qVec, acc)} explicitly requests a
- *       fused-multiply-add, avoiding the {@code add(mul())} pattern.</li>
- *   <li><strong>No tail loop:</strong> {@code paddedDim % vecLen == 0} is always true
- *       (both are powers-of-two), so the cleanup loop body never executes unless
- *       {@code paddedDim == vecLen}.</li>
- *   <li><strong>{@code reduceLanes} outside the loop:</strong> horizontal reduction is a
- *       single call after all FMA iterations, not per-iteration.</li>
- * </ul>
- *
- * <h3>Signed INT8 Widening</h3>
- * <p>{@code ByteVector.castShape(F_SPECIES, 0)} performs a <em>signed</em> widening
- * from INT8 to INT32 to float32, mapping to {@code vpmovsxbd} + {@code vcvtdq2ps}
- * on AVX2. This is correct for SVASQ's signed [-127, 127] codes.</p>
- *
- * <p>All methods are stateless and safe for concurrent use.</p>
- */
-public final class SvasqSimdKernel {
-
-    // Preferred float species: AVX2 → 8 lanes (256-bit), AVX-512 → 16 lanes (512-bit)
-    private static final VectorSpecies<Float> F_SPECIES = SimdCapability.PREFERRED_SPECIES;
-
-    // Byte species with the SAME lane count as F_SPECIES.
-    // VectorShape.forBitSize(length × 8): 8 lanes → 64-bit, 16 lanes → 128-bit.
-    private static final VectorSpecies<Byte> B_SPECIES =
-            VectorSpecies.of(byte.class,
-                    VectorShape.forBitSize(F_SPECIES.length() * Byte.SIZE));
-
-    /** Number of float lanes in one SIMD register. Pre-cached to avoid method call in hot loop. */
-    private static final int VL = F_SPECIES.length();
-
-    static {
-        assert B_SPECIES.length() == F_SPECIES.length()
-                : "B_SPECIES lanes must equal F_SPECIES lanes";
-    }
-
-    private SvasqSimdKernel() {}
-
-    /**
-     * Computes the approximate squared L2 distance between a prepared query and an
-     * encoded SVASQ vector stored in a {@link MemorySegment}.
-     *
-     * <p>Formula: {@code L2 ≈ exactNormSq + constL2Q - 2 × Σᵢ(q̃ᵢ × zᵢ)}</p>
-     *
-     * <p>Uses a 2× unrolled inner loop to expose instruction-level parallelism.
-     * Reads directly from off-heap memory with zero JVM GC allocations.</p>
-     *
-     * @param segment    off-heap memory segment containing the encoded vector database
-     * @param offset     byte offset of the target vector's 4-byte norm header
-     * @param paddedDim  padded dimensionality (must be power-of-two ≥ {@code F_SPECIES.length()})
-     * @param qs         pre-prepared query state (from {@link SvasqQueryPrep#prepare})
-     * @return approximate squared L2 distance (non-negative)
-     */
-    public static float computeL2(MemorySegment segment, long offset,
-                                   int paddedDim, SvasqQueryState qs) {
-        float exactNormSq = segment.get(ValueLayout.JAVA_FLOAT, offset);
-        long  codeOffset  = offset + 4L;
-        float[] qTilde    = qs.qTilde();
-
-        FloatVector acc0 = FloatVector.zero(F_SPECIES);
-        FloatVector acc1 = FloatVector.zero(F_SPECIES);
-
-        // 2× unrolled SIMD FMA loop — processes 2 × VL dimensions per iteration
-        int i = 0;
-        int limit2 = paddedDim - VL; // last start index of a full 2× pair
-        for (; i < limit2; i += VL * 2) {
-            // Block 0
-            ByteVector  zB0 = ByteVector.fromMemorySegment(
-                    B_SPECIES, segment, codeOffset + i, ByteOrder.nativeOrder());
-            FloatVector zF0 = (FloatVector) zB0.castShape(F_SPECIES, 0);
-            FloatVector qV0 = FloatVector.fromArray(F_SPECIES, qTilde, i);
-            acc0 = zF0.fma(qV0, acc0);
-
-            // Block 1 — overlaps with block 0 in the CPU pipeline (ILP)
-            ByteVector  zB1 = ByteVector.fromMemorySegment(
-                    B_SPECIES, segment, codeOffset + i + VL, ByteOrder.nativeOrder());
-            FloatVector zF1 = (FloatVector) zB1.castShape(F_SPECIES, 0);
-            FloatVector qV1 = FloatVector.fromArray(F_SPECIES, qTilde, i + VL);
-            acc1 = zF1.fma(qV1, acc1);
-        }
-        // Cleanup: 0 or 1 remaining block (only when paddedDim == VL)
-        for (; i < paddedDim; i += VL) {
-            ByteVector  zB = ByteVector.fromMemorySegment(
-                    B_SPECIES, segment, codeOffset + i, ByteOrder.nativeOrder());
-            FloatVector zF = (FloatVector) zB.castShape(F_SPECIES, 0);
-            FloatVector qV = FloatVector.fromArray(F_SPECIES, qTilde, i);
-            acc0 = zF.fma(qV, acc0);
-        }
-
-        // Single horizontal reduction — both accumulators combined before reduce
-        float dot = acc0.add(acc1).reduceLanes(VectorOperators.ADD);
-
-        // L2 = ‖x_exact‖² + (‖q‖² - 2·C(q)) - 2·Σ q̃ᵢzᵢ
-        return exactNormSq + qs.constL2Q() - 2f * dot;
-    }
-
-    /**
-     * Computes the approximate inner product between a prepared query and a SVASQ vector.
-     *
-     * <p>Formula: {@code IP ≈ Σᵢ(q̃ᵢ × zᵢ) + C(q)}</p>
-     *
-     * <p>Uses the same 2× unrolled loop as {@link #computeL2} for symmetric throughput.</p>
-     *
-     * @param segment    off-heap memory segment
-     * @param offset     byte offset of the target vector's norm header (4-byte prefix)
-     * @param paddedDim  padded dimensionality
-     * @param qs         pre-prepared query state
-     * @return approximate inner product (asymmetric: query in float32, corpus in INT8)
-     */
-    public static float computeDot(MemorySegment segment, long offset,
-                                    int paddedDim, SvasqQueryState qs) {
-        long    codeOffset = offset + 4L;
-        float[] qTilde     = qs.qTilde();
-
-        FloatVector acc0 = FloatVector.zero(F_SPECIES);
-        FloatVector acc1 = FloatVector.zero(F_SPECIES);
-
-        int i = 0;
-        int limit2 = paddedDim - VL;
-        for (; i < limit2; i += VL * 2) {
-            ByteVector  zB0 = ByteVector.fromMemorySegment(
-                    B_SPECIES, segment, codeOffset + i, ByteOrder.nativeOrder());
-            FloatVector zF0 = (FloatVector) zB0.castShape(F_SPECIES, 0);
-            acc0 = zF0.fma(FloatVector.fromArray(F_SPECIES, qTilde, i), acc0);
-
-            ByteVector  zB1 = ByteVector.fromMemorySegment(
-                    B_SPECIES, segment, codeOffset + i + VL, ByteOrder.nativeOrder());
-            FloatVector zF1 = (FloatVector) zB1.castShape(F_SPECIES, 0);
-            acc1 = zF1.fma(FloatVector.fromArray(F_SPECIES, qTilde, i + VL), acc1);
-        }
-        for (; i < paddedDim; i += VL) {
-            ByteVector  zB = ByteVector.fromMemorySegment(
-                    B_SPECIES, segment, codeOffset + i, ByteOrder.nativeOrder());
-            FloatVector zF = (FloatVector) zB.castShape(F_SPECIES, 0);
-            acc0 = zF.fma(FloatVector.fromArray(F_SPECIES, qTilde, i), acc0);
-        }
-
-        return acc0.add(acc1).reduceLanes(VectorOperators.ADD) + qs.dotOffset();
-    }
-
-    /**
-     * Returns the number of float lanes in a SIMD register on this platform.
-     *
-     * @return lane count (e.g. 8 for AVX2, 16 for AVX-512)
-     */
-    public static int laneCount() {
-        return VL;
-    }
-
-    /**
-     * Returns the float vector species used by this kernel.
-     *
-     * @return float vector species
-     */
-    public static VectorSpecies<Float> floatSpecies() {
-        return F_SPECIES;
-    }
-
-    /**
-     * Returns the byte vector species used for INT8 loads.
-     *
-     * <p>The byte species always has the same number of lanes as the float species.</p>
-     *
-     * @return byte vector species
-     */
-    public static VectorSpecies<Byte> byteSpecies() {
-        return B_SPECIES;
-    }
-}
diff --git a/spector-core/src/main/java/com/spectrayan/spector/core/simd/RandomRotation.java b/spector-core/src/main/java/com/spectrayan/spector/core/simd/RandomRotation.java
deleted file mode 100644
index be16123..0000000
--- a/spector-core/src/main/java/com/spectrayan/spector/core/simd/RandomRotation.java
+++ /dev/null
@@ -1,313 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.core.simd;
-import com.spectrayan.spector.commons.error.SpectorException;
-
-import java.util.Random;
-
-import jdk.incubator.vector.FloatVector;
-import jdk.incubator.vector.VectorSpecies;
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-import com.spectrayan.spector.commons.error.ErrorCode;
-
-/**
- * Random orthogonal rotation for isotropizing vector distributions.
- *
- * <p>Applies a fixed random orthogonal transform to vectors before quantization.
- * This spreads information across all coordinates, making per-coordinate scalar
- * quantization near-optimal — the key insight behind TurboQuant/PolarQuant.</p>
- *
- * <h3>Performance</h3>
- * <ul>
- *   <li>Matrix stored as a flat 1D array for cache-line-friendly sequential access</li>
- *   <li>Matrix-vector multiply uses Java Vector API (SIMD) for the inner dot product</li>
- *   <li>Inverse rotation uses a pre-transposed copy to avoid cache-hostile column access</li>
- *   <li>Generation (QR decomposition) is O(n³) but only runs once at calibration time</li>
- * </ul>
- *
- * <h3>Why not virtual threads?</h3>
- * <p>The rotation is a pure CPU-bound matrix-vector multiply. For typical embedding
- * dimensions (384–1536), the work is too small to benefit from thread scheduling
- * overhead. SIMD vectorization gives 4–8× speedup without any threading cost.</p>
- *
- * <h3>Properties</h3>
- * <ul>
- *   <li>Preserves L2 norms and inner products (orthogonal transform)</li>
- *   <li>Makes coordinate distributions more uniform/isotropic</li>
- *   <li>Deterministic given a seed (reproducible)</li>
- *   <li>Inverse rotation is just the transpose</li>
- * </ul>
- *
- * <h3>Usage</h3>
- * <pre>{@code
- *   var rotation = RandomRotation.generate(384, 42L);
- *   float[] rotated = rotation.rotate(originalVector);
- *   float[] restored = rotation.inverseRotate(rotated);
- * }</pre>
- */
-public final class RandomRotation {
-
-    private static final VectorSpecies<Float> SPECIES = FloatVector.SPECIES_PREFERRED;
-
-    private final int dimensions;
-    private final float[] matrix;           // row-major flat array [dims * dims]
-    private final float[] matrixTransposed; // column-major (transposed) for inverse rotation
-
-    private RandomRotation(int dimensions, float[] matrix, float[] matrixTransposed) {
-        this.dimensions = dimensions;
-        this.matrix = matrix;
-        this.matrixTransposed = matrixTransposed;
-    }
-
-    /**
-     * Generates a random orthogonal rotation matrix via QR decomposition.
-     *
-     * @param dimensions vector dimensionality
-     * @param seed       random seed for reproducibility
-     * @return a random rotation
-     */
-    public static RandomRotation generate(int dimensions, long seed) {
-        if (dimensions < 1) {
-            throw new SpectorValidationException(ErrorCode.DIMENSIONS_INVALID, 0);
-        }
-
-        Random rng = new Random(seed);
-        float[] flat = qrOrthogonalFlat(dimensions, rng);
-        float[] transposed = transpose(flat, dimensions);
-        return new RandomRotation(dimensions, flat, transposed);
-    }
-
-    /**
-     * Rotates a vector: result = R × vector.
-     *
-     * <p>Uses SIMD-accelerated dot products for each row of the matrix.</p>
-     *
-     * @param vector input vector (length must equal dimensions)
-     * @return rotated vector
-     */
-    public float[] rotate(float[] vector) {
-        if (vector.length != dimensions) {
-            throw new SpectorValidationException(ErrorCode.DIMENSIONS_MISMATCH, dimensions, vector.length);
-        }
-        float[] result = new float[dimensions];
-        matvecSimd(matrix, vector, result, dimensions);
-        return result;
-    }
-
-    /**
-     * Rotates a vector in-place into a destination buffer.
-     *
-     * @param vector input vector
-     * @param result output buffer (must have length >= dimensions)
-     */
-    public void rotate(float[] vector, float[] result) {
-        matvecSimd(matrix, vector, result, dimensions);
-    }
-
-    /**
-     * Inverse rotation: result = R^T × vector.
-     *
-     * <p>Since R is orthogonal, R^{-1} = R^T. Uses the pre-transposed matrix
-     * for cache-friendly row access during the multiply.</p>
-     *
-     * @param vector rotated vector
-     * @return original (unrotated) vector
-     */
-    public float[] inverseRotate(float[] vector) {
-        if (vector.length != dimensions) {
-            throw new SpectorValidationException(ErrorCode.DIMENSIONS_MISMATCH, dimensions, vector.length);
-        }
-        float[] result = new float[dimensions];
-        matvecSimd(matrixTransposed, vector, result, dimensions);
-        return result;
-    }
-
-    /**
-     * Inverse rotation into a destination buffer.
-     *
-     * @param vector rotated vector
-     * @param result output buffer
-     */
-    public void inverseRotate(float[] vector, float[] result) {
-        matvecSimd(matrixTransposed, vector, result, dimensions);
-    }
-
-    /** Returns the dimensionality. */
-    public int dimensions() { return dimensions; }
-
-    /** Returns the rotation matrix as a 2D array (defensive copy). */
-    public float[][] matrix() {
-        float[][] copy = new float[dimensions][dimensions];
-        for (int i = 0; i < dimensions; i++) {
-            System.arraycopy(matrix, i * dimensions, copy[i], 0, dimensions);
-        }
-        return copy;
-    }
-
-    // ─────────────── SIMD Matrix-Vector Multiply ───────────────
-
-    /**
-     * Computes result = M × v using SIMD lanes for the inner dot product.
-     *
-     * <p>For each row i of M, computes dot(M[i], v) using vectorized
-     * fused multiply-add operations. Falls back to scalar for the tail
-     * elements that don't fill a full SIMD lane.</p>
-     */
-    private static void matvecSimd(float[] mat, float[] vec, float[] result, int n) {
-        int laneCount = SPECIES.length();
-        int simdBound = SPECIES.loopBound(n);
-
-        for (int i = 0; i < n; i++) {
-            int rowOffset = i * n;
-            FloatVector acc = FloatVector.zero(SPECIES);
-
-            // SIMD loop: process laneCount elements per iteration
-            int j = 0;
-            for (; j < simdBound; j += laneCount) {
-                FloatVector mv = FloatVector.fromArray(SPECIES, mat, rowOffset + j);
-                FloatVector vv = FloatVector.fromArray(SPECIES, vec, j);
-                acc = mv.fma(vv, acc); // fused multiply-add: acc += mv * vv
-            }
-
-            // Reduce SIMD lanes to scalar
-            float sum = acc.reduceLanes(jdk.incubator.vector.VectorOperators.ADD);
-
-            // Scalar tail
-            for (; j < n; j++) {
-                sum += mat[rowOffset + j] * vec[j];
-            }
-
-            result[i] = sum;
-        }
-    }
-
-    // ─────────────── Matrix Utilities ───────────────
-
-    /**
-     * Transposes a flat row-major matrix.
-     */
-    private static float[] transpose(float[] mat, int n) {
-        float[] t = new float[n * n];
-        for (int i = 0; i < n; i++) {
-            for (int j = 0; j < n; j++) {
-                t[j * n + i] = mat[i * n + j];
-            }
-        }
-        return t;
-    }
-
-    // ─────────────── QR Decomposition (Modified Gram-Schmidt) ───────────────
-
-    /**
-     * Generates a random orthogonal matrix via QR decomposition of a Gaussian random matrix.
-     * Returns a flat row-major array.
-     *
-     * <p>Uses modified Gram-Schmidt for numerical stability. This runs once during
-     * calibration so O(n³) is acceptable.</p>
-     */
-    private static float[] qrOrthogonalFlat(int n, Random rng) {
-        // Generate random Gaussian matrix as columns stored as rows (for cache locality)
-        float[][] cols = new float[n][n];
-        for (int j = 0; j < n; j++) {
-            for (int i = 0; i < n; i++) {
-                cols[j][i] = (float) rng.nextGaussian();
-            }
-        }
-
-        // Modified Gram-Schmidt: orthonormalize columns
-        for (int j = 0; j < n; j++) {
-            // Subtract projections onto previous columns
-            for (int k = 0; k < j; k++) {
-                float dot = simdDot(cols[k], cols[j], n);
-                simdSubScaled(cols[j], cols[k], dot, n);
-            }
-
-            // Normalize
-            float norm = (float) Math.sqrt(simdDot(cols[j], cols[j], n));
-            if (norm < 1e-10f) {
-                // Degenerate — use identity column (extremely unlikely)
-                java.util.Arrays.fill(cols[j], 0.0f);
-                cols[j][j] = 1.0f;
-            } else {
-                float invNorm = 1.0f / norm;
-                simdScale(cols[j], invNorm, n);
-            }
-        }
-
-        // Pack into flat row-major matrix: result[i][j] = cols[j][i]
-        // (transpose from column-storage to row-major)
-        float[] result = new float[n * n];
-        for (int i = 0; i < n; i++) {
-            for (int j = 0; j < n; j++) {
-                result[i * n + j] = cols[j][i];
-            }
-        }
-        return result;
-    }
-
-    /** SIMD dot product of two arrays. */
-    private static float simdDot(float[] a, float[] b, int n) {
-        int laneCount = SPECIES.length();
-        int simdBound = SPECIES.loopBound(n);
-        FloatVector acc = FloatVector.zero(SPECIES);
-
-        int i = 0;
-        for (; i < simdBound; i += laneCount) {
-            FloatVector va = FloatVector.fromArray(SPECIES, a, i);
-            FloatVector vb = FloatVector.fromArray(SPECIES, b, i);
-            acc = va.fma(vb, acc);
-        }
-
-        float sum = acc.reduceLanes(jdk.incubator.vector.VectorOperators.ADD);
-        for (; i < n; i++) {
-            sum += a[i] * b[i];
-        }
-        return sum;
-    }
-
-    /** SIMD: a[i] -= scale * b[i] */
-    private static void simdSubScaled(float[] a, float[] b, float scale, int n) {
-        int laneCount = SPECIES.length();
-        int simdBound = SPECIES.loopBound(n);
-        FloatVector sv = FloatVector.broadcast(SPECIES, scale);
-
-        int i = 0;
-        for (; i < simdBound; i += laneCount) {
-            FloatVector va = FloatVector.fromArray(SPECIES, a, i);
-            FloatVector vb = FloatVector.fromArray(SPECIES, b, i);
-            va.sub(vb.mul(sv)).intoArray(a, i);
-        }
-        for (; i < n; i++) {
-            a[i] -= scale * b[i];
-        }
-    }
-
-    /** SIMD: a[i] *= scale */
-    private static void simdScale(float[] a, float scale, int n) {
-        int laneCount = SPECIES.length();
-        int simdBound = SPECIES.loopBound(n);
-        FloatVector sv = FloatVector.broadcast(SPECIES, scale);
-
-        int i = 0;
-        for (; i < simdBound; i += laneCount) {
-            FloatVector va = FloatVector.fromArray(SPECIES, a, i);
-            va.mul(sv).intoArray(a, i);
-        }
-        for (; i < n; i++) {
-            a[i] *= scale;
-        }
-    }
-}
\ No newline at end of file
diff --git a/spector-core/src/main/java/com/spectrayan/spector/core/similarity/PackedDotProduct.java b/spector-core/src/main/java/com/spectrayan/spector/core/similarity/PackedDotProduct.java
deleted file mode 100644
index 0daadaf..0000000
--- a/spector-core/src/main/java/com/spectrayan/spector/core/similarity/PackedDotProduct.java
+++ /dev/null
@@ -1,317 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.core.similarity;
-
-import com.spectrayan.spector.core.simd.SimdCapability;
-
-import jdk.incubator.vector.FloatVector;
-import jdk.incubator.vector.VectorOperators;
-import jdk.incubator.vector.VectorSpecies;
-
-import java.lang.foreign.MemorySegment;
-import java.lang.foreign.ValueLayout;
-
-/**
- * SIMD-accelerated dot product computation on nibble-packed (INT4) and crumb-packed (INT2)
- * quantized vectors stored in an off-heap {@link MemorySegment}.
- *
- * <h3>Zero-Copy Design</h3>
- * <p>All {@code computeInt4} and {@code computeInt2} overloads that accept a
- * {@link MemorySegment} read directly from off-heap memory without any intermediate
- * {@code byte[]} allocation. This is the correct Panama API usage: the segment
- * is the authoritative store, and compute kernels operate on it in-place.</p>
- *
- * <h3>GC-Free Hot Path</h3>
- * <p>The previous {@code byte[]}-based SIMD path allocated:</p>
- * <ul>
- *   <li>{@code float[] docValues = new float[laneCount]} inside the SIMD loop
- *       — O(D/laneCount) heap allocations per call</li>
- *   <li>{@code float[] products = new float[dimensions]}
- *       — 1 heap allocation per call</li>
- * </ul>
- * <p>The new segment-based path allocates <strong>zero objects</strong> in the hot loop.
- * A single {@code float[laneCount]} scratch buffer is pre-allocated as a local variable
- * outside the loop and reused across SIMD iterations.</p>
- *
- * <h3>INT4 (Nibble Packing)</h3>
- * <pre>
- *   Each byte: [dim_2i (bits 7-4)] [dim_2i+1 (bits 3-0)]
- *   Centroids array: 16 entries (one per quantization level, 0–15)
- * </pre>
- *
- * <h3>INT2 (Crumb Packing)</h3>
- * <pre>
- *   Each byte: [dim_4i (bits 7-6)] [dim_4i+1 (bits 5-4)] [dim_4i+2 (bits 3-2)] [dim_4i+3 (bits 1-0)]
- *   Centroids array: 4 entries (one per quantization level, 0–3)
- * </pre>
- *
- * <h3>Backward Compatibility</h3>
- * <p>Legacy {@code byte[]}-based overloads are kept for callers that still use heap arrays.
- * These delegate to the segment-based kernels by wrapping via {@link MemorySegment#ofArray}.</p>
- */
-public final class PackedDotProduct {
-
-    private static final boolean SIMD_AVAILABLE;
-    private static final VectorSpecies<Float> SPECIES;
-
-    static {
-        boolean available;
-        VectorSpecies<Float> species = null;
-        try {
-            species = SimdCapability.PREFERRED_SPECIES;
-            FloatVector.zero(species);
-            available = true;
-        } catch (Throwable t) {
-            available = false;
-        }
-        SIMD_AVAILABLE = available;
-        SPECIES = species;
-    }
-
-    private PackedDotProduct() {}
-
-    // ─────────────── Primary API: zero-copy MemorySegment overloads ───────────────
-
-    /**
-     * Computes dot product between a float32 query and a nibble-packed INT4 document vector
-     * stored at {@code offset} within the given off-heap {@link MemorySegment}.
-     *
-     * <p>Reads directly from off-heap memory — zero heap allocation in the hot path.</p>
-     *
-     * @param query      float32 query vector (length ≥ dimensions)
-     * @param segment    off-heap memory segment containing the packed document
-     * @param offset     byte offset of the first packed byte within the segment
-     * @param centroids4 centroid values for each of the 16 quantization levels
-     * @param dimensions number of original vector dimensions
-     * @return dot product value
-     */
-    public static float computeInt4(float[] query, MemorySegment segment, long offset,
-                                     float[] centroids4, int dimensions) {
-        if (SIMD_AVAILABLE) {
-            return computeInt4SimdFromSegment(query, segment, offset, centroids4, dimensions);
-        }
-        return computeInt4ScalarFromSegment(query, segment, offset, centroids4, dimensions);
-    }
-
-    /**
-     * Computes dot product between a float32 query and a crumb-packed INT2 document vector
-     * stored at {@code offset} within the given off-heap {@link MemorySegment}.
-     *
-     * <p>Reads directly from off-heap memory — zero heap allocation in the hot path.</p>
-     *
-     * @param query      float32 query vector (length ≥ dimensions)
-     * @param segment    off-heap memory segment containing the packed document
-     * @param offset     byte offset of the first packed byte within the segment
-     * @param centroids2 centroid values for each of the 4 quantization levels
-     * @param dimensions number of original vector dimensions
-     * @return dot product value
-     */
-    public static float computeInt2(float[] query, MemorySegment segment, long offset,
-                                     float[] centroids2, int dimensions) {
-        if (SIMD_AVAILABLE) {
-            return computeInt2SimdFromSegment(query, segment, offset, centroids2, dimensions);
-        }
-        return computeInt2ScalarFromSegment(query, segment, offset, centroids2, dimensions);
-    }
-
-    // ─────────────── Backward-compat: byte[] overloads (delegate to segment path) ───────────────
-
-    /**
-     * Computes dot product between a float32 query and a nibble-packed INT4 document vector.
-     *
-     * @deprecated Prefer the {@link MemorySegment} overload for zero-copy off-heap access.
-     */
-    @Deprecated
-    public static float computeInt4(float[] query, byte[] packedDoc,
-                                     float[] centroids4, int dimensions) {
-        // Wrap heap array as a read-only segment — no data copy, just a view
-        MemorySegment seg = MemorySegment.ofArray(packedDoc);
-        return computeInt4(query, seg, 0L, centroids4, dimensions);
-    }
-
-    /**
-     * Computes dot product between a float32 query and a crumb-packed INT2 document vector.
-     *
-     * @deprecated Prefer the {@link MemorySegment} overload for zero-copy off-heap access.
-     */
-    @Deprecated
-    public static float computeInt2(float[] query, byte[] packedDoc,
-                                     float[] centroids2, int dimensions) {
-        MemorySegment seg = MemorySegment.ofArray(packedDoc);
-        return computeInt2(query, seg, 0L, centroids2, dimensions);
-    }
-
-    // ─────────────── Scalar fallbacks (segment-based, zero heap alloc) ───────────────
-
-    /**
-     * Scalar INT4 dot product from off-heap segment — zero heap allocation.
-     *
-     * <p>Reads each packed byte directly from the segment. No intermediate array.</p>
-     */
-    public static float computeInt4ScalarFromSegment(float[] query, MemorySegment segment,
-                                                      long offset, float[] centroids4, int dimensions) {
-        float sum = 0.0f;
-        for (int i = 0; i < dimensions; i++) {
-            int byteIndex = i >> 1; // i / 2
-            int packed = segment.get(ValueLayout.JAVA_BYTE, offset + byteIndex) & 0xFF;
-            int level = (i & 1) == 0 ? (packed >> 4) : (packed & 0x0F);
-            sum += query[i] * centroids4[level];
-        }
-        return sum;
-    }
-
-    /**
-     * Scalar INT2 dot product from off-heap segment — zero heap allocation.
-     */
-    public static float computeInt2ScalarFromSegment(float[] query, MemorySegment segment,
-                                                      long offset, float[] centroids2, int dimensions) {
-        float sum = 0.0f;
-        for (int i = 0; i < dimensions; i++) {
-            int byteIndex = i >> 2; // i / 4
-            int packed = segment.get(ValueLayout.JAVA_BYTE, offset + byteIndex) & 0xFF;
-            int shift = 6 - ((i & 3) << 1); // 6 - (i%4)*2
-            int level = (packed >> shift) & 0x03;
-            sum += query[i] * centroids2[level];
-        }
-        return sum;
-    }
-
-    // ─────────────── SIMD kernels (segment-based, GC-free hot loop) ───────────────
-
-    /**
-     * SIMD-accelerated INT4 dot product from off-heap segment.
-     *
-     * <h3>Zero-allocation design</h3>
-     * <p>A single {@code float[laneCount]} scratch buffer is allocated <em>once</em> per call
-     * (stack-equivalent) and reused across all SIMD iterations. There are no per-iteration
-     * allocations. The packed bytes are read directly from the off-heap segment via
-     * {@link MemorySegment#get}.</p>
-     *
-     * <h3>FMA accumulation</h3>
-     * <p>Uses {@link FloatVector#fma} for fused multiply-add and a single
-     * {@link FloatVector#reduceLanes} at the end — one horizontal reduction vs.
-     * one per iteration.</p>
-     */
-    private static float computeInt4SimdFromSegment(float[] query, MemorySegment segment,
-                                                      long offset, float[] centroids4, int dimensions) {
-        int laneCount = SPECIES.length();
-        // Single scratch buffer — allocated once per call, reused across SIMD iterations
-        float[] docValues = new float[laneCount];
-
-        FloatVector acc = FloatVector.zero(SPECIES);
-        int limit = SPECIES.loopBound(dimensions);
-
-        for (int i = 0; i < limit; i += laneCount) {
-            // Unpack laneCount nibbles into docValues[] — read directly from segment
-            for (int j = 0; j < laneCount; j++) {
-                int dim = i + j;
-                int byteIndex = dim >> 1;
-                int packed = segment.get(ValueLayout.JAVA_BYTE, offset + byteIndex) & 0xFF;
-                docValues[j] = centroids4[(dim & 1) == 0 ? (packed >> 4) : (packed & 0x0F)];
-            }
-            FloatVector vQuery = FloatVector.fromArray(SPECIES, query, i);
-            FloatVector vDoc   = FloatVector.fromArray(SPECIES, docValues, 0);
-            // FMA: acc += vQuery * vDoc
-            acc = vQuery.fma(vDoc, acc);
-        }
-
-        // Single horizontal reduction
-        float sum = acc.reduceLanes(VectorOperators.ADD);
-
-        // Scalar tail for remaining dimensions (when dimensions % laneCount != 0)
-        for (int i = limit; i < dimensions; i++) {
-            int byteIndex = i >> 1;
-            int packed = segment.get(ValueLayout.JAVA_BYTE, offset + byteIndex) & 0xFF;
-            int level = (i & 1) == 0 ? (packed >> 4) : (packed & 0x0F);
-            sum += query[i] * centroids4[level];
-        }
-
-        return sum;
-    }
-
-    /**
-     * SIMD-accelerated INT2 dot product from off-heap segment.
-     *
-     * <p>Same zero-allocation design as {@link #computeInt4SimdFromSegment}:
-     * one scratch {@code float[laneCount]} reused per call, bytes read directly
-     * from the off-heap segment, FMA accumulation with single {@code reduceLanes}.</p>
-     */
-    private static float computeInt2SimdFromSegment(float[] query, MemorySegment segment,
-                                                      long offset, float[] centroids2, int dimensions) {
-        int laneCount = SPECIES.length();
-        float[] docValues = new float[laneCount];
-
-        FloatVector acc = FloatVector.zero(SPECIES);
-        int limit = SPECIES.loopBound(dimensions);
-
-        for (int i = 0; i < limit; i += laneCount) {
-            for (int j = 0; j < laneCount; j++) {
-                int dim = i + j;
-                int byteIndex = dim >> 2;
-                int packed = segment.get(ValueLayout.JAVA_BYTE, offset + byteIndex) & 0xFF;
-                int shift = 6 - ((dim & 3) << 1);
-                docValues[j] = centroids2[(packed >> shift) & 0x03];
-            }
-            FloatVector vQuery = FloatVector.fromArray(SPECIES, query, i);
-            FloatVector vDoc   = FloatVector.fromArray(SPECIES, docValues, 0);
-            acc = vQuery.fma(vDoc, acc);
-        }
-
-        float sum = acc.reduceLanes(VectorOperators.ADD);
-
-        for (int i = limit; i < dimensions; i++) {
-            int byteIndex = i >> 2;
-            int packed = segment.get(ValueLayout.JAVA_BYTE, offset + byteIndex) & 0xFF;
-            int shift = 6 - ((i & 3) << 1);
-            sum += query[i] * centroids2[(packed >> shift) & 0x03];
-        }
-
-        return sum;
-    }
-
-    // ─────────────── Legacy scalar byte[] fallbacks ───────────────
-
-    /**
-     * Scalar INT4 dot product from heap byte[]. Identical results to the segment path.
-     *
-     * @deprecated Use the {@link MemorySegment} overload.
-     */
-    @Deprecated
-    public static float computeInt4Scalar(float[] query, byte[] packedDoc,
-                                           float[] centroids4, int dimensions) {
-        return computeInt4ScalarFromSegment(query, MemorySegment.ofArray(packedDoc), 0L, centroids4, dimensions);
-    }
-
-    /**
-     * Scalar INT2 dot product from heap byte[]. Identical results to the segment path.
-     *
-     * @deprecated Use the {@link MemorySegment} overload.
-     */
-    @Deprecated
-    public static float computeInt2Scalar(float[] query, byte[] packedDoc,
-                                           float[] centroids2, int dimensions) {
-        return computeInt2ScalarFromSegment(query, MemorySegment.ofArray(packedDoc), 0L, centroids2, dimensions);
-    }
-
-    /**
-     * Returns whether SIMD acceleration is available for packed dot product computation.
-     *
-     * @return true if Java Vector API is available and usable
-     */
-    public static boolean isSimdAvailable() {
-        return SIMD_AVAILABLE;
-    }
-}
diff --git a/spector-core/src/main/java/com/spectrayan/spector/core/similarity/QuantizedCosineSimilarity.java b/spector-core/src/main/java/com/spectrayan/spector/core/similarity/QuantizedCosineSimilarity.java
deleted file mode 100644
index 374f4f9..0000000
--- a/spector-core/src/main/java/com/spectrayan/spector/core/similarity/QuantizedCosineSimilarity.java
+++ /dev/null
@@ -1,124 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.core.similarity;
-
-import com.spectrayan.spector.core.simd.SimdCapability;
-
-import jdk.incubator.vector.FloatVector;
-import jdk.incubator.vector.VectorOperators;
-import jdk.incubator.vector.VectorSpecies;
-
-import java.lang.foreign.MemorySegment;
-import java.lang.foreign.ValueLayout;
-
-/**
- * SIMD-accelerated asymmetric cosine similarity between a float32 query
- * and a quantized INT8 document vector stored in an off-heap {@link MemorySegment}.
- *
- * <h3>Zero-Copy Design</h3>
- * <p>The primary {@link #compute(float[], MemorySegment, long, float[], float[], int)}
- * overload reads INT8 codes directly from the off-heap segment without any
- * intermediate {@code byte[]} allocation. The query vector remains in float32.</p>
- *
- * <h3>GC-Free Hot Path</h3>
- * <p>Previous implementation allocated {@code float[] dequantized = new float[laneCount]}
- * inside the SIMD loop — O(D/laneCount) heap allocations per call. The new implementation
- * allocates a single {@code float[laneCount]} scratch buffer <em>once per call</em> and
- * reuses it across all SIMD iterations. Zero per-iteration allocations.</p>
- *
- * <h3>Formula</h3>
- * <pre>
- *   cosine(query, dequant(doc)) = dot(q, d') / (‖q‖ × ‖d'‖)
- *   where d'[i] = unsigned(byte[i]) × scale[i] + min[i]
- * </pre>
- */
-public final class QuantizedCosineSimilarity {
-
-    private static final VectorSpecies<Float> SPECIES = SimdCapability.PREFERRED_SPECIES;
-
-    private QuantizedCosineSimilarity() {}
-
-    /**
-     * Computes cosine similarity between a float32 query and a quantized INT8 vector
-     * stored in an off-heap {@link MemorySegment}.
-     *
-     * <p>Zero-copy: reads directly from off-heap memory, no {@code byte[]} intermediate.</p>
-     *
-     * @param query   the float32 query vector
-     * @param segment off-heap segment containing the quantized document
-     * @param offset  byte offset of the first INT8 code within the segment
-     * @param mins    per-dimension minimum values from calibration
-     * @param scales  per-dimension scale values from calibration
-     * @param length  number of dimensions
-     * @return approximate cosine similarity in [-1, 1]
-     */
-    public static float compute(float[] query, MemorySegment segment, long offset,
-                                 float[] mins, float[] scales, int length) {
-        int laneCount = SPECIES.length();
-        // Single scratch buffer — allocated once per call, reused across SIMD iterations
-        float[] scratch = new float[laneCount];
-
-        FloatVector sumDot  = FloatVector.zero(SPECIES);
-        FloatVector sumNormQ = FloatVector.zero(SPECIES);
-        FloatVector sumNormD = FloatVector.zero(SPECIES);
-
-        int limit = SPECIES.loopBound(length);
-        for (int i = 0; i < limit; i += laneCount) {
-            FloatVector vQuery = FloatVector.fromArray(SPECIES, query, i);
-
-            // Dequantize laneCount bytes from off-heap segment into scratch (no heap alloc per iter)
-            for (int j = 0; j < laneCount; j++) {
-                int unsigned = segment.get(ValueLayout.JAVA_BYTE, offset + i + j) & 0xFF;
-                scratch[j] = unsigned * scales[i + j] + mins[i + j];
-            }
-            FloatVector vDoc = FloatVector.fromArray(SPECIES, scratch, 0);
-
-            sumDot  = vQuery.fma(vDoc, sumDot);
-            sumNormQ = vQuery.fma(vQuery, sumNormQ);
-            sumNormD = vDoc.fma(vDoc, sumNormD);
-        }
-
-        // Scalar tail
-        float tailDot = 0, tailNormQ = 0, tailNormD = 0;
-        for (int i = limit; i < length; i++) {
-            int unsigned = segment.get(ValueLayout.JAVA_BYTE, offset + i) & 0xFF;
-            float d = unsigned * scales[i] + mins[i];
-            tailDot  += query[i] * d;
-            tailNormQ += query[i] * query[i];
-            tailNormD += d * d;
-        }
-
-        float dot   = sumDot.reduceLanes(VectorOperators.ADD)  + tailDot;
-        float normQ = sumNormQ.reduceLanes(VectorOperators.ADD) + tailNormQ;
-        float normD = sumNormD.reduceLanes(VectorOperators.ADD) + tailNormD;
-
-        float denom = (float) Math.sqrt((double) normQ * normD);
-        return denom == 0.0f ? 0.0f : dot / denom;
-    }
-
-    /**
-     * Backward-compatible overload: computes cosine similarity from a heap {@code byte[]} array.
-     *
-     * <p>Delegates to the segment-based kernel via {@link MemorySegment#ofArray} — no data copy.</p>
-     *
-     * @deprecated Prefer the {@link MemorySegment} overload for zero-copy off-heap access.
-     */
-    @Deprecated
-    public static float compute(float[] query, byte[] quantized,
-                                 float[] mins, float[] scales, int length) {
-        return compute(query, MemorySegment.ofArray(quantized), 0L, mins, scales, length);
-    }
-}
diff --git a/spector-core/src/main/java/com/spectrayan/spector/core/similarity/QuantizedDotProduct.java b/spector-core/src/main/java/com/spectrayan/spector/core/similarity/QuantizedDotProduct.java
deleted file mode 100644
index dd2fbfe..0000000
--- a/spector-core/src/main/java/com/spectrayan/spector/core/similarity/QuantizedDotProduct.java
+++ /dev/null
@@ -1,127 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.core.similarity;
-import com.spectrayan.spector.commons.error.SpectorException;
-
-import com.spectrayan.spector.core.simd.SimdCapability;
-
-import jdk.incubator.vector.FloatVector;
-import jdk.incubator.vector.VectorOperators;
-import jdk.incubator.vector.VectorSpecies;
-
-import java.lang.foreign.MemorySegment;
-import java.lang.foreign.ValueLayout;
-
-/**
- * SIMD-accelerated asymmetric dot product between a float32 query and a
- * quantized INT8 document vector stored in an off-heap {@link MemorySegment}.
- *
- * <h3>Zero-Copy Design</h3>
- * <p>The primary {@link #compute(float[], MemorySegment, long, float[], float[], int)}
- * overload reads INT8 codes directly from the off-heap segment without any intermediate
- * {@code byte[]} allocation. The query vector remains in full float32 precision.</p>
- *
- * <h3>GC-Free Hot Path</h3>
- * <p>Previous implementation allocated {@code float[] dequantized = new float[laneCount]}
- * inside the SIMD loop — O(D/laneCount) heap allocations per call. The new implementation
- * allocates a single {@code float[laneCount]} scratch buffer <em>once per call</em> and
- * reuses it across all SIMD iterations. Zero per-iteration allocations.</p>
- *
- * <h3>Mathematical Equivalence</h3>
- * <pre>
- *   dot(query, dequant(doc)) = Σ query[i] × (doc_byte[i] × scale[i] + min[i])
- *                             = Σ query[i] × doc_byte[i] × scale[i]
- *                             + Σ query[i] × min[i]
- * </pre>
- */
-public final class QuantizedDotProduct {
-
-    private static final VectorSpecies<Float> SPECIES = SimdCapability.PREFERRED_SPECIES;
-
-    private QuantizedDotProduct() {}
-
-    /**
-     * Computes the dot product between a float32 query and a quantized INT8 vector
-     * stored in an off-heap {@link MemorySegment}.
-     *
-     * <p>Zero-copy: reads directly from off-heap memory, no {@code byte[]} intermediate.</p>
-     *
-     * @param query   the float32 query vector
-     * @param segment off-heap segment containing the quantized document
-     * @param offset  byte offset of the first INT8 code within the segment
-     * @param mins    per-dimension minimum values from calibration
-     * @param scales  per-dimension scale values from calibration
-     * @param length  number of dimensions
-     * @return approximate dot product
-     */
-    public static float compute(float[] query, MemorySegment segment, long offset,
-                                 float[] mins, float[] scales, int length) {
-        int laneCount = SPECIES.length();
-        // Single scratch buffer — allocated once per call, reused across SIMD iterations
-        float[] scratch = new float[laneCount];
-
-        FloatVector sumDot = FloatVector.zero(SPECIES);
-
-        int limit = SPECIES.loopBound(length);
-        for (int i = 0; i < limit; i += laneCount) {
-            FloatVector vQuery = FloatVector.fromArray(SPECIES, query, i);
-
-            // Dequantize laneCount bytes from off-heap segment (no heap alloc per iteration)
-            for (int j = 0; j < laneCount; j++) {
-                int unsigned = segment.get(ValueLayout.JAVA_BYTE, offset + i + j) & 0xFF;
-                scratch[j] = unsigned * scales[i + j] + mins[i + j];
-            }
-            FloatVector vDoc = FloatVector.fromArray(SPECIES, scratch, 0);
-
-            // FMA: acc += query * dequantized_doc
-            sumDot = vQuery.fma(vDoc, sumDot);
-        }
-
-        // Scalar tail
-        float tail = 0.0f;
-        for (int i = limit; i < length; i++) {
-            int unsigned = segment.get(ValueLayout.JAVA_BYTE, offset + i) & 0xFF;
-            tail += query[i] * (unsigned * scales[i] + mins[i]);
-        }
-
-        return sumDot.reduceLanes(VectorOperators.ADD) + tail;
-    }
-
-    /**
-     * Backward-compatible overload: computes dot product from a heap {@code byte[]} array.
-     *
-     * <p>Delegates to the segment-based kernel via {@link MemorySegment#ofArray} — no data copy.</p>
-     *
-     * @deprecated Prefer the {@link MemorySegment} overload for zero-copy off-heap access.
-     */
-    @Deprecated
-    public static float compute(float[] query, byte[] quantized,
-                                 float[] mins, float[] scales, int length) {
-        return compute(query, MemorySegment.ofArray(quantized), 0L, mins, scales, length);
-    }
-
-    /**
-     * Computes dot product using a pre-dequantized float document vector.
-     *
-     * @param query       the float32 query vector
-     * @param dequantized pre-dequantized document vector (float32)
-     * @param length      number of dimensions
-     * @return dot product
-     */
-    public static float computePreDequantized(float[] query, float[] dequantized, int length) {
-        return DotProduct.compute(query, 0, dequantized, 0, length);
-    }
-}
\ No newline at end of file
diff --git a/spector-core/src/main/java/com/spectrayan/spector/core/similarity/QuantizedEuclideanDistance.java b/spector-core/src/main/java/com/spectrayan/spector/core/similarity/QuantizedEuclideanDistance.java
deleted file mode 100644
index 83dff97..0000000
--- a/spector-core/src/main/java/com/spectrayan/spector/core/similarity/QuantizedEuclideanDistance.java
+++ /dev/null
@@ -1,114 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.core.similarity;
-
-import com.spectrayan.spector.core.simd.SimdCapability;
-
-import jdk.incubator.vector.FloatVector;
-import jdk.incubator.vector.VectorOperators;
-import jdk.incubator.vector.VectorSpecies;
-
-import java.lang.foreign.MemorySegment;
-import java.lang.foreign.ValueLayout;
-
-/**
- * SIMD-accelerated asymmetric Euclidean (L2) distance between a float32 query and a
- * quantized INT8 document vector stored in an off-heap {@link MemorySegment}.
- *
- * <h3>Performance: 8–16× Speedup over Scalar</h3>
- * <p>The scalar loop in {@code EUCLIDEAN.computeQuantizedFromSegment} reads one byte
- * at a time (~150 cycles per dimension × 768 dims = ~115K cycles). This SIMD kernel
- * processes {@code laneCount} (8 for AVX2, 16 for AVX-512) dimensions per iteration,
- * reducing the cycle count to ~7K–14K per call.</p>
- *
- * <h3>Zero-Copy Design</h3>
- * <p>Reads INT8 codes directly from the off-heap segment without any intermediate
- * {@code byte[]} allocation. Uses a single {@code float[laneCount]} scratch buffer
- * allocated once per call — zero per-iteration allocations.</p>
- *
- * <h3>Mathematical Operation</h3>
- * <pre>
- *   L2(q, dequant(d)) = sqrt(Σ (q[i] - (d_byte[i] × scale[i] + min[i]))²)
- * </pre>
- */
-public final class QuantizedEuclideanDistance {
-
-    private static final VectorSpecies<Float> SPECIES = SimdCapability.PREFERRED_SPECIES;
-
-    private QuantizedEuclideanDistance() {}
-
-    /**
-     * Computes the Euclidean distance between a float32 query and a quantized INT8 vector
-     * stored in an off-heap {@link MemorySegment}.
-     *
-     * <p>SIMD-accelerated: processes {@code laneCount} dimensions per iteration using
-     * FMA (fused multiply-add) intrinsics for the diff² accumulation.</p>
-     *
-     * @param query   the float32 query vector
-     * @param segment off-heap segment containing the quantized document
-     * @param offset  byte offset of the first INT8 code within the segment
-     * @param mins    per-dimension minimum values from calibration
-     * @param scales  per-dimension scale values from calibration
-     * @param length  number of dimensions
-     * @return Euclidean (L2) distance
-     */
-    public static float compute(float[] query, MemorySegment segment, long offset,
-                                 float[] mins, float[] scales, int length) {
-        int laneCount = SPECIES.length();
-        // Single scratch buffer — allocated once per call, reused across SIMD iterations
-        float[] scratch = new float[laneCount];
-
-        FloatVector sumSq = FloatVector.zero(SPECIES);
-
-        int limit = SPECIES.loopBound(length);
-        for (int i = 0; i < limit; i += laneCount) {
-            FloatVector vQuery = FloatVector.fromArray(SPECIES, query, i);
-
-            // Dequantize laneCount bytes from off-heap (no heap alloc per iteration)
-            for (int j = 0; j < laneCount; j++) {
-                int unsigned = segment.get(ValueLayout.JAVA_BYTE, offset + i + j) & 0xFF;
-                scratch[j] = unsigned * scales[i + j] + mins[i + j];
-            }
-            FloatVector vDoc = FloatVector.fromArray(SPECIES, scratch, 0);
-
-            // diff = query - dequantized; sumSq += diff * diff
-            FloatVector diff = vQuery.sub(vDoc);
-            sumSq = diff.fma(diff, sumSq);
-        }
-
-        // Scalar tail for remaining dimensions
-        float tail = 0.0f;
-        for (int i = limit; i < length; i++) {
-            int unsigned = segment.get(ValueLayout.JAVA_BYTE, offset + i) & 0xFF;
-            float d = unsigned * scales[i] + mins[i];
-            float diff = query[i] - d;
-            tail += diff * diff;
-        }
-
-        return (float) Math.sqrt(sumSq.reduceLanes(VectorOperators.ADD) + tail);
-    }
-
-    /**
-     * Backward-compatible overload: computes L2 from a heap {@code byte[]} array.
-     *
-     * @deprecated Prefer the {@link MemorySegment} overload for zero-copy off-heap access.
-     */
-    @Deprecated
-    public static float compute(float[] query, byte[] quantized,
-                                 float[] mins, float[] scales, int length) {
-        return compute(query, MemorySegment.ofArray(quantized), 0L, mins, scales, length);
-    }
-}
diff --git a/spector-core/src/main/java/com/spectrayan/spector/core/similarity/SimilarityFunction.java b/spector-core/src/main/java/com/spectrayan/spector/core/similarity/SimilarityFunction.java
deleted file mode 100644
index ca8197c..0000000
--- a/spector-core/src/main/java/com/spectrayan/spector/core/similarity/SimilarityFunction.java
+++ /dev/null
@@ -1,320 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.core.similarity;
-import com.spectrayan.spector.commons.error.SpectorException;
-
-import com.spectrayan.spector.core.quantization.svasq.Svasq4QueryState;
-import com.spectrayan.spector.core.quantization.svasq.Svasq4SimdKernel;
-import com.spectrayan.spector.core.quantization.svasq.SvasqQueryState;
-import com.spectrayan.spector.core.quantization.svasq.SvasqSimdKernel;
-
-import java.lang.foreign.MemorySegment;
-import java.lang.foreign.ValueLayout;
-
-/**
- * Enumerates the supported distance/similarity functions.
- *
- * <p>Each variant encapsulates the corresponding SIMD kernel and provides
- * a uniform {@link #compute(float[], float[])} interface for use by indexes
- * and query engines.</p>
- *
- * <h3>Zero-Copy Distance API</h3>
- * <p>All quantized distance methods have primary overloads that accept a
- * {@link MemorySegment} + offset, reading encoded vectors directly from off-heap
- * memory without any intermediate {@code byte[]} allocation:</p>
- * <ul>
- *   <li>{@link #computeQuantizedFromSegment} — INT8 scalar quantization, zero-copy</li>
- *   <li>{@link #computeSvasq} — SVASQ FWHT Panama kernel, zero-copy (always was)</li>
- * </ul>
- * <p>The legacy {@link #computeQuantized(float[], byte[], float[], float[], int)} overloads
- * are deprecated and delegate to the segment-based kernels via
- * {@link MemorySegment#ofArray} without data copying.</p>
- */
-public enum SimilarityFunction {
-
-    /**
-     * Cosine similarity — measures the angle between two vectors.
-     * Result range: [-1, 1]. Higher is more similar.
-     */
-    COSINE {
-        @Override
-        public float compute(float[] a, float[] b) {
-            return CosineSimilarity.compute(a, b);
-        }
-
-        @Override
-        public float compute(float[] a, int aOff, float[] b, int bOff, int len) {
-            return CosineSimilarity.compute(a, aOff, b, bOff, len);
-        }
-
-        @Override
-        public float computeForRanking(float[] a, float[] b) {
-            return CosineSimilarity.compute(a, b);
-        }
-
-        @Override
-        public float computeForRanking(float[] a, int aOff, float[] b, int bOff, int len) {
-            return CosineSimilarity.compute(a, aOff, b, bOff, len);
-        }
-
-        @Override
-        public float computeQuantizedFromSegment(float[] query, MemorySegment segment, long offset,
-                                                  float[] mins, float[] scales, int length) {
-            return QuantizedCosineSimilarity.compute(query, segment, offset, mins, scales, length);
-        }
-
-        @Override
-        @Deprecated
-        public float computeQuantized(float[] query, byte[] quantized,
-                                       float[] mins, float[] scales, int length) {
-            return QuantizedCosineSimilarity.compute(query, quantized, mins, scales, length);
-        }
-
-        @Override
-        public boolean higherIsBetter() {
-            return true;
-        }
-    },
-
-    /**
-     * Dot product — measures the projection of one vector onto another.
-     * Unbounded range. Higher is more similar (for normalized vectors).
-     */
-    DOT_PRODUCT {
-        @Override
-        public float compute(float[] a, float[] b) {
-            return DotProduct.compute(a, b);
-        }
-
-        @Override
-        public float compute(float[] a, int aOff, float[] b, int bOff, int len) {
-            return DotProduct.compute(a, aOff, b, bOff, len);
-        }
-
-        @Override
-        public float computeForRanking(float[] a, float[] b) {
-            return DotProduct.compute(a, b);
-        }
-
-        @Override
-        public float computeForRanking(float[] a, int aOff, float[] b, int bOff, int len) {
-            return DotProduct.compute(a, aOff, b, bOff, len);
-        }
-
-        @Override
-        public float computeQuantizedFromSegment(float[] query, MemorySegment segment, long offset,
-                                                  float[] mins, float[] scales, int length) {
-            return QuantizedDotProduct.compute(query, segment, offset, mins, scales, length);
-        }
-
-        @Override
-        @Deprecated
-        public float computeQuantized(float[] query, byte[] quantized,
-                                       float[] mins, float[] scales, int length) {
-            return QuantizedDotProduct.compute(query, quantized, mins, scales, length);
-        }
-
-        @Override
-        public boolean higherIsBetter() {
-            return true;
-        }
-    },
-
-    /**
-     * Euclidean (L2) distance — measures straight-line distance.
-     * Range: [0, ∞). Lower is more similar.
-     */
-    EUCLIDEAN {
-        @Override
-        public float compute(float[] a, float[] b) {
-            return EuclideanDistance.compute(a, b);
-        }
-
-        @Override
-        public float compute(float[] a, int aOff, float[] b, int bOff, int len) {
-            return EuclideanDistance.compute(a, aOff, b, bOff, len);
-        }
-
-        @Override
-        public float computeForRanking(float[] a, float[] b) {
-            return EuclideanDistance.computeSquared(a, b);
-        }
-
-        @Override
-        public float computeForRanking(float[] a, int aOff, float[] b, int bOff, int len) {
-            return EuclideanDistance.computeSquared(a, aOff, b, bOff, len);
-        }
-
-        @Override
-        public float computeQuantizedFromSegment(float[] query, MemorySegment segment, long offset,
-                                                  float[] mins, float[] scales, int length) {
-            // SIMD-accelerated: processes laneCount dimensions per iteration via FloatVector FMA
-            return QuantizedEuclideanDistance.compute(query, segment, offset, mins, scales, length);
-        }
-
-        @Override
-        @Deprecated
-        public float computeQuantized(float[] query, byte[] quantized,
-                                       float[] mins, float[] scales, int length) {
-            return computeQuantizedFromSegment(
-                    query, MemorySegment.ofArray(quantized), 0L, mins, scales, length);
-        }
-
-        @Override
-        public boolean higherIsBetter() {
-            return false;
-        }
-    };
-
-    /**
-     * Computes the similarity/distance between two float32 vectors.
-     *
-     * @param a first vector
-     * @param b second vector
-     * @return the similarity or distance score
-     */
-    public abstract float compute(float[] a, float[] b);
-
-    /**
-     * Computes the similarity/distance between two vector slices.
-     *
-     * @param a    first vector array
-     * @param aOff offset into a
-     * @param b    second vector array
-     * @param bOff offset into b
-     * @param len  number of elements
-     * @return the similarity or distance score
-     */
-    public abstract float compute(float[] a, int aOff, float[] b, int bOff, int len);
-
-    /**
-     * Computes a score suitable for <em>ranking only</em> (relative ordering).
-     *
-     * <p>For COSINE and DOT_PRODUCT, this is identical to {@link #compute(float[], float[])}.
-     * For EUCLIDEAN, this returns the <em>squared</em> L2 distance (no {@code sqrt}),
-     * which preserves rank ordering while saving ~20 CPU cycles per call.
-     * <strong>Do not expose the result to users as a distance value</strong> — it
-     * is only valid for comparisons.</p>
-     *
-     * @param a first vector
-     * @param b second vector
-     * @return a rank-preserving score (not necessarily the true distance/similarity)
-     */
-    public abstract float computeForRanking(float[] a, float[] b);
-
-    /**
-     * Rank-preserving computation on vector slices.
-     *
-     * @see #computeForRanking(float[], float[])
-     */
-    public abstract float computeForRanking(float[] a, int aOff, float[] b, int bOff, int len);
-
-    /**
-     * Computes asymmetric similarity/distance between a float32 query and a quantized INT8
-     * document vector stored in an off-heap {@link MemorySegment}.
-     *
-     * <p><b>Zero-copy hot path:</b> reads directly from the off-heap segment — no {@code byte[]}
-     * intermediate, no GC pressure. This is the primary API for INT8 HNSW graph traversal.</p>
-     *
-     * @param query   query vector in float32
-     * @param segment off-heap segment containing the encoded document database
-     * @param offset  byte offset of the target vector's first INT8 code within the segment
-     * @param mins    per-dimension minimum values from calibration
-     * @param scales  per-dimension scale values from calibration
-     * @param length  number of dimensions
-     * @return the similarity or distance score
-     */
-    public abstract float computeQuantizedFromSegment(float[] query, MemorySegment segment,
-                                                       long offset, float[] mins, float[] scales,
-                                                       int length);
-
-    /**
-     * Computes asymmetric similarity/distance between a float32 query and a quantized INT8
-     * document vector stored in a heap {@code byte[]} array.
-     *
-     * @deprecated Use {@link #computeQuantizedFromSegment} for zero-copy off-heap access.
-     *             This overload delegates via {@link MemorySegment#ofArray} without data copying.
-     *
-     * @param query     query vector in float32
-     * @param quantized document vector in int8 (unsigned byte)
-     * @param mins      per-dimension minimums from calibration
-     * @param scales    per-dimension scales from calibration
-     * @param length    number of dimensions
-     * @return the similarity or distance score
-     */
-    @Deprecated
-    public abstract float computeQuantized(float[] query, byte[] quantized,
-                                            float[] mins, float[] scales, int length);
-
-    /**
-     * Computes SVASQ-quantized distance using a pre-prepared query context and an
-     * off-heap {@link MemorySegment} storing the encoded vector database.
-     *
-     * <p><b>Zero-copy:</b> reads directly from off-heap memory, zero JVM GC allocations.
-     * This is the primary hot path for SVASQ HNSW graph traversal via the Panama SIMD kernel.</p>
-     *
-     * <ul>
-     *   <li>{@code EUCLIDEAN}: approximate squared L2 distance (lower = more similar)</li>
-     *   <li>{@code DOT_PRODUCT}: approximate inner product (higher = more similar)</li>
-     *   <li>{@code COSINE}: approximate inner product in rotated space (higher = more similar;
-     *       equals cosine similarity for unit-normalized vectors)</li>
-     * </ul>
-     *
-     * @param segment   off-heap memory segment containing the encoded vector database
-     * @param offset    byte offset of the target vector's 4-byte norm header
-     * @param paddedDim FWHT-padded dimension (power-of-two)
-     * @param qs        pre-prepared query state (from {@link com.spectrayan.spector.core.quantization.svasq.SvasqQueryPrep})
-     * @return distance or similarity score appropriate for this function
-     */
-    public float computeSvasq(MemorySegment segment, long offset,
-                              int paddedDim, SvasqQueryState qs) {
-        return switch (this) {
-            case EUCLIDEAN   -> SvasqSimdKernel.computeL2(segment, offset, paddedDim, qs);
-            case DOT_PRODUCT -> SvasqSimdKernel.computeDot(segment, offset, paddedDim, qs);
-            // For cosine, inner product in FWHT-rotated space. Equals cosine for unit vectors.
-            case COSINE      -> SvasqSimdKernel.computeDot(segment, offset, paddedDim, qs);
-        };
-    }
-
-    /**
-     * Computes SVASQ-4 quantized distance using a pre-prepared SVASQ-4 query context and
-     * an off-heap {@link MemorySegment} storing nibble-packed INT4 encoded vectors.
-     *
-     * <p><b>Zero-copy:</b> reads directly from off-heap memory with zero JVM GC allocations.
-     * This is the hot path for SVASQ-4 HNSW graph traversal.</p>
-     *
-     * @param segment  off-heap memory segment containing the encoded vector database
-     * @param offset   byte offset of the target vector's 4-byte norm header
-     * @param halfDim  half of paddedDim (number of nibble-packed code bytes to process)
-     * @param qs       pre-prepared SVASQ-4 query state (from {@link com.spectrayan.spector.core.quantization.svasq.Svasq4QueryPrep})
-     * @return distance or similarity score appropriate for this function
-     */
-    public float computeSvasq4(MemorySegment segment, long offset,
-                               int halfDim, Svasq4QueryState qs) {
-        return switch (this) {
-            case EUCLIDEAN   -> Svasq4SimdKernel.computeL2(segment, offset, halfDim, qs);
-            case DOT_PRODUCT -> Svasq4SimdKernel.computeDot(segment, offset, halfDim, qs);
-            case COSINE      -> Svasq4SimdKernel.computeDot(segment, offset, halfDim, qs);
-        };
-    }
-
-    /**
-     * Whether higher scores indicate greater similarity.
-     *
-     * @return true for similarity metrics (cosine, dot), false for distance metrics (euclidean)
-     */
-    public abstract boolean higherIsBetter();
-}
\ No newline at end of file
diff --git a/spector-core/src/test/java/com/spectrayan/spector/core/CosineSimilarityTest.java b/spector-core/src/test/java/com/spectrayan/spector/core/CosineSimilarityTest.java
index 8e18c6a..dda82a4 100644
--- a/spector-core/src/test/java/com/spectrayan/spector/core/CosineSimilarityTest.java
+++ b/spector-core/src/test/java/com/spectrayan/spector/core/CosineSimilarityTest.java
@@ -1,22 +1,5 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.core;
 
-import com.spectrayan.spector.core.similarity.CosineSimilarity;
-
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.within;
 
diff --git a/spector-core/src/test/java/com/spectrayan/spector/core/CrumbPackerTest.java b/spector-core/src/test/java/com/spectrayan/spector/core/CrumbPackerTest.java
index ee73d19..de5d117 100644
--- a/spector-core/src/test/java/com/spectrayan/spector/core/CrumbPackerTest.java
+++ b/spector-core/src/test/java/com/spectrayan/spector/core/CrumbPackerTest.java
@@ -1,24 +1,5 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.core;
 
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-
-import com.spectrayan.spector.core.quantization.CrumbPacker;
-
 import static org.junit.jupiter.api.Assertions.assertArrayEquals;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
@@ -143,28 +124,28 @@ void packedSize_nonMultipleOfFour() {
     @Test
     void pack_negativeLengthThrows() {
         int[] values = {1, 2, 3};
-        assertThrows(SpectorValidationException.class,
+        assertThrows(IllegalArgumentException.class,
                 () -> CrumbPacker.pack(values, -1));
     }
 
     @Test
     void pack_lengthExceedsArrayThrows() {
         int[] values = {1, 2};
-        assertThrows(SpectorValidationException.class,
+        assertThrows(IllegalArgumentException.class,
                 () -> CrumbPacker.pack(values, 5));
     }
 
     @Test
     void unpack_negativeOriginalLengthThrows() {
         byte[] packed = {0x00};
-        assertThrows(SpectorValidationException.class,
+        assertThrows(IllegalArgumentException.class,
                 () -> CrumbPacker.unpack(packed, -1));
     }
 
     @Test
     void unpack_originalLengthExceedsCapacityThrows() {
         byte[] packed = {0x00};
-        assertThrows(SpectorValidationException.class,
+        assertThrows(IllegalArgumentException.class,
                 () -> CrumbPacker.unpack(packed, 5));
     }
 
diff --git a/spector-core/src/test/java/com/spectrayan/spector/core/DotProductTest.java b/spector-core/src/test/java/com/spectrayan/spector/core/DotProductTest.java
index 7a2a32d..4960419 100644
--- a/spector-core/src/test/java/com/spectrayan/spector/core/DotProductTest.java
+++ b/spector-core/src/test/java/com/spectrayan/spector/core/DotProductTest.java
@@ -1,24 +1,5 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.core;
 
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-
-import com.spectrayan.spector.core.similarity.DotProduct;
-
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import static org.assertj.core.api.Assertions.within;
@@ -85,7 +66,7 @@ void invalidInputThrows() {
         float[] a = {1f, 2f};
         float[] b = {3f};
         assertThatThrownBy(() -> DotProduct.compute(a, 0, b, 0, 2))
-                .isInstanceOf(SpectorValidationException.class);
+                .isInstanceOf(IllegalArgumentException.class);
     }
 
     // ── Scalar reference implementation ──
diff --git a/spector-core/src/test/java/com/spectrayan/spector/core/EuclideanDistanceTest.java b/spector-core/src/test/java/com/spectrayan/spector/core/EuclideanDistanceTest.java
index 5524d8f..a17fa5d 100644
--- a/spector-core/src/test/java/com/spectrayan/spector/core/EuclideanDistanceTest.java
+++ b/spector-core/src/test/java/com/spectrayan/spector/core/EuclideanDistanceTest.java
@@ -1,22 +1,5 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.core;
 
-import com.spectrayan.spector.core.similarity.EuclideanDistance;
-
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.within;
 
diff --git a/spector-core/src/test/java/com/spectrayan/spector/core/NibblePackerTest.java b/spector-core/src/test/java/com/spectrayan/spector/core/NibblePackerTest.java
index 1b7265f..1e434d9 100644
--- a/spector-core/src/test/java/com/spectrayan/spector/core/NibblePackerTest.java
+++ b/spector-core/src/test/java/com/spectrayan/spector/core/NibblePackerTest.java
@@ -1,24 +1,5 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.core;
 
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-
-import com.spectrayan.spector.core.quantization.NibblePacker;
-
 import static org.junit.jupiter.api.Assertions.assertArrayEquals;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
@@ -130,14 +111,14 @@ void packedSize(int dimensions, int expectedBytes) {
     @Test
     void pack_invalidLength_throwsException() {
         int[] values = {1, 2, 3};
-        assertThrows(SpectorValidationException.class, () -> NibblePacker.pack(values, -1));
-        assertThrows(SpectorValidationException.class, () -> NibblePacker.pack(values, 4));
+        assertThrows(IllegalArgumentException.class, () -> NibblePacker.pack(values, -1));
+        assertThrows(IllegalArgumentException.class, () -> NibblePacker.pack(values, 4));
     }
 
     @Test
     void unpack_invalidOriginalLength_throwsException() {
         byte[] packed = {(byte) 0xAB};
-        assertThrows(SpectorValidationException.class, () -> NibblePacker.unpack(packed, -1));
-        assertThrows(SpectorValidationException.class, () -> NibblePacker.unpack(packed, 3));
+        assertThrows(IllegalArgumentException.class, () -> NibblePacker.unpack(packed, -1));
+        assertThrows(IllegalArgumentException.class, () -> NibblePacker.unpack(packed, 3));
     }
 }
diff --git a/spector-core/src/test/java/com/spectrayan/spector/core/NonUniformQuantizerTest.java b/spector-core/src/test/java/com/spectrayan/spector/core/NonUniformQuantizerTest.java
index 0c6382d..6b0596a 100644
--- a/spector-core/src/test/java/com/spectrayan/spector/core/NonUniformQuantizerTest.java
+++ b/spector-core/src/test/java/com/spectrayan/spector/core/NonUniformQuantizerTest.java
@@ -1,24 +1,5 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.core;
 
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-
-import com.spectrayan.spector.core.quantization.NonUniformQuantizer;
-
 import static org.junit.jupiter.api.Assertions.assertArrayEquals;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
@@ -163,13 +144,13 @@ void encode_clampsOutOfRangeValues() {
 
     @Test
     void calibrate_emptySampleThrows() {
-        assertThrows(SpectorValidationException.class,
+        assertThrows(IllegalArgumentException.class,
                 () -> NonUniformQuantizer.calibrate(new float[0][], 4, 16));
     }
 
     @Test
     void calibrate_nullSampleThrows() {
-        assertThrows(SpectorValidationException.class,
+        assertThrows(IllegalArgumentException.class,
                 () -> NonUniformQuantizer.calibrate(null, 4, 16));
     }
 
@@ -178,7 +159,7 @@ void encode_dimensionMismatchThrows() {
         float[][] samples = generateUniformSamples(10, 4, 1);
         NonUniformQuantizer q = NonUniformQuantizer.calibrate(samples, 4, 4);
 
-        assertThrows(SpectorValidationException.class,
+        assertThrows(IllegalArgumentException.class,
                 () -> q.encode(new float[]{1.0f, 2.0f})); // wrong dimensions
     }
 
@@ -187,7 +168,7 @@ void decode_dimensionMismatchThrows() {
         float[][] samples = generateUniformSamples(10, 4, 1);
         NonUniformQuantizer q = NonUniformQuantizer.calibrate(samples, 4, 4);
 
-        assertThrows(SpectorValidationException.class,
+        assertThrows(IllegalArgumentException.class,
                 () -> q.decode(new int[]{0, 1})); // wrong dimensions
     }
 
@@ -198,7 +179,7 @@ void calibrate_dimensionMismatchInSampleThrows() {
                 {1.0f, 2.0f}  // wrong length
         };
 
-        assertThrows(SpectorValidationException.class,
+        assertThrows(IllegalArgumentException.class,
                 () -> NonUniformQuantizer.calibrate(samples, 3, 4));
     }
 
@@ -207,8 +188,8 @@ void boundaries_outOfRangeThrows() {
         float[][] samples = generateUniformSamples(10, 3, 1);
         NonUniformQuantizer q = NonUniformQuantizer.calibrate(samples, 3, 4);
 
-        assertThrows(SpectorValidationException.class, () -> q.boundaries(-1));
-        assertThrows(SpectorValidationException.class, () -> q.boundaries(3));
+        assertThrows(IndexOutOfBoundsException.class, () -> q.boundaries(-1));
+        assertThrows(IndexOutOfBoundsException.class, () -> q.boundaries(3));
     }
 
     @Test
@@ -216,8 +197,8 @@ void centroids_outOfRangeThrows() {
         float[][] samples = generateUniformSamples(10, 3, 1);
         NonUniformQuantizer q = NonUniformQuantizer.calibrate(samples, 3, 4);
 
-        assertThrows(SpectorValidationException.class, () -> q.centroids(-1));
-        assertThrows(SpectorValidationException.class, () -> q.centroids(3));
+        assertThrows(IndexOutOfBoundsException.class, () -> q.centroids(-1));
+        assertThrows(IndexOutOfBoundsException.class, () -> q.centroids(3));
     }
 
     @Test
diff --git a/spector-core/src/test/java/com/spectrayan/spector/core/PackedDotProductTest.java b/spector-core/src/test/java/com/spectrayan/spector/core/PackedDotProductTest.java
index 32656a4..a99ebc9 100644
--- a/spector-core/src/test/java/com/spectrayan/spector/core/PackedDotProductTest.java
+++ b/spector-core/src/test/java/com/spectrayan/spector/core/PackedDotProductTest.java
@@ -1,24 +1,5 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.core;
 
-import com.spectrayan.spector.core.similarity.PackedDotProduct;
-import com.spectrayan.spector.core.quantization.NibblePacker;
-import com.spectrayan.spector.core.quantization.CrumbPacker;
-
 import java.util.Random;
 
 import static org.assertj.core.api.Assertions.assertThat;
@@ -32,17 +13,13 @@
 class PackedDotProductTest {
 
     private static final float TOLERANCE = 1e-6f;
-    /**
-     * Tolerance for SIMD-vs-scalar large dimension comparisons.
-     * FMA accumulation differs from sequential summation only by floating-point rounding order.
-     * FMA is more accurate; we allow 1e-4f relative difference for 384 dimensions.
-     */
-    private static final float SIMD_TOLERANCE = 1e-4f;
 
     @Test
     @DisplayName("SIMD availability should be detected")
     void shouldDetectSimdAvailability() {
+        // Just verify the method doesn't throw; actual value depends on runtime
         boolean available = PackedDotProduct.isSimdAvailable();
+        // On a standard JDK 21+ with --add-modules, this should be true
         assertThat(available).isNotNull();
     }
 
@@ -93,7 +70,7 @@ void int4OddDimensions() {
     }
 
     @Test
-    @DisplayName("INT4: SIMD and scalar produce numerically equivalent results for 384 dimensions")
+    @DisplayName("INT4: SIMD and scalar produce identical results for 384 dimensions")
     void int4SimdEqualsScalarLargeDimension() {
         int dimensions = 384;
         Random rng = new Random(42);
@@ -114,12 +91,10 @@ void int4SimdEqualsScalarLargeDimension() {
         }
         byte[] packedDoc = NibblePacker.pack(levels, levels.length);
 
-        float simdResult   = PackedDotProduct.computeInt4(query, packedDoc, centroids4, dimensions);
+        float simdResult = PackedDotProduct.computeInt4(query, packedDoc, centroids4, dimensions);
         float scalarResult = PackedDotProduct.computeInt4Scalar(query, packedDoc, centroids4, dimensions);
 
-        // FMA accumulation (SIMD) differs from sequential summation (scalar) only by rounding order.
-        // FMA is more numerically accurate; exact bitwise equality is not a correct requirement.
-        assertThat(simdResult).isCloseTo(scalarResult, within(SIMD_TOLERANCE));
+        assertThat(simdResult).isEqualTo(scalarResult);
     }
 
     @Test
@@ -182,7 +157,7 @@ void int2NonMultipleOf4Dimensions() {
     }
 
     @Test
-    @DisplayName("INT2: SIMD and scalar produce numerically equivalent results for 384 dimensions")
+    @DisplayName("INT2: SIMD and scalar produce identical results for 384 dimensions")
     void int2SimdEqualsScalarLargeDimension() {
         int dimensions = 384;
         Random rng = new Random(123);
@@ -203,12 +178,10 @@ void int2SimdEqualsScalarLargeDimension() {
         }
         byte[] packedDoc = CrumbPacker.pack(levels, levels.length);
 
-        float simdResult   = PackedDotProduct.computeInt2(query, packedDoc, centroids2, dimensions);
+        float simdResult = PackedDotProduct.computeInt2(query, packedDoc, centroids2, dimensions);
         float scalarResult = PackedDotProduct.computeInt2Scalar(query, packedDoc, centroids2, dimensions);
 
-        // FMA accumulation (SIMD) differs from sequential summation (scalar) only by rounding order.
-        // FMA is more numerically accurate; exact bitwise equality is not a correct requirement.
-        assertThat(simdResult).isCloseTo(scalarResult, within(SIMD_TOLERANCE));
+        assertThat(simdResult).isEqualTo(scalarResult);
     }
 
     @Test
@@ -276,10 +249,10 @@ void int4ArbitraryDimensionality() {
         }
         byte[] packedDoc = NibblePacker.pack(levels, levels.length);
 
-        float simd   = PackedDotProduct.computeInt4(query, packedDoc, centroids4, dimensions);
+        float simd = PackedDotProduct.computeInt4(query, packedDoc, centroids4, dimensions);
         float scalar = PackedDotProduct.computeInt4Scalar(query, packedDoc, centroids4, dimensions);
 
-        assertThat(simd).isCloseTo(scalar, within(SIMD_TOLERANCE));
+        assertThat(simd).isEqualTo(scalar);
     }
 
     @Test
@@ -304,9 +277,9 @@ void int2ArbitraryDimensionality() {
         }
         byte[] packedDoc = CrumbPacker.pack(levels, levels.length);
 
-        float simd   = PackedDotProduct.computeInt2(query, packedDoc, centroids2, dimensions);
+        float simd = PackedDotProduct.computeInt2(query, packedDoc, centroids2, dimensions);
         float scalar = PackedDotProduct.computeInt2Scalar(query, packedDoc, centroids2, dimensions);
 
-        assertThat(simd).isCloseTo(scalar, within(SIMD_TOLERANCE));
+        assertThat(simd).isEqualTo(scalar);
     }
 }
diff --git a/spector-core/src/test/java/com/spectrayan/spector/core/QuantizationTypeTest.java b/spector-core/src/test/java/com/spectrayan/spector/core/QuantizationTypeTest.java
index 27d6456..7ba00f9 100644
--- a/spector-core/src/test/java/com/spectrayan/spector/core/QuantizationTypeTest.java
+++ b/spector-core/src/test/java/com/spectrayan/spector/core/QuantizationTypeTest.java
@@ -1,27 +1,5 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.core;
 
-import com.spectrayan.spector.core.quantization.QuantizationType;
-
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.CsvSource;
-
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
@@ -34,14 +12,11 @@ class QuantizationTypeTest {
 
     @Test
     void testEnumVariantsExist() {
-        assertEquals(7, QuantizationType.values().length);
+        assertEquals(4, QuantizationType.values().length);
         QuantizationType.valueOf("NONE");
         QuantizationType.valueOf("SCALAR_INT8");
         QuantizationType.valueOf("SCALAR_INT4");
         QuantizationType.valueOf("SCALAR_INT2");
-        QuantizationType.valueOf("TURBO_QUANT");
-        QuantizationType.valueOf("SVASQ");
-        QuantizationType.valueOf("SVASQ_4");
     }
 
     @Test
@@ -90,18 +65,4 @@ void testLevelsForNone() {
         // This is acceptable since levels() is not meaningful for NONE.
         assertEquals(1, QuantizationType.NONE.levels());
     }
-
-    @Test
-    void svasq_bitsPerDimension_is_8() {
-        assertEquals(8, QuantizationType.SVASQ.bitsPerDimension());
-    }
-
-    @Test
-    void svasq_bytesPerVector_throws() {
-        // SVASQ storage size depends on paddedDim = nextPow2(dimensions), not dimensions.
-        // Use SvasqEncoder.bytesPerVector() instead.
-        org.junit.jupiter.api.Assertions.assertThrows(
-                com.spectrayan.spector.commons.error.SpectorValidationException.class,
-                () -> QuantizationType.SVASQ.bytesPerVector(768));
-    }
 }
diff --git a/spector-core/src/test/java/com/spectrayan/spector/core/QuantizedEuclideanDistanceTest.java b/spector-core/src/test/java/com/spectrayan/spector/core/QuantizedEuclideanDistanceTest.java
deleted file mode 100644
index ef78b74..0000000
--- a/spector-core/src/test/java/com/spectrayan/spector/core/QuantizedEuclideanDistanceTest.java
+++ /dev/null
@@ -1,316 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.core;
-
-import com.spectrayan.spector.core.similarity.QuantizedEuclideanDistance;
-import com.spectrayan.spector.core.similarity.SimilarityFunction;
-
-import org.junit.jupiter.api.*;
-import static org.assertj.core.api.Assertions.*;
-
-import java.lang.foreign.Arena;
-import java.lang.foreign.MemorySegment;
-import java.lang.foreign.ValueLayout;
-import java.util.Arrays;
-import java.util.Random;
-
-/**
- * Tests and benchmarks for {@link QuantizedEuclideanDistance} — the SIMD-accelerated
- * INT8 quantized L2 distance kernel (P3 optimization).
- *
- * <p>Verifies correctness against a reference scalar implementation and
- * benchmarks performance at common embedding dimensions (128, 384, 768, 1024).</p>
- */
-@DisplayName("QuantizedEuclideanDistance — SIMD L2 Kernel")
-@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
-class QuantizedEuclideanDistanceTest {
-
-    private static final Random RNG = new Random(42);
-
-    // ══════════════════════════════════════════════════════════════
-    // Correctness: SIMD matches scalar reference
-    // ══════════════════════════════════════════════════════════════
-
-    @Test
-    @Order(1)
-    @DisplayName("SIMD result matches scalar reference for 128-dim")
-    void correctness_128dim() {
-        assertSimdMatchesScalar(128);
-    }
-
-    @Test
-    @Order(2)
-    @DisplayName("SIMD result matches scalar reference for 384-dim")
-    void correctness_384dim() {
-        assertSimdMatchesScalar(384);
-    }
-
-    @Test
-    @Order(3)
-    @DisplayName("SIMD result matches scalar reference for 768-dim (nomic-embed-text)")
-    void correctness_768dim() {
-        assertSimdMatchesScalar(768);
-    }
-
-    @Test
-    @Order(4)
-    @DisplayName("SIMD result matches scalar reference for 1024-dim")
-    void correctness_1024dim() {
-        assertSimdMatchesScalar(1024);
-    }
-
-    @Test
-    @Order(5)
-    @DisplayName("SIMD result matches scalar reference for 7-dim (tail-only)")
-    void correctness_7dim_tailOnly() {
-        assertSimdMatchesScalar(7);
-    }
-
-    @Test
-    @Order(6)
-    @DisplayName("SIMD result matches scalar reference for 1-dim (degenerate)")
-    void correctness_1dim() {
-        assertSimdMatchesScalar(1);
-    }
-
-    @Test
-    @Order(7)
-    @DisplayName("SIMD result matches scalar reference for 17-dim (1 SIMD + tail)")
-    void correctness_17dim() {
-        assertSimdMatchesScalar(17);
-    }
-
-    @Test
-    @Order(8)
-    @DisplayName("Zero vector returns sqrt(sum(mins²))")
-    void zeroVector() {
-        int dims = 32;
-        float[] query = new float[dims];
-        float[] mins = new float[dims];
-        float[] scales = new float[dims];
-        Arrays.fill(mins, -1.0f);
-        Arrays.fill(scales, 1.0f / 127.5f);
-
-        try (Arena arena = Arena.ofConfined()) {
-            MemorySegment seg = arena.allocate(dims, 32);
-            seg.fill((byte) 0);
-
-            float dist = QuantizedEuclideanDistance.compute(query, seg, 0, mins, scales, dims);
-            float expected = scalarEuclidean(query, seg, 0, mins, scales, dims);
-
-            assertThat(dist).isCloseTo(expected, within(0.01f));
-        }
-    }
-
-    @Test
-    @Order(9)
-    @DisplayName("Identical vectors have zero distance")
-    void identicalVectors() {
-        int dims = 64;
-        float[] mins = new float[dims];
-        float[] scales = new float[dims];
-        Arrays.fill(mins, -1.0f);
-        Arrays.fill(scales, 1.0f / 127.5f);
-
-        try (Arena arena = Arena.ofConfined()) {
-            MemorySegment seg = arena.allocate(dims, 32);
-            byte[] quantized = new byte[dims];
-            for (int i = 0; i < dims; i++) {
-                quantized[i] = (byte) RNG.nextInt(256);
-                seg.set(ValueLayout.JAVA_BYTE, i, quantized[i]);
-            }
-
-            // Build query = exact dequantization of the stored vector
-            float[] query = new float[dims];
-            for (int i = 0; i < dims; i++) {
-                query[i] = (quantized[i] & 0xFF) * scales[i] + mins[i];
-            }
-
-            float dist = QuantizedEuclideanDistance.compute(query, seg, 0, mins, scales, dims);
-            assertThat(dist).as("Distance to self should be ~0").isCloseTo(0f, within(0.001f));
-        }
-    }
-
-    @Test
-    @Order(10)
-    @DisplayName("SimilarityFunction.EUCLIDEAN delegates to SIMD kernel")
-    void similarityFunctionDelegates() {
-        int dims = 128;
-        float[] mins = new float[dims];
-        float[] scales = new float[dims];
-        Arrays.fill(mins, -1.0f);
-        Arrays.fill(scales, 1.0f / 127.5f);
-
-        float[] query = randomFloatVector(dims);
-
-        try (Arena arena = Arena.ofConfined()) {
-            MemorySegment seg = arena.allocate(dims, 32);
-            fillRandomBytes(seg, dims);
-
-            float simd = QuantizedEuclideanDistance.compute(query, seg, 0, mins, scales, dims);
-            float via_enum = SimilarityFunction.EUCLIDEAN.computeQuantizedFromSegment(
-                    query, seg, 0, mins, scales, dims);
-
-            assertThat(via_enum).as("Enum should delegate to SIMD kernel")
-                    .isCloseTo(simd, within(0.0001f));
-        }
-    }
-
-    @Test
-    @Order(11)
-    @DisplayName("Byte array overload matches segment overload")
-    void byteArrayOverload() {
-        int dims = 64;
-        float[] mins = new float[dims];
-        float[] scales = new float[dims];
-        Arrays.fill(mins, -1.0f);
-        Arrays.fill(scales, 1.0f / 127.5f);
-
-        float[] query = randomFloatVector(dims);
-        byte[] quantized = new byte[dims];
-        RNG.nextBytes(quantized);
-
-        @SuppressWarnings("deprecation")
-        float fromArray = QuantizedEuclideanDistance.compute(query, quantized, mins, scales, dims);
-
-        try (Arena arena = Arena.ofConfined()) {
-            MemorySegment seg = arena.allocate(dims, 32);
-            MemorySegment.copy(MemorySegment.ofArray(quantized), 0, seg, 0, dims);
-            float fromSegment = QuantizedEuclideanDistance.compute(query, seg, 0, mins, scales, dims);
-
-            assertThat(fromArray).isCloseTo(fromSegment, within(0.0001f));
-        }
-    }
-
-    // ══════════════════════════════════════════════════════════════
-    // Benchmarks: SIMD throughput at various dimensions
-    // ══════════════════════════════════════════════════════════════
-
-    @Test
-    @Order(20)
-    @DisplayName("Benchmark: 50K × 128-dim L2 distance")
-    void benchmark_128dim() {
-        runBenchmark(128, 50_000);
-    }
-
-    @Test
-    @Order(21)
-    @DisplayName("Benchmark: 50K × 384-dim L2 distance")
-    void benchmark_384dim() {
-        runBenchmark(384, 50_000);
-    }
-
-    @Test
-    @Order(22)
-    @DisplayName("Benchmark: 50K × 768-dim L2 distance")
-    void benchmark_768dim() {
-        runBenchmark(768, 50_000);
-    }
-
-    @Test
-    @Order(23)
-    @DisplayName("Benchmark: 10K × 1024-dim L2 distance")
-    void benchmark_1024dim() {
-        runBenchmark(1024, 10_000);
-    }
-
-    // ══════════════════════════════════════════════════════════════
-    // Helpers
-    // ══════════════════════════════════════════════════════════════
-
-    private void assertSimdMatchesScalar(int dims) {
-        float[] mins = new float[dims];
-        float[] scales = new float[dims];
-        Arrays.fill(mins, -1.0f);
-        Arrays.fill(scales, 1.0f / 127.5f);
-
-        float[] query = randomFloatVector(dims);
-
-        try (Arena arena = Arena.ofConfined()) {
-            MemorySegment seg = arena.allocate(dims, 32);
-            fillRandomBytes(seg, dims);
-
-            float simd = QuantizedEuclideanDistance.compute(query, seg, 0, mins, scales, dims);
-            float scalar = scalarEuclidean(query, seg, 0, mins, scales, dims);
-
-            // Allow small floating-point divergence from FMA reordering
-            assertThat(simd).isCloseTo(scalar, within(Math.max(0.01f, scalar * 0.001f)));
-        }
-    }
-
-    private void runBenchmark(int dims, int count) {
-        float[] mins = new float[dims];
-        float[] scales = new float[dims];
-        Arrays.fill(mins, -1.0f);
-        Arrays.fill(scales, 1.0f / 127.5f);
-        float[] query = randomFloatVector(dims);
-
-        try (Arena arena = Arena.ofConfined()) {
-            MemorySegment seg = arena.allocate((long) count * dims, 32);
-            for (int i = 0; i < count * dims; i++) {
-                seg.set(ValueLayout.JAVA_BYTE, i, (byte) RNG.nextInt(256));
-            }
-
-            // Warm up (5 iterations)
-            for (int i = 0; i < Math.min(5, count); i++) {
-                QuantizedEuclideanDistance.compute(query, seg, (long) i * dims, mins, scales, dims);
-            }
-
-            // Benchmark
-            long start = System.nanoTime();
-            float checksum = 0;
-            for (int i = 0; i < count; i++) {
-                checksum += QuantizedEuclideanDistance.compute(query, seg, (long) i * dims, mins, scales, dims);
-            }
-            long elapsed = System.nanoTime() - start;
-
-            double totalMs = elapsed / 1e6;
-            double avgUs = elapsed / 1e3 / count;
-            double throughput = count / (totalMs / 1000);
-
-            System.out.printf("  SIMD L2 %d-dim × %,d: %.1f ms total (%.1f µs/vec, %.0f vec/s, checksum=%.2f)%n",
-                    dims, count, totalMs, avgUs, throughput, checksum);
-
-            // Throughput assertions (conservative for CI)
-            assertThat(totalMs).as("Total time should be reasonable").isLessThan(5_000);
-        }
-    }
-
-    /** Reference scalar implementation for correctness verification. */
-    private static float scalarEuclidean(float[] query, MemorySegment segment, long offset,
-                                          float[] mins, float[] scales, int length) {
-        float sum = 0;
-        for (int i = 0; i < length; i++) {
-            int unsigned = segment.get(ValueLayout.JAVA_BYTE, offset + i) & 0xFF;
-            float d = unsigned * scales[i] + mins[i];
-            float diff = query[i] - d;
-            sum += diff * diff;
-        }
-        return (float) Math.sqrt(sum);
-    }
-
-    private float[] randomFloatVector(int dims) {
-        float[] v = new float[dims];
-        for (int i = 0; i < dims; i++) v[i] = RNG.nextFloat() * 2 - 1;
-        return v;
-    }
-
-    private void fillRandomBytes(MemorySegment seg, int length) {
-        for (int i = 0; i < length; i++) {
-            seg.set(ValueLayout.JAVA_BYTE, i, (byte) RNG.nextInt(256));
-        }
-    }
-}
diff --git a/spector-core/src/test/java/com/spectrayan/spector/core/ScalarQuantizerTest.java b/spector-core/src/test/java/com/spectrayan/spector/core/ScalarQuantizerTest.java
index 8a98e4d..e669926 100644
--- a/spector-core/src/test/java/com/spectrayan/spector/core/ScalarQuantizerTest.java
+++ b/spector-core/src/test/java/com/spectrayan/spector/core/ScalarQuantizerTest.java
@@ -1,26 +1,5 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.core;
 
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-
-import com.spectrayan.spector.core.similarity.CosineSimilarity;
-import com.spectrayan.spector.core.similarity.QuantizedCosineSimilarity;
-import com.spectrayan.spector.core.quantization.ScalarQuantizer;
-
 import org.junit.jupiter.api.Test;
 
 import static org.junit.jupiter.api.Assertions.*;
@@ -106,7 +85,7 @@ void fromBounds_restoresCorrectly() {
 
     @Test
     void emptySampleThrows() {
-        assertThrows(SpectorValidationException.class,
+        assertThrows(IllegalArgumentException.class,
                 () -> ScalarQuantizer.calibrate(new float[0][], 4));
     }
 
diff --git a/spector-core/src/test/java/com/spectrayan/spector/core/SimdCapabilityTest.java b/spector-core/src/test/java/com/spectrayan/spector/core/SimdCapabilityTest.java
index d1efa62..f8ddbf3 100644
--- a/spector-core/src/test/java/com/spectrayan/spector/core/SimdCapabilityTest.java
+++ b/spector-core/src/test/java/com/spectrayan/spector/core/SimdCapabilityTest.java
@@ -1,22 +1,5 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.core;
 
-import com.spectrayan.spector.core.simd.SimdCapability;
-
 import static org.assertj.core.api.Assertions.assertThat;
 
 import org.junit.jupiter.api.Test;
diff --git a/spector-core/src/test/java/com/spectrayan/spector/core/SimilarityFunctionTest.java b/spector-core/src/test/java/com/spectrayan/spector/core/SimilarityFunctionTest.java
index bfb0e66..326b551 100644
--- a/spector-core/src/test/java/com/spectrayan/spector/core/SimilarityFunctionTest.java
+++ b/spector-core/src/test/java/com/spectrayan/spector/core/SimilarityFunctionTest.java
@@ -1,23 +1,5 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.core;
 
-import com.spectrayan.spector.core.similarity.SimilarityFunction;
-import com.spectrayan.spector.core.similarity.VectorOps;
-
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.within;
 
diff --git a/spector-core/src/test/java/com/spectrayan/spector/core/Svasq4KernelTest.java b/spector-core/src/test/java/com/spectrayan/spector/core/Svasq4KernelTest.java
deleted file mode 100644
index b743691..0000000
--- a/spector-core/src/test/java/com/spectrayan/spector/core/Svasq4KernelTest.java
+++ /dev/null
@@ -1,314 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.core;
-
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-
-import com.spectrayan.spector.core.quantization.svasq.*;
-
-import org.junit.jupiter.api.BeforeAll;
-import org.junit.jupiter.api.Test;
-
-import java.lang.foreign.Arena;
-import java.lang.foreign.MemorySegment;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Random;
-
-import static org.junit.jupiter.api.Assertions.*;
-
-/**
- * Tests for SVASQ-4 (INT4 nibble-packed) pipeline: calibration → encode → prepare → distance.
- *
- * <p>Mirrors {@link SvasqKernelTest} but with 4-bit quantization. Expected accuracy is
- * lower than SVASQ-8 (15 levels vs 255) but still usable with oversampling rescore.</p>
- */
-class Svasq4KernelTest {
-
-    private static final long   SEED       = 42L;
-    private static final int    DIM        = 128;
-    private static final int    N_SAMPLES  = 500;
-    // Relaxed tolerances for INT4 — 15 levels vs 255 for INT8
-    private static final float  L2_REL_TOL = 0.15f;  // ≤ 15% average relative L2 error
-    private static final float  DOT_TOL    = 0.15f;  // ≤ 15% average norm-normalized dot error
-
-    private static SvasqParams     params;
-    private static Svasq4Encoder   encoder;
-    private static Svasq4QueryPrep queryPrep;
-    private static List<float[]>  corpus;
-
-    @BeforeAll
-    static void setup() {
-        Random rng = new Random(1L);
-        corpus = new ArrayList<>(N_SAMPLES);
-        for (int i = 0; i < N_SAMPLES; i++) {
-            float[] v = new float[DIM];
-            for (int d = 0; d < DIM; d++) v[d] = (float) rng.nextGaussian();
-            corpus.add(v);
-        }
-        params    = SvasqCalibrator.calibrate4bit(corpus, DIM, SEED);
-        encoder   = new Svasq4Encoder(params);
-        queryPrep = new Svasq4QueryPrep(params);
-    }
-
-    // ── Params validation ─────────────────────────────────────────────────────
-
-    @Test
-    void params_bitWidth_is_4() {
-        assertEquals(SvasqParams.BIT_WIDTH_4, params.bitWidth());
-    }
-
-    @Test
-    void params_bytesPerVector_equals_4_plus_halfPaddedDim() {
-        assertEquals(4 + params.paddedDim() / 2, params.bytesPerVector());
-    }
-
-    @Test
-    void params_codeBytesPerVector_equals_halfPaddedDim() {
-        assertEquals(params.paddedDim() / 2, params.codeBytesPerVector());
-    }
-
-    // ── Encode/Decode round-trip ──────────────────────────────────────────────
-
-    @Test
-    void encodeDecode_roundTrip_withinTolerance() {
-        float[] original = corpus.get(0);
-        int bpv = encoder.bytesPerVector();
-
-        try (Arena arena = Arena.ofConfined()) {
-            MemorySegment seg = arena.allocate(bpv, 8);
-            encoder.encode(original, seg, 0L);
-
-            // Decode returns rotated-space approximation (not original space).
-            // With 15 quantization levels, each dim can be off by up to 1 scale unit.
-            // Verify that the decode produces values in a reasonable range
-            // and that the stored norm header is correct.
-            float[] decoded = encoder.decode(seg, 0L, DIM);
-            assertEquals(DIM, decoded.length);
-
-            // Verify the norm header is correctly stored
-            float storedNorm = seg.get(java.lang.foreign.ValueLayout.JAVA_FLOAT, 0L);
-            float expectedNorm = exactNormSq(original);
-            assertEquals(expectedNorm, storedNorm, expectedNorm * 0.01f + 0.001f,
-                    "Stored norm should match exact ‖x‖²");
-
-            // Verify decoded values are finite and not all zero
-            boolean hasNonZero = false;
-            for (float v : decoded) {
-                assertTrue(Float.isFinite(v), "Decoded value must be finite");
-                if (Math.abs(v) > 1e-6f) hasNonZero = true;
-            }
-            assertTrue(hasNonZero, "Decoded vector should not be all zeros");
-        }
-    }
-
-    // ── L2 distance accuracy ──────────────────────────────────────────────────
-
-    @Test
-    void computeL2_closeToExact_randomPairs() {
-        int halfDim = params.paddedDim() / 2;
-        int bpv     = encoder.bytesPerVector();
-
-        try (Arena arena = Arena.ofConfined()) {
-            MemorySegment segment = arena.allocate((long) N_SAMPLES * bpv, 8);
-            for (int i = 0; i < N_SAMPLES; i++) {
-                encoder.encode(corpus.get(i), segment, (long) i * bpv);
-            }
-
-            Random rng = new Random(2L);
-            double totalRelError = 0;
-            int pairs = 200;
-
-            for (int t = 0; t < pairs; t++) {
-                float[] query = corpus.get(rng.nextInt(N_SAMPLES));
-                int     docIdx = rng.nextInt(N_SAMPLES);
-                float[] doc    = corpus.get(docIdx);
-
-                float exactL2 = exactL2Sq(query, doc);
-                Svasq4QueryState qs = queryPrep.prepare(query);
-                float approxL2 = Svasq4SimdKernel.computeL2(segment, (long) docIdx * bpv, halfDim, qs);
-
-                // L2 distances should be non-negative
-                assertTrue(approxL2 >= -0.5f,
-                        "L2 distance must be ≥ -0.5 (allowing small numerical error), got " + approxL2);
-
-                if (exactL2 > 1e-6f) {
-                    double relError = Math.abs(approxL2 - exactL2) / exactL2;
-                    totalRelError += relError;
-                }
-            }
-
-            double avgRelError = totalRelError / pairs;
-            assertTrue(avgRelError < L2_REL_TOL,
-                    "Average relative L2 error too high: " + avgRelError);
-        }
-    }
-
-    @Test
-    void computeL2_same_vector_is_near_zero() {
-        float[] q   = corpus.get(0);
-        int     bpv = encoder.bytesPerVector();
-
-        try (Arena arena = Arena.ofConfined()) {
-            MemorySegment seg = arena.allocate(bpv, 8);
-            encoder.encode(q, seg, 0L);
-
-            Svasq4QueryState qs = queryPrep.prepare(q);
-            float l2 = Svasq4SimdKernel.computeL2(seg, 0L, params.paddedDim() / 2, qs);
-
-            float normSq = exactNormSq(q);
-            // INT4 is rougher — allow 25% of ‖q‖²
-            assertTrue(l2 < normSq * 0.25f,
-                    "L2(q,q) should be < 25% of ‖q‖², got " + l2 + " norm²=" + normSq);
-        }
-    }
-
-    // ── Dot product accuracy ──────────────────────────────────────────────────
-
-    @Test
-    void computeDot_closeToExact_randomPairs() {
-        int halfDim = params.paddedDim() / 2;
-        int bpv     = encoder.bytesPerVector();
-
-        try (Arena arena = Arena.ofConfined()) {
-            MemorySegment segment = arena.allocate((long) N_SAMPLES * bpv, 8);
-            for (int i = 0; i < N_SAMPLES; i++) {
-                encoder.encode(corpus.get(i), segment, (long) i * bpv);
-            }
-
-            Random rng = new Random(3L);
-            double totalAbsError = 0;
-            double totalNormProd = 0;
-            int pairs = 200;
-
-            for (int t = 0; t < pairs; t++) {
-                float[] query  = corpus.get(rng.nextInt(N_SAMPLES));
-                int     docIdx = rng.nextInt(N_SAMPLES);
-                float[] doc    = corpus.get(docIdx);
-
-                float exactDot  = exactDot(query, doc);
-                Svasq4QueryState qs = queryPrep.prepare(query);
-                float approxDot = Svasq4SimdKernel.computeDot(segment, (long) docIdx * bpv, halfDim, qs);
-
-                float normProd = (float) Math.sqrt(exactNormSq(query) * exactNormSq(doc)) + 1e-9f;
-                totalAbsError += Math.abs(approxDot - exactDot);
-                totalNormProd += normProd;
-            }
-
-            double avgNormError = totalAbsError / totalNormProd;
-            assertTrue(avgNormError < DOT_TOL,
-                    "Average norm-normalized dot error too high: " + avgNormError);
-        }
-    }
-
-    // ── Ranking preservation ──────────────────────────────────────────────────
-
-    @Test
-    void l2_ranking_partially_preserved() {
-        // Top-5 exact should partially overlap with top-15 SVASQ-4 (less strict than SVASQ-8)
-        float[] query = corpus.get(0);
-        int halfDim = params.paddedDim() / 2;
-        int bpv = encoder.bytesPerVector();
-
-        try (Arena arena = Arena.ofConfined()) {
-            MemorySegment segment = arena.allocate((long) N_SAMPLES * bpv, 8);
-            for (int i = 0; i < N_SAMPLES; i++) {
-                encoder.encode(corpus.get(i), segment, (long) i * bpv);
-            }
-
-            // Exact top-5
-            float[] exactL2 = new float[N_SAMPLES];
-            for (int i = 0; i < N_SAMPLES; i++) exactL2[i] = exactL2Sq(query, corpus.get(i));
-            int[] exactTop5 = topK(exactL2, 6, true, 0);
-
-            // SVASQ-4 top-15 (wider window due to lower precision)
-            Svasq4QueryState qs = queryPrep.prepare(query);
-            float[] svasqL2 = new float[N_SAMPLES];
-            for (int i = 0; i < N_SAMPLES; i++) {
-                svasqL2[i] = Svasq4SimdKernel.computeL2(segment, (long) i * bpv, halfDim, qs);
-            }
-            int[] svasqTop15 = topK(svasqL2, 16, true, 0);
-
-            int overlap = 0;
-            for (int e : exactTop5) {
-                for (int v : svasqTop15) if (e == v) { overlap++; break; }
-            }
-            assertTrue(overlap >= 2,
-                    "Expected ≥ 2 of top-5 exact to appear in SVASQ-4 top-15; overlap=" + overlap);
-        }
-    }
-
-    // ── Memory layout ─────────────────────────────────────────────────────────
-
-    @Test
-    void encoder_bytesPerVector_matchesParams() {
-        assertEquals(params.bytesPerVector(), encoder.bytesPerVector());
-    }
-
-    @Test
-    void encoder_rejectsWrongBitWidth() {
-        // SVASQ-8 params should be rejected by Svasq4Encoder
-        SvasqParams int8Params = SvasqCalibrator.calibrate(corpus, DIM, SEED);
-        assertThrows(SpectorValidationException.class, () -> new Svasq4Encoder(int8Params));
-    }
-
-    @Test
-    void queryPrep_rejectsWrongBitWidth() {
-        SvasqParams int8Params = SvasqCalibrator.calibrate(corpus, DIM, SEED);
-        assertThrows(SpectorValidationException.class, () -> new Svasq4QueryPrep(int8Params));
-    }
-
-    // ── Helpers ───────────────────────────────────────────────────────────────
-
-    private static float exactL2Sq(float[] a, float[] b) {
-        double s = 0;
-        for (int i = 0; i < a.length; i++) { double d = a[i] - b[i]; s += d * d; }
-        return (float) s;
-    }
-
-    private static float exactNormSq(float[] v) {
-        double s = 0;
-        for (float x : v) s += (double) x * x;
-        return (float) s;
-    }
-
-    private static float exactDot(float[] a, float[] b) {
-        double s = 0;
-        for (int i = 0; i < a.length; i++) s += (double) a[i] * b[i];
-        return (float) s;
-    }
-
-    /** Returns indices of top-k smallest values, skipping {@code skipIdx}. */
-    private static int[] topK(float[] scores, int k, boolean smallerIsBetter, int skipIdx) {
-        int n = scores.length;
-        int[] indices = new int[k];
-        boolean[] used = new boolean[n];
-        for (int t = 0; t < k; t++) {
-            int best = -1;
-            for (int i = 0; i < n; i++) {
-                if (used[i] || i == skipIdx) continue;
-                if (best == -1) { best = i; continue; }
-                boolean betterThanBest = smallerIsBetter
-                        ? scores[i] < scores[best]
-                        : scores[i] > scores[best];
-                if (betterThanBest) best = i;
-            }
-            indices[t] = best;
-            used[best] = true;
-        }
-        return indices;
-    }
-}
diff --git a/spector-core/src/test/java/com/spectrayan/spector/core/SvasqCalibratorTest.java b/spector-core/src/test/java/com/spectrayan/spector/core/SvasqCalibratorTest.java
deleted file mode 100644
index b229fa1..0000000
--- a/spector-core/src/test/java/com/spectrayan/spector/core/SvasqCalibratorTest.java
+++ /dev/null
@@ -1,197 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.core;
-
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-
-import com.spectrayan.spector.core.quantization.svasq.SvasqCalibrator;
-import com.spectrayan.spector.core.quantization.svasq.SvasqParams;
-import org.junit.jupiter.api.Test;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-import java.util.Random;
-
-import static org.junit.jupiter.api.Assertions.*;
-
-/**
- * Tests for {@link SvasqCalibrator} — calibration correctness and robustness.
- */
-class SvasqCalibratorTest {
-
-    private static final long SEED = 42L;
-
-    // ── Basic calibration ─────────────────────────────────────────────────────
-
-    @Test
-    void calibrate_returns_non_null_params() {
-        List<float[]> samples = gaussian(500, 128, new Random(1L));
-        SvasqParams p = SvasqCalibrator.calibrate(samples, 128, SEED);
-        assertNotNull(p);
-        assertEquals(128, p.originalDim());
-        assertEquals(128, p.paddedDim()); // 128 is already power-of-two
-    }
-
-    @Test
-    void calibrate_768dim_padded_to_1024() {
-        List<float[]> samples = gaussian(500, 768, new Random(1L));
-        SvasqParams p = SvasqCalibrator.calibrate(samples, 768, SEED);
-        assertEquals(768,  p.originalDim());
-        assertEquals(1024, p.paddedDim());
-    }
-
-    @Test
-    void params_arrays_have_paddedDim_length() {
-        int dim = 100;
-        List<float[]> samples = gaussian(200, dim, new Random(2L));
-        SvasqParams p = SvasqCalibrator.calibrate(samples, dim, SEED);
-
-        assertEquals(p.paddedDim(), p.means().length,     "means must have paddedDim elements");
-        assertEquals(p.paddedDim(), p.scales().length,    "scales must have paddedDim elements");
-        assertEquals(p.paddedDim(), p.invScales().length, "invScales must have paddedDim elements");
-    }
-
-    // ── Scale/invScale consistency ─────────────────────────────────────────────
-
-    @Test
-    void scales_and_invScales_are_reciprocal() {
-        List<float[]> samples = gaussian(500, 64, new Random(3L));
-        SvasqParams p = SvasqCalibrator.calibrate(samples, 64, SEED);
-
-        for (int i = 0; i < p.paddedDim(); i++) {
-            float product = p.scales()[i] * p.invScales()[i];
-            assertEquals(1.0f, product, 0.01f,
-                    "scale × invScale must be ≈ 1.0 at dim " + i);
-        }
-    }
-
-    @Test
-    void scales_are_positive() {
-        List<float[]> samples = gaussian(300, 64, new Random(4L));
-        SvasqParams p = SvasqCalibrator.calibrate(samples, 64, SEED);
-
-        for (int i = 0; i < p.paddedDim(); i++) {
-            assertTrue(p.scales()[i] > 0f, "scale must be positive at dim " + i);
-            assertTrue(p.invScales()[i] > 0f, "invScale must be positive at dim " + i);
-        }
-    }
-
-    // ── Outlier resistance ────────────────────────────────────────────────────
-
-    @Test
-    void calibration_robust_to_outliers() {
-        // 499 normal vectors + 1 extreme outlier (50× scale)
-        Random rng = new Random(5L);
-        List<float[]> samples = gaussian(499, 64, rng);
-
-        float[] outlier = new float[64];
-        Arrays.fill(outlier, 50f);
-        samples.add(outlier);
-
-        SvasqParams pWithOutlier = SvasqCalibrator.calibrate(samples, 64, SEED);
-
-        // Calibrate clean sample for comparison
-        List<float[]> cleanSamples = gaussian(500, 64, new Random(5L));
-        SvasqParams pClean = SvasqCalibrator.calibrate(cleanSamples, 64, SEED);
-
-        // The scale from the outlier-polluted set should not be dramatically larger
-        // (if percentile clipping works, scales should be within ~2× of the clean set)
-        double maxScaleRatio = 0;
-        for (int i = 0; i < pClean.paddedDim(); i++) {
-            double ratio = pWithOutlier.scales()[i] / (pClean.scales()[i] + 1e-9f);
-            maxScaleRatio = Math.max(maxScaleRatio, ratio);
-        }
-        assertTrue(maxScaleRatio < 5.0,
-                "Outlier should not inflate scales by more than 5×; max ratio was " + maxScaleRatio);
-    }
-
-    // ── Padded dimensions ─────────────────────────────────────────────────────
-
-    @Test
-    void padded_dims_have_near_zero_mean() {
-        // Original dim = 100, padded to 128; dims [100..127] were zero-padded before FWHT.
-        // After FWHT the energy is spread, but means should be close to zero.
-        List<float[]> samples = gaussian(500, 100, new Random(6L));
-        SvasqParams p = SvasqCalibrator.calibrate(samples, 100, SEED);
-
-        assertEquals(128, p.paddedDim());
-
-        // The padded portion [100..127] should have small means relative to the original dims
-        float maxPaddedMean = 0f;
-        for (int i = 100; i < 128; i++) {
-            maxPaddedMean = Math.max(maxPaddedMean, Math.abs(p.means()[i]));
-        }
-
-        float maxOrigMean = 0f;
-        for (int i = 0; i < 100; i++) {
-            maxOrigMean = Math.max(maxOrigMean, Math.abs(p.means()[i]));
-        }
-
-        // Padded dims should have smaller average mean than original dims
-        // (They may not be strictly zero due to FWHT mixing, but should be smaller)
-        assertTrue(maxPaddedMean <= maxOrigMean * 2 + 0.1f,
-                "Padded dim means should not exceed original dim means; "
-                + "maxPadded=" + maxPaddedMean + " maxOrig=" + maxOrigMean);
-    }
-
-    // ── Edge cases ────────────────────────────────────────────────────────────
-
-    @Test
-    void emptySampleThrows() {
-        assertThrows(SpectorValidationException.class,
-                () -> SvasqCalibrator.calibrate(List.of(), 64, SEED));
-    }
-
-    @Test
-    void wrongDimThrows() {
-        List<float[]> samples = List.of(new float[32], new float[64]);
-        assertThrows(SpectorValidationException.class,
-                () -> SvasqCalibrator.calibrate(samples, 64, SEED));
-    }
-
-    @Test
-    void singleSample_doesNotThrow() {
-        List<float[]> samples = List.of(gaussian(1, 32, new Random(7L)).get(0));
-        assertDoesNotThrow(() -> SvasqCalibrator.calibrate(samples, 32, SEED));
-    }
-
-    @Test
-    void largeCorpus_capped_at_maxSampleSize() {
-        // 15,000 samples → should be capped at MAX_SAMPLE_SIZE (10,000) without error
-        List<float[]> samples = gaussian(15_000, 32, new Random(8L));
-        assertDoesNotThrow(() -> SvasqCalibrator.calibrate(samples, 32, SEED));
-    }
-
-    @Test
-    void bytesPerVector_is_4_plus_paddedDim() {
-        List<float[]> samples = gaussian(200, 64, new Random(9L));
-        SvasqParams p = SvasqCalibrator.calibrate(samples, 64, SEED);
-        assertEquals(4 + p.paddedDim(), p.bytesPerVector());
-    }
-
-    // ── Helpers ───────────────────────────────────────────────────────────────
-
-    private static List<float[]> gaussian(int n, int dim, Random rng) {
-        List<float[]> list = new ArrayList<>(n);
-        for (int i = 0; i < n; i++) {
-            float[] v = new float[dim];
-            for (int d = 0; d < dim; d++) v[d] = (float) rng.nextGaussian();
-            list.add(v);
-        }
-        return list;
-    }
-}
diff --git a/spector-core/src/test/java/com/spectrayan/spector/core/SvasqFwhtTest.java b/spector-core/src/test/java/com/spectrayan/spector/core/SvasqFwhtTest.java
deleted file mode 100644
index dcc2532..0000000
--- a/spector-core/src/test/java/com/spectrayan/spector/core/SvasqFwhtTest.java
+++ /dev/null
@@ -1,242 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.core;
-
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-
-import com.spectrayan.spector.core.quantization.svasq.SvasqFwht;
-import org.junit.jupiter.api.Test;
-
-import java.util.Random;
-
-import static org.junit.jupiter.api.Assertions.*;
-
-/**
- * Tests for {@link SvasqFwht} — FWHT rotation correctness and orthogonality.
- */
-class SvasqFwhtTest {
-
-    private static final long SEED = 42L;
-    private static final float NORM_TOLERANCE    = 1e-4f;
-    private static final float INNER_P_TOLERANCE = 1e-4f;
-
-    // ── nextPowerOfTwo ────────────────────────────────────────────────────────
-
-    @Test
-    void nextPowerOfTwo_exactPower() {
-        assertEquals(1,    SvasqFwht.nextPowerOfTwo(1));
-        assertEquals(2,    SvasqFwht.nextPowerOfTwo(2));
-        assertEquals(4,    SvasqFwht.nextPowerOfTwo(4));
-        assertEquals(256,  SvasqFwht.nextPowerOfTwo(256));
-        assertEquals(1024, SvasqFwht.nextPowerOfTwo(1024));
-    }
-
-    @Test
-    void nextPowerOfTwo_nonExactPower() {
-        assertEquals(4,    SvasqFwht.nextPowerOfTwo(3));
-        assertEquals(128,  SvasqFwht.nextPowerOfTwo(100));
-        assertEquals(512,  SvasqFwht.nextPowerOfTwo(385));
-        assertEquals(1024, SvasqFwht.nextPowerOfTwo(769));
-        assertEquals(2048, SvasqFwht.nextPowerOfTwo(1537)); // 1536-dim embeddings
-    }
-
-    @Test
-    void paddedDim_768_is_1024() {
-        SvasqFwht fwht = new SvasqFwht(768, SEED);
-        assertEquals(1024, fwht.paddedDim());
-        assertEquals(768,  fwht.originalDim());
-    }
-
-    @Test
-    void paddedDim_384_is_512() {
-        SvasqFwht fwht = new SvasqFwht(384, SEED);
-        assertEquals(512,  fwht.paddedDim());
-    }
-
-    @Test
-    void paddedDim_128_is_128() {
-        // 128 is already a power-of-two — no padding
-        SvasqFwht fwht = new SvasqFwht(128, SEED);
-        assertEquals(128, fwht.paddedDim());
-    }
-
-    // ── Orthogonality: ‖rotate(v)‖ = ‖v‖ ─────────────────────────────────────
-
-    @Test
-    void normPreserved_randomVector_128dims() {
-        SvasqFwht fwht = new SvasqFwht(128, SEED);
-        Random rng = new Random(1L);
-
-        for (int trial = 0; trial < 50; trial++) {
-            float[] v = randomVector(128, rng);
-            float[] r = fwht.rotate(v);
-
-            float normOrig   = norm(v);
-            float normRotated = norm(r);
-            assertEquals(normOrig, normRotated, NORM_TOLERANCE * normOrig,
-                    "Norm not preserved on trial " + trial);
-        }
-    }
-
-    @Test
-    void normPreserved_randomVector_768dims() {
-        SvasqFwht fwht = new SvasqFwht(768, SEED);
-        Random rng = new Random(2L);
-
-        for (int trial = 0; trial < 20; trial++) {
-            float[] v = randomVector(768, rng);
-            float[] r = fwht.rotate(v);
-
-            float normOrig    = norm(v);
-            float normRotated = norm(r);
-            assertEquals(normOrig, normRotated, NORM_TOLERANCE * normOrig + 1e-6f,
-                    "Norm not preserved on trial " + trial);
-        }
-    }
-
-    @Test
-    void normPreserved_zeroVector() {
-        SvasqFwht fwht = new SvasqFwht(128, SEED);
-        float[] zero   = new float[128];
-        float[] rotated = fwht.rotate(zero);
-        assertEquals(0f, norm(rotated), 1e-10f, "Zero vector must stay zero after rotation");
-    }
-
-    // ── Inner-product preservation: ⟨rotate(a), rotate(b)⟩ ≈ ⟨a, b⟩ ─────────
-
-    @Test
-    void innerProductPreserved_randomPairs_128dims() {
-        SvasqFwht fwht = new SvasqFwht(128, SEED);
-        Random rng = new Random(3L);
-
-        for (int trial = 0; trial < 30; trial++) {
-            float[] a = randomVector(128, rng);
-            float[] b = randomVector(128, rng);
-            float[] ra = fwht.rotate(a);
-            float[] rb = fwht.rotate(b);
-
-            float exactIP    = dot(a, b);
-            float rotatedIP  = dot(ra, rb);
-            float normProd   = norm(a) * norm(b) + 1e-9f;
-            assertEquals(exactIP, rotatedIP, INNER_P_TOLERANCE * normProd + 1e-6f,
-                    "Inner product not preserved on trial " + trial);
-        }
-    }
-
-    // ── Determinism: same seed → same rotation ────────────────────────────────
-
-    @Test
-    void deterministic_sameSeed() {
-        SvasqFwht fwht1 = new SvasqFwht(64, SEED);
-        SvasqFwht fwht2 = new SvasqFwht(64, SEED);
-        float[] v = randomVector(64, new Random(99L));
-
-        float[] r1 = fwht1.rotate(v);
-        float[] r2 = fwht2.rotate(v);
-
-        assertArrayEquals(r1, r2, "Same seed must produce identical rotations");
-    }
-
-    @Test
-    void different_seeds_produce_different_rotations() {
-        SvasqFwht fwht1 = new SvasqFwht(64, 10L);
-        SvasqFwht fwht2 = new SvasqFwht(64, 20L);
-        float[] v = randomVector(64, new Random(99L));
-
-        float[] r1 = fwht1.rotate(v);
-        float[] r2 = fwht2.rotate(v);
-
-        // Very unlikely to be identical with different seeds
-        boolean allEqual = true;
-        for (int i = 0; i < r1.length; i++) {
-            if (Math.abs(r1[i] - r2[i]) > 1e-6f) { allEqual = false; break; }
-        }
-        assertFalse(allEqual, "Different seeds should produce different rotations");
-    }
-
-    // ── Output shape ──────────────────────────────────────────────────────────
-
-    @Test
-    void rotateAllocating_returns_paddedDim_array() {
-        SvasqFwht fwht = new SvasqFwht(100, SEED);
-        assertEquals(128, fwht.paddedDim());
-        float[] v = randomVector(100, new Random(5L));
-        float[] r = fwht.rotate(v);
-        assertEquals(128, r.length);
-    }
-
-    @Test
-    void rotateInPlace_writes_to_dst_buffer() {
-        SvasqFwht fwht = new SvasqFwht(4, SEED);
-        float[] src = {1f, 2f, 3f, 4f};
-        float[] dst = new float[4];
-        fwht.rotate(src, dst);
-        // Verify dst was modified (not all zeros)
-        float dstNorm = norm(dst);
-        assertTrue(dstNorm > 0f, "dst must be non-zero after rotation");
-        // Verify norm is preserved
-        assertEquals(norm(src), dstNorm, 0.01f * norm(src) + 1e-6f);
-    }
-
-    @Test
-    void wrongDimThrows() {
-        SvasqFwht fwht = new SvasqFwht(128, SEED);
-        assertThrows(SpectorValidationException.class, () -> fwht.rotate(new float[64]));
-    }
-
-    @Test
-    void invalidDimThrows() {
-        assertThrows(SpectorValidationException.class, () -> new SvasqFwht(0, SEED));
-    }
-
-    // ── FWHT butterfly correctness (known output) ─────────────────────────────
-
-    @Test
-    void applyFwht_knownInput() {
-        // For input [1, 0, 0, 0], FWHT gives [1, 1, 1, 1]
-        float[] data = {1f, 0f, 0f, 0f};
-        SvasqFwht.applyFwht(data);
-        assertArrayEquals(new float[]{1f, 1f, 1f, 1f}, data, 1e-6f);
-    }
-
-    @Test
-    void applyFwht_knownInput2() {
-        // For input [1, 1, 1, 1], FWHT gives [4, 0, 0, 0]
-        float[] data = {1f, 1f, 1f, 1f};
-        SvasqFwht.applyFwht(data);
-        assertArrayEquals(new float[]{4f, 0f, 0f, 0f}, data, 1e-6f);
-    }
-
-    // ── Helpers ───────────────────────────────────────────────────────────────
-
-    private static float[] randomVector(int dim, Random rng) {
-        float[] v = new float[dim];
-        for (int i = 0; i < dim; i++) v[i] = (float) rng.nextGaussian();
-        return v;
-    }
-
-    private static float norm(float[] v) {
-        double s = 0;
-        for (float x : v) s += (double) x * x;
-        return (float) Math.sqrt(s);
-    }
-
-    private static float dot(float[] a, float[] b) {
-        double s = 0;
-        for (int i = 0; i < a.length; i++) s += (double) a[i] * b[i];
-        return (float) s;
-    }
-}
diff --git a/spector-core/src/test/java/com/spectrayan/spector/core/SvasqKernelTest.java b/spector-core/src/test/java/com/spectrayan/spector/core/SvasqKernelTest.java
deleted file mode 100644
index 5697954..0000000
--- a/spector-core/src/test/java/com/spectrayan/spector/core/SvasqKernelTest.java
+++ /dev/null
@@ -1,285 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.core;
-
-import com.spectrayan.spector.core.quantization.svasq.*;
-import com.spectrayan.spector.core.simd.SimdCapability;
-
-import jdk.incubator.vector.VectorSpecies;
-
-import org.junit.jupiter.api.BeforeAll;
-import org.junit.jupiter.api.Test;
-
-import java.lang.foreign.Arena;
-import java.lang.foreign.MemorySegment;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Random;
-
-import static org.junit.jupiter.api.Assertions.*;
-
-/**
- * Tests for {@link SvasqSimdKernel} and the full encode → prepare → distance pipeline.
- */
-class SvasqKernelTest {
-
-    private static final long   SEED       = 42L;
-    private static final int    DIM        = 128;
-    private static final int    N_SAMPLES  = 500;
-    private static final float  L2_REL_TOL = 0.05f; // ≤ 5% relative L2 error
-    private static final float  DOT_TOL    = 0.10f; // ≤ 10% relative dot error
-
-    private static SvasqParams   params;
-    private static SvasqEncoder  encoder;
-    private static SvasqQueryPrep queryPrep;
-    private static List<float[]> corpus;
-
-    @BeforeAll
-    static void setup() {
-        Random rng = new Random(1L);
-        corpus = new ArrayList<>(N_SAMPLES);
-        for (int i = 0; i < N_SAMPLES; i++) {
-            float[] v = new float[DIM];
-            for (int d = 0; d < DIM; d++) v[d] = (float) rng.nextGaussian();
-            corpus.add(v);
-        }
-        params    = SvasqCalibrator.calibrate(corpus, DIM, SEED);
-        encoder   = new SvasqEncoder(params);
-        queryPrep = new SvasqQueryPrep(params);
-    }
-
-    // ── Species safety regression ─────────────────────────────────────────────
-
-    @Test
-    void byteSpecies_laneCount_equals_floatSpecies_laneCount() {
-        // This is the regression test for the SPECIES_256 bug from quant.md analysis.
-        // B_SPECIES.length() must equal F_SPECIES.length() for the castShape to be valid.
-        int floatLanes = SvasqSimdKernel.floatSpecies().length();
-        int byteLanes  = SvasqSimdKernel.byteSpecies().length();
-        assertEquals(floatLanes, byteLanes,
-                "B_SPECIES must have the same lane count as F_SPECIES. "
-                + "Got floatLanes=" + floatLanes + " byteLanes=" + byteLanes);
-    }
-
-    @Test
-    void laneCount_is_power_of_two() {
-        int lanes = SvasqSimdKernel.laneCount();
-        assertTrue(lanes > 0 && (lanes & (lanes - 1)) == 0,
-                "Lane count must be a power of two, got " + lanes);
-    }
-
-    // ── L2 distance accuracy ──────────────────────────────────────────────────
-
-    @Test
-    void computeL2_closeToExact_randomPairs() {
-        int paddedDim = params.paddedDim();
-        int bpv       = encoder.bytesPerVector();
-
-        try (Arena arena = Arena.ofConfined()) {
-            // Encode all corpus vectors into one MemorySegment
-            MemorySegment segment = arena.allocate((long) N_SAMPLES * bpv, 8);
-            for (int i = 0; i < N_SAMPLES; i++) {
-                encoder.encode(corpus.get(i), segment, (long) i * bpv);
-            }
-
-            Random rng = new Random(2L);
-            double totalRelError = 0;
-            int pairs = 200;
-
-            for (int t = 0; t < pairs; t++) {
-                float[] query = corpus.get(rng.nextInt(N_SAMPLES));
-                int     docIdx = rng.nextInt(N_SAMPLES);
-                float[] doc    = corpus.get(docIdx);
-
-                float exactL2 = exactL2Sq(query, doc);
-                SvasqQueryState qs = queryPrep.prepare(query);
-                float approxL2 = SvasqSimdKernel.computeL2(segment, (long) docIdx * bpv, paddedDim, qs);
-
-                // L2 distances should be non-negative
-                assertTrue(approxL2 >= -0.01f,
-                        "L2 distance must be ≥ 0, got " + approxL2);
-
-                if (exactL2 > 1e-6f) {
-                    double relError = Math.abs(approxL2 - exactL2) / exactL2;
-                    totalRelError += relError;
-                }
-            }
-
-            double avgRelError = totalRelError / pairs;
-            assertTrue(avgRelError < L2_REL_TOL,
-                    "Average relative L2 error too high: " + avgRelError);
-        }
-    }
-
-    @Test
-    void computeL2_zero_query_returns_exactNormSq() {
-        // When query is zero: dot = 0, C(q) = 0, constL2Q = ‖0‖² - 2×0 = 0
-        // So L2 = exactNormSq + 0 - 0 = exactNormSq
-        float[] query  = new float[DIM]; // all zeros
-        float[] doc    = corpus.get(0);
-        int     bpv    = encoder.bytesPerVector();
-
-        try (Arena arena = Arena.ofConfined()) {
-            MemorySegment seg = arena.allocate(bpv, 8);
-            encoder.encode(doc, seg, 0L);
-
-            SvasqQueryState qs = queryPrep.prepare(query);
-            float approxL2 = SvasqSimdKernel.computeL2(seg, 0L, params.paddedDim(), qs);
-
-            // Should approximately equal exactNormSq stored in the header
-            float storedNorm = seg.get(java.lang.foreign.ValueLayout.JAVA_FLOAT, 0L);
-            assertEquals(storedNorm, approxL2, storedNorm * 0.02f + 0.01f,
-                    "L2 with zero query should ≈ exactNormSq");
-        }
-    }
-
-    @Test
-    void computeL2_same_vector_is_near_zero() {
-        // L2(q, q) should be ≈ 0
-        float[] q   = corpus.get(0);
-        int     bpv = encoder.bytesPerVector();
-
-        try (Arena arena = Arena.ofConfined()) {
-            MemorySegment seg = arena.allocate(bpv, 8);
-            encoder.encode(q, seg, 0L);
-
-            SvasqQueryState qs = queryPrep.prepare(q);
-            float l2 = SvasqSimdKernel.computeL2(seg, 0L, params.paddedDim(), qs);
-
-        // Quantization introduces ~5-10% error, so L2(q,q) won't be exactly 0
-            float normSq = exactNormSq(q);
-            assertTrue(l2 < normSq * 0.15f,
-                    "L2(q,q) should be < 15% of ‖q‖², got " + l2 + " norm²=" + normSq);
-        }
-    }
-
-    // ── Dot product accuracy ──────────────────────────────────────────────────
-
-    @Test
-    void computeDot_closeToExact_randomPairs() {
-        int paddedDim = params.paddedDim();
-        int bpv       = encoder.bytesPerVector();
-
-        try (Arena arena = Arena.ofConfined()) {
-            MemorySegment segment = arena.allocate((long) N_SAMPLES * bpv, 8);
-            for (int i = 0; i < N_SAMPLES; i++) {
-                encoder.encode(corpus.get(i), segment, (long) i * bpv);
-            }
-
-            Random rng = new Random(3L);
-            double totalAbsError = 0;
-            double totalNormProd = 0;
-            int pairs = 200;
-
-            for (int t = 0; t < pairs; t++) {
-                float[] query  = corpus.get(rng.nextInt(N_SAMPLES));
-                int     docIdx = rng.nextInt(N_SAMPLES);
-                float[] doc    = corpus.get(docIdx);
-
-                float exactDot  = exactDot(query, doc);
-                SvasqQueryState qs = queryPrep.prepare(query);
-                float approxDot = SvasqSimdKernel.computeDot(segment, (long) docIdx * bpv, paddedDim, qs);
-
-                // Normalize by ‖query‖·‖doc‖ to avoid division by near-zero dot products
-                float normProd = (float) Math.sqrt(exactNormSq(query) * exactNormSq(doc)) + 1e-9f;
-                totalAbsError += Math.abs(approxDot - exactDot);
-                totalNormProd += normProd;
-            }
-
-            // Average normalized error should be < 5% of the typical vector norm product
-            double avgNormError = totalAbsError / totalNormProd;
-            assertTrue(avgNormError < 0.05,
-                    "Average norm-normalized dot error too high: " + avgNormError);
-        }
-    }
-
-    // ── Ranking preservation (relative order) ────────────────────────────────
-
-    @Test
-    void l2_ranking_mostly_preserved() {
-        // Top-5 by exact L2 should appear in top-10 by SVASQ L2 (>= 4 out of 5)
-        float[] query = corpus.get(0);
-        int bpv = encoder.bytesPerVector();
-
-        try (Arena arena = Arena.ofConfined()) {
-            MemorySegment segment = arena.allocate((long) N_SAMPLES * bpv, 8);
-            for (int i = 0; i < N_SAMPLES; i++) {
-                encoder.encode(corpus.get(i), segment, (long) i * bpv);
-            }
-
-            // Exact top-5 (excluding query itself)
-            float[] exactL2 = new float[N_SAMPLES];
-            for (int i = 0; i < N_SAMPLES; i++) exactL2[i] = exactL2Sq(query, corpus.get(i));
-            int[] exactTop5 = topK(exactL2, 6, true, 0); // skip index 0
-
-            // SVASQ top-10
-            SvasqQueryState qs = queryPrep.prepare(query);
-            float[] svasqL2 = new float[N_SAMPLES];
-            for (int i = 0; i < N_SAMPLES; i++) {
-                svasqL2[i] = SvasqSimdKernel.computeL2(segment, (long) i * bpv, params.paddedDim(), qs);
-            }
-            int[] svasqTop10 = topK(svasqL2, 11, true, 0); // skip index 0
-
-            int overlap = 0;
-            for (int e : exactTop5) {
-                for (int v : svasqTop10) if (e == v) { overlap++; break; }
-            }
-            assertTrue(overlap >= 3,
-                    "Expected ≥ 3 of top-5 exact to appear in SVASQ top-10; overlap=" + overlap);
-        }
-    }
-
-    // ── Helpers ───────────────────────────────────────────────────────────────
-
-    private static float exactL2Sq(float[] a, float[] b) {
-        double s = 0;
-        for (int i = 0; i < a.length; i++) { double d = a[i] - b[i]; s += d * d; }
-        return (float) s;
-    }
-
-    private static float exactNormSq(float[] v) {
-        double s = 0;
-        for (float x : v) s += (double) x * x;
-        return (float) s;
-    }
-
-    private static float exactDot(float[] a, float[] b) {
-        double s = 0;
-        for (int i = 0; i < a.length; i++) s += (double) a[i] * b[i];
-        return (float) s;
-    }
-
-    /** Returns indices of top-k smallest values, skipping {@code skipIdx}. */
-    private static int[] topK(float[] scores, int k, boolean smallerIsBetter, int skipIdx) {
-        int n = scores.length;
-        int[] indices = new int[k];
-        boolean[] used = new boolean[n];
-        for (int t = 0; t < k; t++) {
-            int best = -1;
-            for (int i = 0; i < n; i++) {
-                if (used[i] || i == skipIdx) continue;
-                if (best == -1) { best = i; continue; }
-                boolean betterThanBest = smallerIsBetter
-                        ? scores[i] < scores[best]
-                        : scores[i] > scores[best];
-                if (betterThanBest) best = i;
-            }
-            indices[t] = best;
-            used[best] = true;
-        }
-        return indices;
-    }
-}
diff --git a/spector-core/src/test/java/com/spectrayan/spector/core/SvasqQueryPrepTest.java b/spector-core/src/test/java/com/spectrayan/spector/core/SvasqQueryPrepTest.java
deleted file mode 100644
index 5f3b698..0000000
--- a/spector-core/src/test/java/com/spectrayan/spector/core/SvasqQueryPrepTest.java
+++ /dev/null
@@ -1,154 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.core;
-
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-
-import com.spectrayan.spector.core.quantization.svasq.*;
-import org.junit.jupiter.api.Test;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Random;
-
-import static org.junit.jupiter.api.Assertions.*;
-
-/**
- * Tests for {@link SvasqQueryPrep} — query state correctness.
- */
-class SvasqQueryPrepTest {
-
-    private static final long SEED = 42L;
-    private static final int  DIM  = 64;
-
-    private SvasqParams calibrate(int n, int dim, long rngSeed) {
-        Random rng = new Random(rngSeed);
-        List<float[]> samples = new ArrayList<>(n);
-        for (int i = 0; i < n; i++) {
-            float[] v = new float[dim];
-            for (int d = 0; d < dim; d++) v[d] = (float) rng.nextGaussian();
-            samples.add(v);
-        }
-        return SvasqCalibrator.calibrate(samples, dim, SEED);
-    }
-
-    // ── qTilde ────────────────────────────────────────────────────────────────
-
-    @Test
-    void qTilde_length_is_paddedDim() {
-        SvasqParams params = calibrate(200, DIM, 1L);
-        SvasqQueryPrep prep = new SvasqQueryPrep(params);
-        float[] query = new float[DIM];
-        SvasqQueryState qs = prep.prepare(query);
-        assertEquals(params.paddedDim(), qs.qTilde().length);
-    }
-
-    @Test
-    void qTilde_is_qRot_times_scale() {
-        SvasqParams params = calibrate(200, DIM, 2L);
-        SvasqQueryPrep prep = new SvasqQueryPrep(params);
-
-        Random rng = new Random(3L);
-        float[] query = new float[DIM];
-        for (int i = 0; i < DIM; i++) query[i] = (float) rng.nextGaussian();
-
-        SvasqQueryState qs = prep.prepare(query);
-
-        // Manually compute q_rot
-        float[] qRot = params.fwht().rotate(query);
-        float[] scales = params.scales();
-
-        for (int i = 0; i < params.paddedDim(); i++) {
-            assertEquals(qRot[i] * scales[i], qs.qTilde()[i], 1e-5f,
-                    "qTilde[" + i + "] mismatch");
-        }
-    }
-
-    @Test
-    void zero_query_gives_zero_qTilde_and_zero_dotOffset() {
-        SvasqParams params = calibrate(200, DIM, 4L);
-        SvasqQueryPrep prep = new SvasqQueryPrep(params);
-        float[] zero = new float[DIM];
-        SvasqQueryState qs = prep.prepare(zero);
-
-        for (int i = 0; i < params.paddedDim(); i++) {
-            assertEquals(0f, qs.qTilde()[i], 1e-6f, "qTilde must be zero for zero query");
-        }
-        assertEquals(0f, qs.qNormSq(), 1e-9f);
-    }
-
-    // ── constL2Q sign ─────────────────────────────────────────────────────────
-
-    @Test
-    void constL2Q_equals_qNormSq_minus_2_times_dotOffset() {
-        SvasqParams params = calibrate(200, DIM, 5L);
-        SvasqQueryPrep prep = new SvasqQueryPrep(params);
-
-        Random rng = new Random(6L);
-        float[] query = new float[DIM];
-        for (int i = 0; i < DIM; i++) query[i] = (float) rng.nextGaussian();
-
-        SvasqQueryState qs = prep.prepare(query);
-
-        float expected = qs.qNormSq() - 2f * qs.dotOffset();
-        assertEquals(expected, qs.constL2Q(), 1e-4f,
-                "constL2Q must equal qNormSq - 2*C(q). "
-                + "Got constL2Q=" + qs.constL2Q() + " expected=" + expected);
-    }
-
-    @Test
-    void zero_query_constL2Q_is_zero() {
-        SvasqParams params = calibrate(200, DIM, 7L);
-        SvasqQueryPrep prep = new SvasqQueryPrep(params);
-        SvasqQueryState qs = prep.prepare(new float[DIM]);
-        assertEquals(0f, qs.constL2Q(), 1e-6f);
-    }
-
-    // ── qNormSq ───────────────────────────────────────────────────────────────
-
-    @Test
-    void qNormSq_matches_manual_calculation() {
-        SvasqParams params = calibrate(200, DIM, 8L);
-        SvasqQueryPrep prep = new SvasqQueryPrep(params);
-
-        Random rng = new Random(9L);
-        float[] query = new float[DIM];
-        double expected = 0;
-        for (int i = 0; i < DIM; i++) {
-            query[i] = (float) rng.nextGaussian();
-            expected += (double) query[i] * query[i];
-        }
-
-        SvasqQueryState qs = prep.prepare(query);
-        assertEquals((float) expected, qs.qNormSq(), 1e-3f * (float) expected,
-                "qNormSq mismatch");
-    }
-
-    // ── Error cases ───────────────────────────────────────────────────────────
-
-    @Test
-    void wrongDimThrows() {
-        SvasqParams params = calibrate(100, DIM, 10L);
-        SvasqQueryPrep prep = new SvasqQueryPrep(params);
-        assertThrows(SpectorValidationException.class,
-                () -> prep.prepare(new float[DIM + 1]));
-    }
-
-    @Test
-    void nullParamsThrows() {
-        assertThrows(SpectorValidationException.class, () -> new SvasqQueryPrep(null));
-    }
-}
diff --git a/spector-core/src/test/java/com/spectrayan/spector/core/VectorOpsTest.java b/spector-core/src/test/java/com/spectrayan/spector/core/VectorOpsTest.java
index 298c76f..85b5da1 100644
--- a/spector-core/src/test/java/com/spectrayan/spector/core/VectorOpsTest.java
+++ b/spector-core/src/test/java/com/spectrayan/spector/core/VectorOpsTest.java
@@ -1,22 +1,5 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.core;
 
-import com.spectrayan.spector.core.similarity.VectorOps;
-
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.within;
 
diff --git a/spector-cortex/.editorconfig b/spector-cortex/.editorconfig
deleted file mode 100644
index f166060..0000000
--- a/spector-cortex/.editorconfig
+++ /dev/null
@@ -1,17 +0,0 @@
-# Editor configuration, see https://editorconfig.org
-root = true
-
-[*]
-charset = utf-8
-indent_style = space
-indent_size = 2
-insert_final_newline = true
-trim_trailing_whitespace = true
-
-[*.ts]
-quote_type = single
-ij_typescript_use_double_quotes = false
-
-[*.md]
-max_line_length = off
-trim_trailing_whitespace = false
diff --git a/spector-cortex/.gitignore b/spector-cortex/.gitignore
deleted file mode 100644
index 854acd5..0000000
--- a/spector-cortex/.gitignore
+++ /dev/null
@@ -1,44 +0,0 @@
-# See https://docs.github.com/get-started/getting-started-with-git/ignoring-files for more about ignoring files.
-
-# Compiled output
-/dist
-/tmp
-/out-tsc
-/bazel-out
-
-# Node
-/node_modules
-npm-debug.log
-yarn-error.log
-
-# IDEs and editors
-.idea/
-.project
-.classpath
-.c9/
-*.launch
-.settings/
-*.sublime-workspace
-
-# Visual Studio Code
-.vscode/*
-!.vscode/settings.json
-!.vscode/tasks.json
-!.vscode/launch.json
-!.vscode/extensions.json
-!.vscode/mcp.json
-.history/*
-
-# Miscellaneous
-/.angular/cache
-.sass-cache/
-/connect.lock
-/coverage
-/libpeerconnection.log
-testem.log
-/typings
-__screenshots__/
-
-# System files
-.DS_Store
-Thumbs.db
diff --git a/spector-cortex/.prettierrc b/spector-cortex/.prettierrc
deleted file mode 100644
index d6c16d7..0000000
--- a/spector-cortex/.prettierrc
+++ /dev/null
@@ -1,12 +0,0 @@
-{
-  "printWidth": 100,
-  "singleQuote": true,
-  "overrides": [
-    {
-      "files": "*.html",
-      "options": {
-        "parser": "angular"
-      }
-    }
-  ]
-}
diff --git a/spector-cortex/README.md b/spector-cortex/README.md
deleted file mode 100644
index ab87dde..0000000
--- a/spector-cortex/README.md
+++ /dev/null
@@ -1,59 +0,0 @@
-# SpectorCortex
-
-This project was generated using [Angular CLI](https://github.com/angular/angular-cli) version 21.2.13.
-
-## Development server
-
-To start a local development server, run:
-
-```bash
-ng serve
-```
-
-Once the server is running, open your browser and navigate to `http://localhost:4200/`. The application will automatically reload whenever you modify any of the source files.
-
-## Code scaffolding
-
-Angular CLI includes powerful code scaffolding tools. To generate a new component, run:
-
-```bash
-ng generate component component-name
-```
-
-For a complete list of available schematics (such as `components`, `directives`, or `pipes`), run:
-
-```bash
-ng generate --help
-```
-
-## Building
-
-To build the project run:
-
-```bash
-ng build
-```
-
-This will compile your project and store the build artifacts in the `dist/` directory. By default, the production build optimizes your application for performance and speed.
-
-## Running unit tests
-
-To execute unit tests with the [Vitest](https://vitest.dev/) test runner, use the following command:
-
-```bash
-ng test
-```
-
-## Running end-to-end tests
-
-For end-to-end (e2e) testing, run:
-
-```bash
-ng e2e
-```
-
-Angular CLI does not come with an end-to-end testing framework by default. You can choose one that suits your needs.
-
-## Additional Resources
-
-For more information on using the Angular CLI, including detailed command references, visit the [Angular CLI Overview and Command Reference](https://angular.dev/tools/cli) page.
diff --git a/spector-cortex/angular.json b/spector-cortex/angular.json
deleted file mode 100644
index 6530058..0000000
--- a/spector-cortex/angular.json
+++ /dev/null
@@ -1,98 +0,0 @@
-{
-  "$schema": "./node_modules/@angular/cli/lib/config/schema.json",
-  "version": 1,
-  "cli": {
-    "packageManager": "npm",
-    "analytics": false
-  },
-  "newProjectRoot": "projects",
-  "projects": {
-    "spector-cortex": {
-      "projectType": "application",
-      "schematics": {
-        "@schematics/angular:component": {
-          "style": "scss",
-          "skipTests": true
-        },
-        "@schematics/angular:class": {
-          "skipTests": true
-        },
-        "@schematics/angular:directive": {
-          "skipTests": true
-        },
-        "@schematics/angular:guard": {
-          "skipTests": true
-        },
-        "@schematics/angular:interceptor": {
-          "skipTests": true
-        },
-        "@schematics/angular:pipe": {
-          "skipTests": true
-        },
-        "@schematics/angular:resolver": {
-          "skipTests": true
-        },
-        "@schematics/angular:service": {
-          "skipTests": true
-        }
-      },
-      "root": "",
-      "sourceRoot": "src",
-      "prefix": "cortex",
-      "architect": {
-        "build": {
-          "builder": "@angular/build:application",
-          "options": {
-            "browser": "src/main.ts",
-            "tsConfig": "tsconfig.app.json",
-            "inlineStyleLanguage": "scss",
-            "assets": [
-              {
-                "glob": "**/*",
-                "input": "public"
-              }
-            ],
-            "styles": [
-              "src/styles.scss"
-            ]
-          },
-          "configurations": {
-            "production": {
-              "budgets": [
-                {
-                  "type": "initial",
-                  "maximumWarning": "2MB",
-                  "maximumError": "4MB"
-                },
-                {
-                  "type": "anyComponentStyle",
-                  "maximumWarning": "16kB",
-                  "maximumError": "32kB"
-                }
-              ],
-              "outputHashing": "all"
-            },
-            "development": {
-              "optimization": false,
-              "extractLicenses": false,
-              "sourceMap": true
-            }
-          },
-          "defaultConfiguration": "production"
-        },
-        "serve": {
-          "builder": "@angular/build:dev-server",
-          "configurations": {
-            "production": {
-              "buildTarget": "spector-cortex:build:production"
-            },
-            "development": {
-              "buildTarget": "spector-cortex:build:development"
-            }
-          },
-          "defaultConfiguration": "development"
-        }
-      }
-    }
-  }
-}
diff --git a/spector-cortex/package-lock.json b/spector-cortex/package-lock.json
deleted file mode 100644
index 436a95b..0000000
--- a/spector-cortex/package-lock.json
+++ /dev/null
@@ -1,7901 +0,0 @@
-{
-  "name": "spector-cortex",
-  "version": "0.0.0",
-  "lockfileVersion": 3,
-  "requires": true,
-  "packages": {
-    "": {
-      "name": "spector-cortex",
-      "version": "0.0.0",
-      "dependencies": {
-        "@angular/animations": "^21.2.15",
-        "@angular/cdk": "^21.2.13",
-        "@angular/common": "^21.2.0",
-        "@angular/compiler": "^21.2.0",
-        "@angular/core": "^21.2.0",
-        "@angular/forms": "^21.2.0",
-        "@angular/material": "^21.2.13",
-        "@angular/platform-browser": "^21.2.0",
-        "@angular/router": "^21.2.0",
-        "@spectrayan/ng-sse-client": "^2.0.0",
-        "echarts": "^6.1.0",
-        "ngx-echarts": "^21.0.0",
-        "rxjs": "~7.8.0",
-        "three": "^0.184.0",
-        "tslib": "^2.3.0"
-      },
-      "devDependencies": {
-        "@angular/build": "^21.2.13",
-        "@angular/cli": "^21.2.13",
-        "@angular/compiler-cli": "^21.2.0",
-        "@types/three": "^0.184.1",
-        "prettier": "^3.8.1",
-        "typescript": "~5.9.2"
-      }
-    },
-    "node_modules/@algolia/abtesting": {
-      "version": "1.14.1",
-      "resolved": "https://registry.npmjs.org/@algolia/abtesting/-/abtesting-1.14.1.tgz",
-      "integrity": "sha512-Dkj0BgPiLAaim9sbQ97UKDFHJE/880wgStAM18U++NaJ/2Cws34J5731ovJifr6E3Pv4T2CqvMXf8qLCC417Ew==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@algolia/client-common": "5.48.1",
-        "@algolia/requester-browser-xhr": "5.48.1",
-        "@algolia/requester-fetch": "5.48.1",
-        "@algolia/requester-node-http": "5.48.1"
-      },
-      "engines": {
-        "node": ">= 14.0.0"
-      }
-    },
-    "node_modules/@algolia/client-abtesting": {
-      "version": "5.48.1",
-      "resolved": "https://registry.npmjs.org/@algolia/client-abtesting/-/client-abtesting-5.48.1.tgz",
-      "integrity": "sha512-LV5qCJdj+/m9I+Aj91o+glYszrzd7CX6NgKaYdTOj4+tUYfbS62pwYgUfZprYNayhkQpVFcrW8x8ZlIHpS23Vw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@algolia/client-common": "5.48.1",
-        "@algolia/requester-browser-xhr": "5.48.1",
-        "@algolia/requester-fetch": "5.48.1",
-        "@algolia/requester-node-http": "5.48.1"
-      },
-      "engines": {
-        "node": ">= 14.0.0"
-      }
-    },
-    "node_modules/@algolia/client-analytics": {
-      "version": "5.48.1",
-      "resolved": "https://registry.npmjs.org/@algolia/client-analytics/-/client-analytics-5.48.1.tgz",
-      "integrity": "sha512-/AVoMqHhPm14CcHq7mwB+bUJbfCv+jrxlNvRjXAuO+TQa+V37N8k1b0ijaRBPdmSjULMd8KtJbQyUyabXOu6Kg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@algolia/client-common": "5.48.1",
-        "@algolia/requester-browser-xhr": "5.48.1",
-        "@algolia/requester-fetch": "5.48.1",
-        "@algolia/requester-node-http": "5.48.1"
-      },
-      "engines": {
-        "node": ">= 14.0.0"
-      }
-    },
-    "node_modules/@algolia/client-common": {
-      "version": "5.48.1",
-      "resolved": "https://registry.npmjs.org/@algolia/client-common/-/client-common-5.48.1.tgz",
-      "integrity": "sha512-VXO+qu2Ep6ota28ktvBm3sG53wUHS2n7bgLWmce5jTskdlCD0/JrV4tnBm1l7qpla1CeoQb8D7ShFhad+UoSOw==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 14.0.0"
-      }
-    },
-    "node_modules/@algolia/client-insights": {
-      "version": "5.48.1",
-      "resolved": "https://registry.npmjs.org/@algolia/client-insights/-/client-insights-5.48.1.tgz",
-      "integrity": "sha512-zl+Qyb0nLg+Y5YvKp1Ij+u9OaPaKg2/EPzTwKNiVyOHnQJlFxmXyUZL1EInczAZsEY8hVpPCLtNfhMhfxluXKQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@algolia/client-common": "5.48.1",
-        "@algolia/requester-browser-xhr": "5.48.1",
-        "@algolia/requester-fetch": "5.48.1",
-        "@algolia/requester-node-http": "5.48.1"
-      },
-      "engines": {
-        "node": ">= 14.0.0"
-      }
-    },
-    "node_modules/@algolia/client-personalization": {
-      "version": "5.48.1",
-      "resolved": "https://registry.npmjs.org/@algolia/client-personalization/-/client-personalization-5.48.1.tgz",
-      "integrity": "sha512-r89Qf9Oo9mKWQXumRu/1LtvVJAmEDpn8mHZMc485pRfQUMAwSSrsnaw1tQ3sszqzEgAr1c7rw6fjBI+zrAXTOw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@algolia/client-common": "5.48.1",
-        "@algolia/requester-browser-xhr": "5.48.1",
-        "@algolia/requester-fetch": "5.48.1",
-        "@algolia/requester-node-http": "5.48.1"
-      },
-      "engines": {
-        "node": ">= 14.0.0"
-      }
-    },
-    "node_modules/@algolia/client-query-suggestions": {
-      "version": "5.48.1",
-      "resolved": "https://registry.npmjs.org/@algolia/client-query-suggestions/-/client-query-suggestions-5.48.1.tgz",
-      "integrity": "sha512-TPKNPKfghKG/bMSc7mQYD9HxHRUkBZA4q1PEmHgICaSeHQscGqL4wBrKkhfPlDV1uYBKW02pbFMUhsOt7p4ZpA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@algolia/client-common": "5.48.1",
-        "@algolia/requester-browser-xhr": "5.48.1",
-        "@algolia/requester-fetch": "5.48.1",
-        "@algolia/requester-node-http": "5.48.1"
-      },
-      "engines": {
-        "node": ">= 14.0.0"
-      }
-    },
-    "node_modules/@algolia/client-search": {
-      "version": "5.48.1",
-      "resolved": "https://registry.npmjs.org/@algolia/client-search/-/client-search-5.48.1.tgz",
-      "integrity": "sha512-4Fu7dnzQyQmMFknYwTiN/HxPbH4DyxvQ1m+IxpPp5oslOgz8m6PG5qhiGbqJzH4HiT1I58ecDiCAC716UyVA8Q==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@algolia/client-common": "5.48.1",
-        "@algolia/requester-browser-xhr": "5.48.1",
-        "@algolia/requester-fetch": "5.48.1",
-        "@algolia/requester-node-http": "5.48.1"
-      },
-      "engines": {
-        "node": ">= 14.0.0"
-      }
-    },
-    "node_modules/@algolia/ingestion": {
-      "version": "1.48.1",
-      "resolved": "https://registry.npmjs.org/@algolia/ingestion/-/ingestion-1.48.1.tgz",
-      "integrity": "sha512-/RFq3TqtXDUUawwic/A9xylA2P3LDMO8dNhphHAUOU51b1ZLHrmZ6YYJm3df1APz7xLY1aht6okCQf+/vmrV9w==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@algolia/client-common": "5.48.1",
-        "@algolia/requester-browser-xhr": "5.48.1",
-        "@algolia/requester-fetch": "5.48.1",
-        "@algolia/requester-node-http": "5.48.1"
-      },
-      "engines": {
-        "node": ">= 14.0.0"
-      }
-    },
-    "node_modules/@algolia/monitoring": {
-      "version": "1.48.1",
-      "resolved": "https://registry.npmjs.org/@algolia/monitoring/-/monitoring-1.48.1.tgz",
-      "integrity": "sha512-Of0jTeAZRyRhC7XzDSjJef0aBkgRcvRAaw0ooYRlOw57APii7lZdq+layuNdeL72BRq1snaJhoMMwkmLIpJScw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@algolia/client-common": "5.48.1",
-        "@algolia/requester-browser-xhr": "5.48.1",
-        "@algolia/requester-fetch": "5.48.1",
-        "@algolia/requester-node-http": "5.48.1"
-      },
-      "engines": {
-        "node": ">= 14.0.0"
-      }
-    },
-    "node_modules/@algolia/recommend": {
-      "version": "5.48.1",
-      "resolved": "https://registry.npmjs.org/@algolia/recommend/-/recommend-5.48.1.tgz",
-      "integrity": "sha512-bE7JcpFXzxF5zHwj/vkl2eiCBvyR1zQ7aoUdO+GDXxGp0DGw7nI0p8Xj6u8VmRQ+RDuPcICFQcCwRIJT5tDJFw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@algolia/client-common": "5.48.1",
-        "@algolia/requester-browser-xhr": "5.48.1",
-        "@algolia/requester-fetch": "5.48.1",
-        "@algolia/requester-node-http": "5.48.1"
-      },
-      "engines": {
-        "node": ">= 14.0.0"
-      }
-    },
-    "node_modules/@algolia/requester-browser-xhr": {
-      "version": "5.48.1",
-      "resolved": "https://registry.npmjs.org/@algolia/requester-browser-xhr/-/requester-browser-xhr-5.48.1.tgz",
-      "integrity": "sha512-MK3wZ2koLDnvH/AmqIF1EKbJlhRS5j74OZGkLpxI4rYvNi9Jn/C7vb5DytBnQ4KUWts7QsmbdwHkxY5txQHXVw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@algolia/client-common": "5.48.1"
-      },
-      "engines": {
-        "node": ">= 14.0.0"
-      }
-    },
-    "node_modules/@algolia/requester-fetch": {
-      "version": "5.48.1",
-      "resolved": "https://registry.npmjs.org/@algolia/requester-fetch/-/requester-fetch-5.48.1.tgz",
-      "integrity": "sha512-2oDT43Y5HWRSIQMPQI4tA/W+TN/N2tjggZCUsqQV440kxzzoPGsvv9QP1GhQ4CoDa+yn6ygUsGp6Dr+a9sPPSg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@algolia/client-common": "5.48.1"
-      },
-      "engines": {
-        "node": ">= 14.0.0"
-      }
-    },
-    "node_modules/@algolia/requester-node-http": {
-      "version": "5.48.1",
-      "resolved": "https://registry.npmjs.org/@algolia/requester-node-http/-/requester-node-http-5.48.1.tgz",
-      "integrity": "sha512-xcaCqbhupVWhuBP1nwbk1XNvwrGljozutEiLx06mvqDf3o8cHyEgQSHS4fKJM+UAggaWVnnFW+Nne5aQ8SUJXg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@algolia/client-common": "5.48.1"
-      },
-      "engines": {
-        "node": ">= 14.0.0"
-      }
-    },
-    "node_modules/@ampproject/remapping": {
-      "version": "2.3.0",
-      "resolved": "https://registry.npmjs.org/@ampproject/remapping/-/remapping-2.3.0.tgz",
-      "integrity": "sha512-30iZtAPgz+LTIYoeivqYo853f02jBYSd5uGnGpkFV0M3xOt9aN73erkgYAmZU43x4VfqcnLxW9Kpg3R5LC4YYw==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@jridgewell/gen-mapping": "^0.3.5",
-        "@jridgewell/trace-mapping": "^0.3.24"
-      },
-      "engines": {
-        "node": ">=6.0.0"
-      }
-    },
-    "node_modules/@angular-devkit/architect": {
-      "version": "0.2102.13",
-      "resolved": "https://registry.npmjs.org/@angular-devkit/architect/-/architect-0.2102.13.tgz",
-      "integrity": "sha512-fheyi0gPx6b7tT+WQ+ePlzdGqKjPLUK72wg5Z9pkVtQ5+VN/8yB9mlRlmoivngd2FeNG9wMeNynWZGYycnOWVw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@angular-devkit/core": "21.2.13",
-        "rxjs": "7.8.2"
-      },
-      "bin": {
-        "architect": "bin/cli.js"
-      },
-      "engines": {
-        "node": "^20.19.0 || ^22.12.0 || >=24.0.0",
-        "npm": "^6.11.0 || ^7.5.6 || >=8.0.0",
-        "yarn": ">= 1.13.0"
-      }
-    },
-    "node_modules/@angular-devkit/core": {
-      "version": "21.2.13",
-      "resolved": "https://registry.npmjs.org/@angular-devkit/core/-/core-21.2.13.tgz",
-      "integrity": "sha512-9jLaHcUr6BumIY9nCsBib1q62p259nf++gd2igYJ7mLm1w/0wEacsZ1cC8wCGEe6vx8a+DrD+EVCQ6zivePG2A==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ajv": "8.18.0",
-        "ajv-formats": "3.0.1",
-        "jsonc-parser": "3.3.1",
-        "picomatch": "4.0.4",
-        "rxjs": "7.8.2",
-        "source-map": "0.7.6"
-      },
-      "engines": {
-        "node": "^20.19.0 || ^22.12.0 || >=24.0.0",
-        "npm": "^6.11.0 || ^7.5.6 || >=8.0.0",
-        "yarn": ">= 1.13.0"
-      },
-      "peerDependencies": {
-        "chokidar": "^5.0.0"
-      },
-      "peerDependenciesMeta": {
-        "chokidar": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/@angular-devkit/schematics": {
-      "version": "21.2.13",
-      "resolved": "https://registry.npmjs.org/@angular-devkit/schematics/-/schematics-21.2.13.tgz",
-      "integrity": "sha512-gifpOcMNiAy49lQmQKhzpxoSfS3qJQSEdJSF5m7RVFkAcmllfcCD76GPN4dhho3wdAnbZ3qr54LtDqrGY4xNjw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@angular-devkit/core": "21.2.13",
-        "jsonc-parser": "3.3.1",
-        "magic-string": "0.30.21",
-        "ora": "9.3.0",
-        "rxjs": "7.8.2"
-      },
-      "engines": {
-        "node": "^20.19.0 || ^22.12.0 || >=24.0.0",
-        "npm": "^6.11.0 || ^7.5.6 || >=8.0.0",
-        "yarn": ">= 1.13.0"
-      }
-    },
-    "node_modules/@angular/animations": {
-      "version": "21.2.15",
-      "resolved": "https://registry.npmjs.org/@angular/animations/-/animations-21.2.15.tgz",
-      "integrity": "sha512-Z8AsLTwc++Fcu0fJnclAF9zMfumAd5KXrwtSdyECqLpqd+lEmmsOpeOl6P7loqdDz99KYh/8UF4eJxdMvnsaKw==",
-      "license": "MIT",
-      "dependencies": {
-        "tslib": "^2.3.0"
-      },
-      "engines": {
-        "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
-      },
-      "peerDependencies": {
-        "@angular/core": "21.2.15"
-      }
-    },
-    "node_modules/@angular/build": {
-      "version": "21.2.13",
-      "resolved": "https://registry.npmjs.org/@angular/build/-/build-21.2.13.tgz",
-      "integrity": "sha512-Y9TDAaTQ+E5LScCKA/hPZmns/7Mpu6J2BiPj2cETA1xNjvgRpeb5Mh32KuhZb20NSFLvjpdnLuBTTtbym7hevw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@ampproject/remapping": "2.3.0",
-        "@angular-devkit/architect": "0.2102.13",
-        "@babel/core": "7.29.0",
-        "@babel/helper-annotate-as-pure": "7.27.3",
-        "@babel/helper-split-export-declaration": "7.24.7",
-        "@inquirer/confirm": "5.1.21",
-        "@vitejs/plugin-basic-ssl": "2.1.4",
-        "beasties": "0.4.1",
-        "browserslist": "^4.26.0",
-        "esbuild": "0.27.3",
-        "https-proxy-agent": "7.0.6",
-        "istanbul-lib-instrument": "6.0.3",
-        "jsonc-parser": "3.3.1",
-        "listr2": "9.0.5",
-        "magic-string": "0.30.21",
-        "mrmime": "2.0.1",
-        "parse5-html-rewriting-stream": "8.0.0",
-        "picomatch": "4.0.4",
-        "piscina": "5.1.4",
-        "rolldown": "1.0.0-rc.4",
-        "sass": "1.97.3",
-        "semver": "7.7.4",
-        "source-map-support": "0.5.21",
-        "tinyglobby": "0.2.15",
-        "undici": "7.24.4",
-        "vite": "7.3.2",
-        "watchpack": "2.5.1"
-      },
-      "engines": {
-        "node": "^20.19.0 || ^22.12.0 || >=24.0.0",
-        "npm": "^6.11.0 || ^7.5.6 || >=8.0.0",
-        "yarn": ">= 1.13.0"
-      },
-      "optionalDependencies": {
-        "lmdb": "3.5.1"
-      },
-      "peerDependencies": {
-        "@angular/compiler": "^21.0.0",
-        "@angular/compiler-cli": "^21.0.0",
-        "@angular/core": "^21.0.0",
-        "@angular/localize": "^21.0.0",
-        "@angular/platform-browser": "^21.0.0",
-        "@angular/platform-server": "^21.0.0",
-        "@angular/service-worker": "^21.0.0",
-        "@angular/ssr": "^21.2.13",
-        "karma": "^6.4.0",
-        "less": "^4.2.0",
-        "ng-packagr": "^21.0.0",
-        "postcss": "^8.4.0",
-        "tailwindcss": "^2.0.0 || ^3.0.0 || ^4.0.0",
-        "tslib": "^2.3.0",
-        "typescript": ">=5.9 <6.0",
-        "vitest": "^4.0.8"
-      },
-      "peerDependenciesMeta": {
-        "@angular/core": {
-          "optional": true
-        },
-        "@angular/localize": {
-          "optional": true
-        },
-        "@angular/platform-browser": {
-          "optional": true
-        },
-        "@angular/platform-server": {
-          "optional": true
-        },
-        "@angular/service-worker": {
-          "optional": true
-        },
-        "@angular/ssr": {
-          "optional": true
-        },
-        "karma": {
-          "optional": true
-        },
-        "less": {
-          "optional": true
-        },
-        "ng-packagr": {
-          "optional": true
-        },
-        "postcss": {
-          "optional": true
-        },
-        "tailwindcss": {
-          "optional": true
-        },
-        "vitest": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/@angular/cdk": {
-      "version": "21.2.13",
-      "resolved": "https://registry.npmjs.org/@angular/cdk/-/cdk-21.2.13.tgz",
-      "integrity": "sha512-nQGGJ6Efqi8n0qhT/PllsaIIY+vz+TL7/tpR7F2QKiqzS/9l4m7ea0vvS6fSMGrjEbqbkzTHbjLDsIg6X2hK+w==",
-      "license": "MIT",
-      "dependencies": {
-        "parse5": "^8.0.0",
-        "tslib": "^2.3.0"
-      },
-      "peerDependencies": {
-        "@angular/common": "^21.0.0 || ^22.0.0",
-        "@angular/core": "^21.0.0 || ^22.0.0",
-        "@angular/platform-browser": "^21.0.0 || ^22.0.0",
-        "rxjs": "^6.5.3 || ^7.4.0"
-      }
-    },
-    "node_modules/@angular/cli": {
-      "version": "21.2.13",
-      "resolved": "https://registry.npmjs.org/@angular/cli/-/cli-21.2.13.tgz",
-      "integrity": "sha512-j1kOV/f0og/3xCwG7Y8RyPd6V7uYfX2NuvXbvN1mzgxLLN2mu6CTsvPg5l/9Pu9SJI3KOPRgDxWyuP3k8KuzMg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@angular-devkit/architect": "0.2102.13",
-        "@angular-devkit/core": "21.2.13",
-        "@angular-devkit/schematics": "21.2.13",
-        "@inquirer/prompts": "7.10.1",
-        "@listr2/prompt-adapter-inquirer": "3.0.5",
-        "@modelcontextprotocol/sdk": "1.26.0",
-        "@schematics/angular": "21.2.13",
-        "@yarnpkg/lockfile": "1.1.0",
-        "algoliasearch": "5.48.1",
-        "ini": "6.0.0",
-        "jsonc-parser": "3.3.1",
-        "listr2": "9.0.5",
-        "npm-package-arg": "13.0.2",
-        "pacote": "21.3.1",
-        "parse5-html-rewriting-stream": "8.0.0",
-        "semver": "7.7.4",
-        "yargs": "18.0.0",
-        "zod": "4.3.6"
-      },
-      "bin": {
-        "ng": "bin/ng.js"
-      },
-      "engines": {
-        "node": "^20.19.0 || ^22.12.0 || >=24.0.0",
-        "npm": "^6.11.0 || ^7.5.6 || >=8.0.0",
-        "yarn": ">= 1.13.0"
-      }
-    },
-    "node_modules/@angular/common": {
-      "version": "21.2.15",
-      "resolved": "https://registry.npmjs.org/@angular/common/-/common-21.2.15.tgz",
-      "integrity": "sha512-PHbICQe4YCXnax2FcmKUpiffs8XPW9A0KlZF35qgJoQyBMBZx5F8c8geCh25jxtq77n3eBTmOa/WIAdSqiitkQ==",
-      "license": "MIT",
-      "dependencies": {
-        "tslib": "^2.3.0"
-      },
-      "engines": {
-        "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
-      },
-      "peerDependencies": {
-        "@angular/core": "21.2.15",
-        "rxjs": "^6.5.3 || ^7.4.0"
-      }
-    },
-    "node_modules/@angular/compiler": {
-      "version": "21.2.15",
-      "resolved": "https://registry.npmjs.org/@angular/compiler/-/compiler-21.2.15.tgz",
-      "integrity": "sha512-nwpNb+NbVUNzR3cck0QXbU/oFK7BpmXOXVnN/w7+P4+TsFUYeTtO1Ojbc15jkqe6mSM0lBvGlcoztVblHQkqcw==",
-      "license": "MIT",
-      "dependencies": {
-        "tslib": "^2.3.0"
-      },
-      "engines": {
-        "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
-      }
-    },
-    "node_modules/@angular/compiler-cli": {
-      "version": "21.2.15",
-      "resolved": "https://registry.npmjs.org/@angular/compiler-cli/-/compiler-cli-21.2.15.tgz",
-      "integrity": "sha512-/MU7OA9d/e9P5SthR+N6JJObBmzcGsgNQaeQ2YfSUnU0lCRVQweTWwxLFDbfU6UX8MZFWB6pdI57zod8r5kXUw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/core": "7.29.0",
-        "@jridgewell/sourcemap-codec": "^1.4.14",
-        "chokidar": "^5.0.0",
-        "convert-source-map": "^1.5.1",
-        "reflect-metadata": "^0.2.0",
-        "semver": "^7.0.0",
-        "tslib": "^2.3.0",
-        "yargs": "^18.0.0"
-      },
-      "bin": {
-        "ng-xi18n": "bundles/src/bin/ng_xi18n.js",
-        "ngc": "bundles/src/bin/ngc.js"
-      },
-      "engines": {
-        "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
-      },
-      "peerDependencies": {
-        "@angular/compiler": "21.2.15",
-        "typescript": ">=5.9 <6.1"
-      },
-      "peerDependenciesMeta": {
-        "typescript": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/@angular/core": {
-      "version": "21.2.15",
-      "resolved": "https://registry.npmjs.org/@angular/core/-/core-21.2.15.tgz",
-      "integrity": "sha512-J5JsUnNtQURdeA7EA3DoCsMBizW3l01gfqM326Al72Ou3woFWmRb5P3LOXpIOzAeMQhO6Z5tW+B1t+4qmoq7uw==",
-      "license": "MIT",
-      "dependencies": {
-        "tslib": "^2.3.0"
-      },
-      "engines": {
-        "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
-      },
-      "peerDependencies": {
-        "@angular/compiler": "21.2.15",
-        "rxjs": "^6.5.3 || ^7.4.0",
-        "zone.js": "~0.15.0 || ~0.16.0"
-      },
-      "peerDependenciesMeta": {
-        "@angular/compiler": {
-          "optional": true
-        },
-        "zone.js": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/@angular/forms": {
-      "version": "21.2.15",
-      "resolved": "https://registry.npmjs.org/@angular/forms/-/forms-21.2.15.tgz",
-      "integrity": "sha512-swGUHgbBrPNvODPR9qBP6+vT2EHiyW361iEgS3HpTmvDhF/kD4l8NE0vh3P5N0DnEtGh4umOCKfQ1w6hPJ7lqA==",
-      "license": "MIT",
-      "dependencies": {
-        "@standard-schema/spec": "^1.0.0",
-        "tslib": "^2.3.0"
-      },
-      "engines": {
-        "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
-      },
-      "peerDependencies": {
-        "@angular/common": "21.2.15",
-        "@angular/core": "21.2.15",
-        "@angular/platform-browser": "21.2.15",
-        "rxjs": "^6.5.3 || ^7.4.0"
-      }
-    },
-    "node_modules/@angular/material": {
-      "version": "21.2.13",
-      "resolved": "https://registry.npmjs.org/@angular/material/-/material-21.2.13.tgz",
-      "integrity": "sha512-6gWFb9LNh4cRIvkdocktej6MUVuGa9HQvap+j9gbZOtiveD7ER+FByUPlLlypreRebF29G2MRZeshKSdmv4NbA==",
-      "license": "MIT",
-      "dependencies": {
-        "tslib": "^2.3.0"
-      },
-      "peerDependencies": {
-        "@angular/cdk": "21.2.13",
-        "@angular/common": "^21.0.0 || ^22.0.0",
-        "@angular/core": "^21.0.0 || ^22.0.0",
-        "@angular/forms": "^21.0.0 || ^22.0.0",
-        "@angular/platform-browser": "^21.0.0 || ^22.0.0",
-        "rxjs": "^6.5.3 || ^7.4.0"
-      }
-    },
-    "node_modules/@angular/platform-browser": {
-      "version": "21.2.15",
-      "resolved": "https://registry.npmjs.org/@angular/platform-browser/-/platform-browser-21.2.15.tgz",
-      "integrity": "sha512-O4ZHVV/rxkK1AuiD9M3UssL/HkoQvBcZy2+U421IMNibclGhwH9aRwc/0ZlQ7zpseS9+KPZ23FebvN4/92IbPg==",
-      "license": "MIT",
-      "dependencies": {
-        "tslib": "^2.3.0"
-      },
-      "engines": {
-        "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
-      },
-      "peerDependencies": {
-        "@angular/animations": "21.2.15",
-        "@angular/common": "21.2.15",
-        "@angular/core": "21.2.15"
-      },
-      "peerDependenciesMeta": {
-        "@angular/animations": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/@angular/router": {
-      "version": "21.2.15",
-      "resolved": "https://registry.npmjs.org/@angular/router/-/router-21.2.15.tgz",
-      "integrity": "sha512-Cej4hYkmaTB6wXn1xQPlr4O1wHgUD0WLv//Oue1IssKqL8vkzic5f5x/H/bxtxxGlSnc+i6uIUF/lvjdGoWk/A==",
-      "license": "MIT",
-      "dependencies": {
-        "tslib": "^2.3.0"
-      },
-      "engines": {
-        "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
-      },
-      "peerDependencies": {
-        "@angular/common": "21.2.15",
-        "@angular/core": "21.2.15",
-        "@angular/platform-browser": "21.2.15",
-        "rxjs": "^6.5.3 || ^7.4.0"
-      }
-    },
-    "node_modules/@babel/code-frame": {
-      "version": "7.29.7",
-      "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.29.7.tgz",
-      "integrity": "sha512-Aup7aUOfpbAUg2ROOJN6Iw5f9DMBlzu0mIkm/malLQFN/YQgO48wCj0Kxa3sEHJvPVFg7siR+qRInwXd2qhQKw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/helper-validator-identifier": "^7.29.7",
-        "js-tokens": "^4.0.0",
-        "picocolors": "^1.1.1"
-      },
-      "engines": {
-        "node": ">=6.9.0"
-      }
-    },
-    "node_modules/@babel/compat-data": {
-      "version": "7.29.7",
-      "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.29.7.tgz",
-      "integrity": "sha512-locTkQyKvwIEgBzVrn8693ebc97F2U8ZHjbXwDXJ5Fn2TCpNwTlKcaKLkdHop5c/icOFE7qt7Q9JC5hnKNa6Gg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=6.9.0"
-      }
-    },
-    "node_modules/@babel/core": {
-      "version": "7.29.0",
-      "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.29.0.tgz",
-      "integrity": "sha512-CGOfOJqWjg2qW/Mb6zNsDm+u5vFQ8DxXfbM09z69p5Z6+mE1ikP2jUXw+j42Pf1XTYED2Rni5f95npYeuwMDQA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/code-frame": "^7.29.0",
-        "@babel/generator": "^7.29.0",
-        "@babel/helper-compilation-targets": "^7.28.6",
-        "@babel/helper-module-transforms": "^7.28.6",
-        "@babel/helpers": "^7.28.6",
-        "@babel/parser": "^7.29.0",
-        "@babel/template": "^7.28.6",
-        "@babel/traverse": "^7.29.0",
-        "@babel/types": "^7.29.0",
-        "@jridgewell/remapping": "^2.3.5",
-        "convert-source-map": "^2.0.0",
-        "debug": "^4.1.0",
-        "gensync": "^1.0.0-beta.2",
-        "json5": "^2.2.3",
-        "semver": "^6.3.1"
-      },
-      "engines": {
-        "node": ">=6.9.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/babel"
-      }
-    },
-    "node_modules/@babel/core/node_modules/convert-source-map": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-2.0.0.tgz",
-      "integrity": "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@babel/core/node_modules/semver": {
-      "version": "6.3.1",
-      "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz",
-      "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==",
-      "dev": true,
-      "license": "ISC",
-      "bin": {
-        "semver": "bin/semver.js"
-      }
-    },
-    "node_modules/@babel/generator": {
-      "version": "7.29.7",
-      "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.29.7.tgz",
-      "integrity": "sha512-DkXD5OJQaAQIdZ1bt3UZdEnHAn9Imd3IVBdX03UFe+ony9Ojw5pzr9YVKGDY1jt+Gcn/FnGkNf8r+Vj5NOJWtQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/parser": "^7.29.7",
-        "@babel/types": "^7.29.7",
-        "@jridgewell/gen-mapping": "^0.3.12",
-        "@jridgewell/trace-mapping": "^0.3.28",
-        "jsesc": "^3.0.2"
-      },
-      "engines": {
-        "node": ">=6.9.0"
-      }
-    },
-    "node_modules/@babel/helper-annotate-as-pure": {
-      "version": "7.27.3",
-      "resolved": "https://registry.npmjs.org/@babel/helper-annotate-as-pure/-/helper-annotate-as-pure-7.27.3.tgz",
-      "integrity": "sha512-fXSwMQqitTGeHLBC08Eq5yXz2m37E4pJX1qAU1+2cNedz/ifv/bVXft90VeSav5nFO61EcNgwr0aJxbyPaWBPg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/types": "^7.27.3"
-      },
-      "engines": {
-        "node": ">=6.9.0"
-      }
-    },
-    "node_modules/@babel/helper-compilation-targets": {
-      "version": "7.29.7",
-      "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.29.7.tgz",
-      "integrity": "sha512-wem6WaBj4NaVYVdNhLPPVacES6ZJ+KBBfSkTMD3YZxbP3rm3Di85tJU5ljaUNhaOynt+Aj0xruhYuzQBt8n71g==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/compat-data": "^7.29.7",
-        "@babel/helper-validator-option": "^7.29.7",
-        "browserslist": "^4.24.0",
-        "lru-cache": "^5.1.1",
-        "semver": "^6.3.1"
-      },
-      "engines": {
-        "node": ">=6.9.0"
-      }
-    },
-    "node_modules/@babel/helper-compilation-targets/node_modules/semver": {
-      "version": "6.3.1",
-      "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz",
-      "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==",
-      "dev": true,
-      "license": "ISC",
-      "bin": {
-        "semver": "bin/semver.js"
-      }
-    },
-    "node_modules/@babel/helper-globals": {
-      "version": "7.29.7",
-      "resolved": "https://registry.npmjs.org/@babel/helper-globals/-/helper-globals-7.29.7.tgz",
-      "integrity": "sha512-3nQVUAtvkKH9zahfWgw96Jc/uFOmjACE1kQz82E2lqWmHBgjzbNlsC22nuQTfahmWeQtTq5nQ/4Nnd2A1wj4zA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=6.9.0"
-      }
-    },
-    "node_modules/@babel/helper-module-imports": {
-      "version": "7.29.7",
-      "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.29.7.tgz",
-      "integrity": "sha512-ejHwrQQYcm9xnTivShn2IDOlIzInN34AXskvq9QicvCtEzq1Vzclu/tKF8Jq1Cg8JG2GL6/EmjgsCT7lXepE3g==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/traverse": "^7.29.7",
-        "@babel/types": "^7.29.7"
-      },
-      "engines": {
-        "node": ">=6.9.0"
-      }
-    },
-    "node_modules/@babel/helper-module-transforms": {
-      "version": "7.29.7",
-      "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.29.7.tgz",
-      "integrity": "sha512-UPUVSyXbOh627KiCIGQSgwWzGeBKLkaJ9PJEdrngIwMSzxLR4jS4+f1f1jb7VzBbg8nFLaYotvVPFCTqdrmTAg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/helper-module-imports": "^7.29.7",
-        "@babel/helper-validator-identifier": "^7.29.7",
-        "@babel/traverse": "^7.29.7"
-      },
-      "engines": {
-        "node": ">=6.9.0"
-      },
-      "peerDependencies": {
-        "@babel/core": "^7.0.0"
-      }
-    },
-    "node_modules/@babel/helper-split-export-declaration": {
-      "version": "7.24.7",
-      "resolved": "https://registry.npmjs.org/@babel/helper-split-export-declaration/-/helper-split-export-declaration-7.24.7.tgz",
-      "integrity": "sha512-oy5V7pD+UvfkEATUKvIjvIAH/xCzfsFVw7ygW2SI6NClZzquT+mwdTfgfdbUiceh6iQO0CHtCPsyze/MZ2YbAA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/types": "^7.24.7"
-      },
-      "engines": {
-        "node": ">=6.9.0"
-      }
-    },
-    "node_modules/@babel/helper-string-parser": {
-      "version": "7.29.7",
-      "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.29.7.tgz",
-      "integrity": "sha512-Pb5ijPrZ89GDH8223L4UP8i6QApWxs04RbPQJTeWDV0/keR2E36MeKnyr6LYmUUvqRRI+Iv87SuF1W6ErINzYw==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=6.9.0"
-      }
-    },
-    "node_modules/@babel/helper-validator-identifier": {
-      "version": "7.29.7",
-      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.29.7.tgz",
-      "integrity": "sha512-qehxGkRj55h/ff8EMaJ+cYhyaKlHIxqYDn682wQD7RNp9UujOQsHog2uS0r2vzr4pW+sXf90NeeayjcNaX3fFg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=6.9.0"
-      }
-    },
-    "node_modules/@babel/helper-validator-option": {
-      "version": "7.29.7",
-      "resolved": "https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-7.29.7.tgz",
-      "integrity": "sha512-N9ZErrD+yW5geCDtBqnOoxmR8+tNKiGuxKlDpuJxfsqpa2dFcexaziGAE/qoHLiDDreVNMupxGmSoNlyvsA3gw==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=6.9.0"
-      }
-    },
-    "node_modules/@babel/helpers": {
-      "version": "7.29.7",
-      "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.29.7.tgz",
-      "integrity": "sha512-1k2lAGRMfHTcwuNYcCNUmaUffmQv8KWMfh2iJUUeRlwlwH4FdNG7mfPI10NPfLHJFThE4Tyr4mv7kTNZOiPuBg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/template": "^7.29.7",
-        "@babel/types": "^7.29.7"
-      },
-      "engines": {
-        "node": ">=6.9.0"
-      }
-    },
-    "node_modules/@babel/parser": {
-      "version": "7.29.7",
-      "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.29.7.tgz",
-      "integrity": "sha512-hnORnjP/1P/zFEndoeX+n+t1RwWRJiJpM/jO7FW32Kn9r5+sJB2JWOdYo4L6k78j15eCwY3Gm/7364B1EMwtNg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/types": "^7.29.7"
-      },
-      "bin": {
-        "parser": "bin/babel-parser.js"
-      },
-      "engines": {
-        "node": ">=6.0.0"
-      }
-    },
-    "node_modules/@babel/template": {
-      "version": "7.29.7",
-      "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.29.7.tgz",
-      "integrity": "sha512-puq+Gf35oI24FeN11LkoUQFqv9uwNeWpxXZi/Ji3rRIoKAzKnxRaZ+Gkj0vKS9ZCiTESfng1N9LyOyXvo+m+Gg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/code-frame": "^7.29.7",
-        "@babel/parser": "^7.29.7",
-        "@babel/types": "^7.29.7"
-      },
-      "engines": {
-        "node": ">=6.9.0"
-      }
-    },
-    "node_modules/@babel/traverse": {
-      "version": "7.29.7",
-      "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.29.7.tgz",
-      "integrity": "sha512-EhlfNQtZ+NK22w5BM61ciuiq1m58ed33Wr1Xan//ZRTy6hgjnwyCffRYwzsGXdASJSUJ1guZILsErh1eQcl+zw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/code-frame": "^7.29.7",
-        "@babel/generator": "^7.29.7",
-        "@babel/helper-globals": "^7.29.7",
-        "@babel/parser": "^7.29.7",
-        "@babel/template": "^7.29.7",
-        "@babel/types": "^7.29.7",
-        "debug": "^4.3.1"
-      },
-      "engines": {
-        "node": ">=6.9.0"
-      }
-    },
-    "node_modules/@babel/types": {
-      "version": "7.29.7",
-      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.29.7.tgz",
-      "integrity": "sha512-4zBIxpPzowiZpusoFkyGVwakdRJUyuH5PxQ/PrqghfdFWWasvnCdPfQXHrenDai+gyLARulZjZowCOj6fjT4pA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@babel/helper-string-parser": "^7.29.7",
-        "@babel/helper-validator-identifier": "^7.29.7"
-      },
-      "engines": {
-        "node": ">=6.9.0"
-      }
-    },
-    "node_modules/@dimforge/rapier3d-compat": {
-      "version": "0.12.0",
-      "resolved": "https://registry.npmjs.org/@dimforge/rapier3d-compat/-/rapier3d-compat-0.12.0.tgz",
-      "integrity": "sha512-uekIGetywIgopfD97oDL5PfeezkFpNhwlzlaEYNOA0N6ghdsOvh/HYjSMek5Q2O1PYvRSDFcqFVJl4r4ZBwOow==",
-      "dev": true,
-      "license": "Apache-2.0"
-    },
-    "node_modules/@emnapi/core": {
-      "version": "1.10.0",
-      "resolved": "https://registry.npmjs.org/@emnapi/core/-/core-1.10.0.tgz",
-      "integrity": "sha512-yq6OkJ4p82CAfPl0u9mQebQHKPJkY7WrIuk205cTYnYe+k2Z8YBh11FrbRG/H6ihirqcacOgl2BIO8oyMQLeXw==",
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "peer": true,
-      "dependencies": {
-        "@emnapi/wasi-threads": "1.2.1",
-        "tslib": "^2.4.0"
-      }
-    },
-    "node_modules/@emnapi/runtime": {
-      "version": "1.10.0",
-      "resolved": "https://registry.npmjs.org/@emnapi/runtime/-/runtime-1.10.0.tgz",
-      "integrity": "sha512-ewvYlk86xUoGI0zQRNq/mC+16R1QeDlKQy21Ki3oSYXNgLb45GV1P6A0M+/s6nyCuNDqe5VpaY84BzXGwVbwFA==",
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "peer": true,
-      "dependencies": {
-        "tslib": "^2.4.0"
-      }
-    },
-    "node_modules/@emnapi/wasi-threads": {
-      "version": "1.2.1",
-      "resolved": "https://registry.npmjs.org/@emnapi/wasi-threads/-/wasi-threads-1.2.1.tgz",
-      "integrity": "sha512-uTII7OYF+/Mes/MrcIOYp5yOtSMLBWSIoLPpcgwipoiKbli6k322tcoFsxoIIxPDqW01SQGAgko4EzZi2BNv2w==",
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "peer": true,
-      "dependencies": {
-        "tslib": "^2.4.0"
-      }
-    },
-    "node_modules/@esbuild/aix-ppc64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.27.3.tgz",
-      "integrity": "sha512-9fJMTNFTWZMh5qwrBItuziu834eOCUcEqymSH7pY+zoMVEZg3gcPuBNxH1EvfVYe9h0x/Ptw8KBzv7qxb7l8dg==",
-      "cpu": [
-        "ppc64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "aix"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/android-arm": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.27.3.tgz",
-      "integrity": "sha512-i5D1hPY7GIQmXlXhs2w8AWHhenb00+GxjxRncS2ZM7YNVGNfaMxgzSGuO8o8SJzRc/oZwU2bcScvVERk03QhzA==",
-      "cpu": [
-        "arm"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "android"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/android-arm64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.27.3.tgz",
-      "integrity": "sha512-YdghPYUmj/FX2SYKJ0OZxf+iaKgMsKHVPF1MAq/P8WirnSpCStzKJFjOjzsW0QQ7oIAiccHdcqjbHmJxRb/dmg==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "android"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/android-x64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.27.3.tgz",
-      "integrity": "sha512-IN/0BNTkHtk8lkOM8JWAYFg4ORxBkZQf9zXiEOfERX/CzxW3Vg1ewAhU7QSWQpVIzTW+b8Xy+lGzdYXV6UZObQ==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "android"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/darwin-arm64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.27.3.tgz",
-      "integrity": "sha512-Re491k7ByTVRy0t3EKWajdLIr0gz2kKKfzafkth4Q8A5n1xTHrkqZgLLjFEHVD+AXdUGgQMq+Godfq45mGpCKg==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "darwin"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/darwin-x64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.27.3.tgz",
-      "integrity": "sha512-vHk/hA7/1AckjGzRqi6wbo+jaShzRowYip6rt6q7VYEDX4LEy1pZfDpdxCBnGtl+A5zq8iXDcyuxwtv3hNtHFg==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "darwin"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/freebsd-arm64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.27.3.tgz",
-      "integrity": "sha512-ipTYM2fjt3kQAYOvo6vcxJx3nBYAzPjgTCk7QEgZG8AUO3ydUhvelmhrbOheMnGOlaSFUoHXB6un+A7q4ygY9w==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "freebsd"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/freebsd-x64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.27.3.tgz",
-      "integrity": "sha512-dDk0X87T7mI6U3K9VjWtHOXqwAMJBNN2r7bejDsc+j03SEjtD9HrOl8gVFByeM0aJksoUuUVU9TBaZa2rgj0oA==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "freebsd"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/linux-arm": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.27.3.tgz",
-      "integrity": "sha512-s6nPv2QkSupJwLYyfS+gwdirm0ukyTFNl3KTgZEAiJDd+iHZcbTPPcWCcRYH+WlNbwChgH2QkE9NSlNrMT8Gfw==",
-      "cpu": [
-        "arm"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/linux-arm64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.27.3.tgz",
-      "integrity": "sha512-sZOuFz/xWnZ4KH3YfFrKCf1WyPZHakVzTiqji3WDc0BCl2kBwiJLCXpzLzUBLgmp4veFZdvN5ChW4Eq/8Fc2Fg==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/linux-ia32": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.27.3.tgz",
-      "integrity": "sha512-yGlQYjdxtLdh0a3jHjuwOrxQjOZYD/C9PfdbgJJF3TIZWnm/tMd/RcNiLngiu4iwcBAOezdnSLAwQDPqTmtTYg==",
-      "cpu": [
-        "ia32"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/linux-loong64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.27.3.tgz",
-      "integrity": "sha512-WO60Sn8ly3gtzhyjATDgieJNet/KqsDlX5nRC5Y3oTFcS1l0KWba+SEa9Ja1GfDqSF1z6hif/SkpQJbL63cgOA==",
-      "cpu": [
-        "loong64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/linux-mips64el": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.27.3.tgz",
-      "integrity": "sha512-APsymYA6sGcZ4pD6k+UxbDjOFSvPWyZhjaiPyl/f79xKxwTnrn5QUnXR5prvetuaSMsb4jgeHewIDCIWljrSxw==",
-      "cpu": [
-        "mips64el"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/linux-ppc64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.27.3.tgz",
-      "integrity": "sha512-eizBnTeBefojtDb9nSh4vvVQ3V9Qf9Df01PfawPcRzJH4gFSgrObw+LveUyDoKU3kxi5+9RJTCWlj4FjYXVPEA==",
-      "cpu": [
-        "ppc64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/linux-riscv64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.27.3.tgz",
-      "integrity": "sha512-3Emwh0r5wmfm3ssTWRQSyVhbOHvqegUDRd0WhmXKX2mkHJe1SFCMJhagUleMq+Uci34wLSipf8Lagt4LlpRFWQ==",
-      "cpu": [
-        "riscv64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/linux-s390x": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.27.3.tgz",
-      "integrity": "sha512-pBHUx9LzXWBc7MFIEEL0yD/ZVtNgLytvx60gES28GcWMqil8ElCYR4kvbV2BDqsHOvVDRrOxGySBM9Fcv744hw==",
-      "cpu": [
-        "s390x"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/linux-x64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.27.3.tgz",
-      "integrity": "sha512-Czi8yzXUWIQYAtL/2y6vogER8pvcsOsk5cpwL4Gk5nJqH5UZiVByIY8Eorm5R13gq+DQKYg0+JyQoytLQas4dA==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/netbsd-arm64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.27.3.tgz",
-      "integrity": "sha512-sDpk0RgmTCR/5HguIZa9n9u+HVKf40fbEUt+iTzSnCaGvY9kFP0YKBWZtJaraonFnqef5SlJ8/TiPAxzyS+UoA==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "netbsd"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/netbsd-x64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.27.3.tgz",
-      "integrity": "sha512-P14lFKJl/DdaE00LItAukUdZO5iqNH7+PjoBm+fLQjtxfcfFE20Xf5CrLsmZdq5LFFZzb5JMZ9grUwvtVYzjiA==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "netbsd"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/openbsd-arm64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.27.3.tgz",
-      "integrity": "sha512-AIcMP77AvirGbRl/UZFTq5hjXK+2wC7qFRGoHSDrZ5v5b8DK/GYpXW3CPRL53NkvDqb9D+alBiC/dV0Fb7eJcw==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "openbsd"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/openbsd-x64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.27.3.tgz",
-      "integrity": "sha512-DnW2sRrBzA+YnE70LKqnM3P+z8vehfJWHXECbwBmH/CU51z6FiqTQTHFenPlHmo3a8UgpLyH3PT+87OViOh1AQ==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "openbsd"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/openharmony-arm64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.27.3.tgz",
-      "integrity": "sha512-NinAEgr/etERPTsZJ7aEZQvvg/A6IsZG/LgZy+81wON2huV7SrK3e63dU0XhyZP4RKGyTm7aOgmQk0bGp0fy2g==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "openharmony"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/sunos-x64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.27.3.tgz",
-      "integrity": "sha512-PanZ+nEz+eWoBJ8/f8HKxTTD172SKwdXebZ0ndd953gt1HRBbhMsaNqjTyYLGLPdoWHy4zLU7bDVJztF5f3BHA==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "sunos"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/win32-arm64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.27.3.tgz",
-      "integrity": "sha512-B2t59lWWYrbRDw/tjiWOuzSsFh1Y/E95ofKz7rIVYSQkUYBjfSgf6oeYPNWHToFRr2zx52JKApIcAS/D5TUBnA==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/win32-ia32": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.27.3.tgz",
-      "integrity": "sha512-QLKSFeXNS8+tHW7tZpMtjlNb7HKau0QDpwm49u0vUp9y1WOF+PEzkU84y9GqYaAVW8aH8f3GcBck26jh54cX4Q==",
-      "cpu": [
-        "ia32"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@esbuild/win32-x64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.27.3.tgz",
-      "integrity": "sha512-4uJGhsxuptu3OcpVAzli+/gWusVGwZZHTlS63hh++ehExkVT8SgiEf7/uC/PclrPPkLhZqGgCTjd0VWLo6xMqA==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ],
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@gar/promise-retry": {
-      "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/@gar/promise-retry/-/promise-retry-1.0.3.tgz",
-      "integrity": "sha512-GmzA9ckNokPypTg10pgpeHNQe7ph+iIKKmhKu3Ob9ANkswreCx7R3cKmY781K8QK3AqVL3xVh9A42JvIAbkkSA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": "^20.17.0 || >=22.9.0"
-      }
-    },
-    "node_modules/@harperfast/extended-iterable": {
-      "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/@harperfast/extended-iterable/-/extended-iterable-1.0.3.tgz",
-      "integrity": "sha512-sSAYhQca3rDWtQUHSAPeO7axFIUJOI6hn1gjRC5APVE1a90tuyT8f5WIgRsFhhWA7htNkju2veB9eWL6YHi/Lw==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "optional": true
-    },
-    "node_modules/@hono/node-server": {
-      "version": "1.19.14",
-      "resolved": "https://registry.npmjs.org/@hono/node-server/-/node-server-1.19.14.tgz",
-      "integrity": "sha512-GwtvgtXxnWsucXvbQXkRgqksiH2Qed37H9xHZocE5sA3N8O8O8/8FA3uclQXxXVzc9XBZuEOMK7+r02FmSpHtw==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=18.14.1"
-      },
-      "peerDependencies": {
-        "hono": "^4"
-      }
-    },
-    "node_modules/@inquirer/ansi": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/@inquirer/ansi/-/ansi-1.0.2.tgz",
-      "integrity": "sha512-S8qNSZiYzFd0wAcyG5AXCvUHC5Sr7xpZ9wZ2py9XR88jUz8wooStVx5M6dRzczbBWjic9NP7+rY0Xi7qqK/aMQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@inquirer/checkbox": {
-      "version": "4.3.2",
-      "resolved": "https://registry.npmjs.org/@inquirer/checkbox/-/checkbox-4.3.2.tgz",
-      "integrity": "sha512-VXukHf0RR1doGe6Sm4F0Em7SWYLTHSsbGfJdS9Ja2bX5/D5uwVOEjr07cncLROdBvmnvCATYEWlHqYmXv2IlQA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@inquirer/ansi": "^1.0.2",
-        "@inquirer/core": "^10.3.2",
-        "@inquirer/figures": "^1.0.15",
-        "@inquirer/type": "^3.0.10",
-        "yoctocolors-cjs": "^2.1.3"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "peerDependencies": {
-        "@types/node": ">=18"
-      },
-      "peerDependenciesMeta": {
-        "@types/node": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/@inquirer/confirm": {
-      "version": "5.1.21",
-      "resolved": "https://registry.npmjs.org/@inquirer/confirm/-/confirm-5.1.21.tgz",
-      "integrity": "sha512-KR8edRkIsUayMXV+o3Gv+q4jlhENF9nMYUZs9PA2HzrXeHI8M5uDag70U7RJn9yyiMZSbtF5/UexBtAVtZGSbQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@inquirer/core": "^10.3.2",
-        "@inquirer/type": "^3.0.10"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "peerDependencies": {
-        "@types/node": ">=18"
-      },
-      "peerDependenciesMeta": {
-        "@types/node": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/@inquirer/core": {
-      "version": "10.3.2",
-      "resolved": "https://registry.npmjs.org/@inquirer/core/-/core-10.3.2.tgz",
-      "integrity": "sha512-43RTuEbfP8MbKzedNqBrlhhNKVwoK//vUFNW3Q3vZ88BLcrs4kYpGg+B2mm5p2K/HfygoCxuKwJJiv8PbGmE0A==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@inquirer/ansi": "^1.0.2",
-        "@inquirer/figures": "^1.0.15",
-        "@inquirer/type": "^3.0.10",
-        "cli-width": "^4.1.0",
-        "mute-stream": "^2.0.0",
-        "signal-exit": "^4.1.0",
-        "wrap-ansi": "^6.2.0",
-        "yoctocolors-cjs": "^2.1.3"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "peerDependencies": {
-        "@types/node": ">=18"
-      },
-      "peerDependenciesMeta": {
-        "@types/node": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/@inquirer/editor": {
-      "version": "4.2.23",
-      "resolved": "https://registry.npmjs.org/@inquirer/editor/-/editor-4.2.23.tgz",
-      "integrity": "sha512-aLSROkEwirotxZ1pBaP8tugXRFCxW94gwrQLxXfrZsKkfjOYC1aRvAZuhpJOb5cu4IBTJdsCigUlf2iCOu4ZDQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@inquirer/core": "^10.3.2",
-        "@inquirer/external-editor": "^1.0.3",
-        "@inquirer/type": "^3.0.10"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "peerDependencies": {
-        "@types/node": ">=18"
-      },
-      "peerDependenciesMeta": {
-        "@types/node": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/@inquirer/expand": {
-      "version": "4.0.23",
-      "resolved": "https://registry.npmjs.org/@inquirer/expand/-/expand-4.0.23.tgz",
-      "integrity": "sha512-nRzdOyFYnpeYTTR2qFwEVmIWypzdAx/sIkCMeTNTcflFOovfqUk+HcFhQQVBftAh9gmGrpFj6QcGEqrDMDOiew==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@inquirer/core": "^10.3.2",
-        "@inquirer/type": "^3.0.10",
-        "yoctocolors-cjs": "^2.1.3"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "peerDependencies": {
-        "@types/node": ">=18"
-      },
-      "peerDependenciesMeta": {
-        "@types/node": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/@inquirer/external-editor": {
-      "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/@inquirer/external-editor/-/external-editor-1.0.3.tgz",
-      "integrity": "sha512-RWbSrDiYmO4LbejWY7ttpxczuwQyZLBUyygsA9Nsv95hpzUWwnNTVQmAq3xuh7vNwCp07UTmE5i11XAEExx4RA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "chardet": "^2.1.1",
-        "iconv-lite": "^0.7.0"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "peerDependencies": {
-        "@types/node": ">=18"
-      },
-      "peerDependenciesMeta": {
-        "@types/node": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/@inquirer/figures": {
-      "version": "1.0.15",
-      "resolved": "https://registry.npmjs.org/@inquirer/figures/-/figures-1.0.15.tgz",
-      "integrity": "sha512-t2IEY+unGHOzAaVM5Xx6DEWKeXlDDcNPeDyUpsRc6CUhBfU3VQOEl+Vssh7VNp1dR8MdUJBWhuObjXCsVpjN5g==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@inquirer/input": {
-      "version": "4.3.1",
-      "resolved": "https://registry.npmjs.org/@inquirer/input/-/input-4.3.1.tgz",
-      "integrity": "sha512-kN0pAM4yPrLjJ1XJBjDxyfDduXOuQHrBB8aLDMueuwUGn+vNpF7Gq7TvyVxx8u4SHlFFj4trmj+a2cbpG4Jn1g==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@inquirer/core": "^10.3.2",
-        "@inquirer/type": "^3.0.10"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "peerDependencies": {
-        "@types/node": ">=18"
-      },
-      "peerDependenciesMeta": {
-        "@types/node": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/@inquirer/number": {
-      "version": "3.0.23",
-      "resolved": "https://registry.npmjs.org/@inquirer/number/-/number-3.0.23.tgz",
-      "integrity": "sha512-5Smv0OK7K0KUzUfYUXDXQc9jrf8OHo4ktlEayFlelCjwMXz0299Y8OrI+lj7i4gCBY15UObk76q0QtxjzFcFcg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@inquirer/core": "^10.3.2",
-        "@inquirer/type": "^3.0.10"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "peerDependencies": {
-        "@types/node": ">=18"
-      },
-      "peerDependenciesMeta": {
-        "@types/node": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/@inquirer/password": {
-      "version": "4.0.23",
-      "resolved": "https://registry.npmjs.org/@inquirer/password/-/password-4.0.23.tgz",
-      "integrity": "sha512-zREJHjhT5vJBMZX/IUbyI9zVtVfOLiTO66MrF/3GFZYZ7T4YILW5MSkEYHceSii/KtRk+4i3RE7E1CUXA2jHcA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@inquirer/ansi": "^1.0.2",
-        "@inquirer/core": "^10.3.2",
-        "@inquirer/type": "^3.0.10"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "peerDependencies": {
-        "@types/node": ">=18"
-      },
-      "peerDependenciesMeta": {
-        "@types/node": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/@inquirer/prompts": {
-      "version": "7.10.1",
-      "resolved": "https://registry.npmjs.org/@inquirer/prompts/-/prompts-7.10.1.tgz",
-      "integrity": "sha512-Dx/y9bCQcXLI5ooQ5KyvA4FTgeo2jYj/7plWfV5Ak5wDPKQZgudKez2ixyfz7tKXzcJciTxqLeK7R9HItwiByg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@inquirer/checkbox": "^4.3.2",
-        "@inquirer/confirm": "^5.1.21",
-        "@inquirer/editor": "^4.2.23",
-        "@inquirer/expand": "^4.0.23",
-        "@inquirer/input": "^4.3.1",
-        "@inquirer/number": "^3.0.23",
-        "@inquirer/password": "^4.0.23",
-        "@inquirer/rawlist": "^4.1.11",
-        "@inquirer/search": "^3.2.2",
-        "@inquirer/select": "^4.4.2"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "peerDependencies": {
-        "@types/node": ">=18"
-      },
-      "peerDependenciesMeta": {
-        "@types/node": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/@inquirer/rawlist": {
-      "version": "4.1.11",
-      "resolved": "https://registry.npmjs.org/@inquirer/rawlist/-/rawlist-4.1.11.tgz",
-      "integrity": "sha512-+LLQB8XGr3I5LZN/GuAHo+GpDJegQwuPARLChlMICNdwW7OwV2izlCSCxN6cqpL0sMXmbKbFcItJgdQq5EBXTw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@inquirer/core": "^10.3.2",
-        "@inquirer/type": "^3.0.10",
-        "yoctocolors-cjs": "^2.1.3"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "peerDependencies": {
-        "@types/node": ">=18"
-      },
-      "peerDependenciesMeta": {
-        "@types/node": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/@inquirer/search": {
-      "version": "3.2.2",
-      "resolved": "https://registry.npmjs.org/@inquirer/search/-/search-3.2.2.tgz",
-      "integrity": "sha512-p2bvRfENXCZdWF/U2BXvnSI9h+tuA8iNqtUKb9UWbmLYCRQxd8WkvwWvYn+3NgYaNwdUkHytJMGG4MMLucI1kA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@inquirer/core": "^10.3.2",
-        "@inquirer/figures": "^1.0.15",
-        "@inquirer/type": "^3.0.10",
-        "yoctocolors-cjs": "^2.1.3"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "peerDependencies": {
-        "@types/node": ">=18"
-      },
-      "peerDependenciesMeta": {
-        "@types/node": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/@inquirer/select": {
-      "version": "4.4.2",
-      "resolved": "https://registry.npmjs.org/@inquirer/select/-/select-4.4.2.tgz",
-      "integrity": "sha512-l4xMuJo55MAe+N7Qr4rX90vypFwCajSakx59qe/tMaC1aEHWLyw68wF4o0A4SLAY4E0nd+Vt+EyskeDIqu1M6w==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@inquirer/ansi": "^1.0.2",
-        "@inquirer/core": "^10.3.2",
-        "@inquirer/figures": "^1.0.15",
-        "@inquirer/type": "^3.0.10",
-        "yoctocolors-cjs": "^2.1.3"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "peerDependencies": {
-        "@types/node": ">=18"
-      },
-      "peerDependenciesMeta": {
-        "@types/node": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/@inquirer/type": {
-      "version": "3.0.10",
-      "resolved": "https://registry.npmjs.org/@inquirer/type/-/type-3.0.10.tgz",
-      "integrity": "sha512-BvziSRxfz5Ov8ch0z/n3oijRSEcEsHnhggm4xFZe93DHcUCTlutlq9Ox4SVENAfcRD22UQq7T/atg9Wr3k09eA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=18"
-      },
-      "peerDependencies": {
-        "@types/node": ">=18"
-      },
-      "peerDependenciesMeta": {
-        "@types/node": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/@isaacs/fs-minipass": {
-      "version": "4.0.1",
-      "resolved": "https://registry.npmjs.org/@isaacs/fs-minipass/-/fs-minipass-4.0.1.tgz",
-      "integrity": "sha512-wgm9Ehl2jpeqP3zw/7mo3kRHFp5MEDhqAdwy1fTGkHAwnkGOVsgpvQhL8B5n1qlb01jV3n/bI0ZfZp5lWA1k4w==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "minipass": "^7.0.4"
-      },
-      "engines": {
-        "node": ">=18.0.0"
-      }
-    },
-    "node_modules/@istanbuljs/schema": {
-      "version": "0.1.6",
-      "resolved": "https://registry.npmjs.org/@istanbuljs/schema/-/schema-0.1.6.tgz",
-      "integrity": "sha512-+Sg6GCR/wy1oSmQDFq4LQDAhm3ETKnorxN+y5nbLULOR3P0c14f2Wurzj3/xqPXtasLFfHd5iRFQ7AJt4KH2cw==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/@jridgewell/gen-mapping": {
-      "version": "0.3.13",
-      "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz",
-      "integrity": "sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@jridgewell/sourcemap-codec": "^1.5.0",
-        "@jridgewell/trace-mapping": "^0.3.24"
-      }
-    },
-    "node_modules/@jridgewell/remapping": {
-      "version": "2.3.5",
-      "resolved": "https://registry.npmjs.org/@jridgewell/remapping/-/remapping-2.3.5.tgz",
-      "integrity": "sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@jridgewell/gen-mapping": "^0.3.5",
-        "@jridgewell/trace-mapping": "^0.3.24"
-      }
-    },
-    "node_modules/@jridgewell/resolve-uri": {
-      "version": "3.1.2",
-      "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz",
-      "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=6.0.0"
-      }
-    },
-    "node_modules/@jridgewell/sourcemap-codec": {
-      "version": "1.5.5",
-      "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz",
-      "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@jridgewell/trace-mapping": {
-      "version": "0.3.31",
-      "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz",
-      "integrity": "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@jridgewell/resolve-uri": "^3.1.0",
-        "@jridgewell/sourcemap-codec": "^1.4.14"
-      }
-    },
-    "node_modules/@listr2/prompt-adapter-inquirer": {
-      "version": "3.0.5",
-      "resolved": "https://registry.npmjs.org/@listr2/prompt-adapter-inquirer/-/prompt-adapter-inquirer-3.0.5.tgz",
-      "integrity": "sha512-WELs+hj6xcilkloBXYf9XXK8tYEnKsgLj01Xl5ONUJpKjmT5hGVUzNUS5tooUxs7pGMrw+jFD/41WpqW4V3LDA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@inquirer/type": "^3.0.8"
-      },
-      "engines": {
-        "node": ">=20.0.0"
-      },
-      "peerDependencies": {
-        "@inquirer/prompts": ">= 3 < 8",
-        "listr2": "9.0.5"
-      }
-    },
-    "node_modules/@lmdb/lmdb-darwin-arm64": {
-      "version": "3.5.1",
-      "resolved": "https://registry.npmjs.org/@lmdb/lmdb-darwin-arm64/-/lmdb-darwin-arm64-3.5.1.tgz",
-      "integrity": "sha512-tpfN4kKrrMpQ+If1l8bhmoNkECJi0iOu6AEdrTJvWVC+32sLxTARX5Rsu579mPImRP9YFWfWgeRQ5oav7zApQQ==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "darwin"
-      ]
-    },
-    "node_modules/@lmdb/lmdb-darwin-x64": {
-      "version": "3.5.1",
-      "resolved": "https://registry.npmjs.org/@lmdb/lmdb-darwin-x64/-/lmdb-darwin-x64-3.5.1.tgz",
-      "integrity": "sha512-+a2tTfc3rmWhLAolFUWRgJtpSuu+Fw/yjn4rF406NMxhfjbMuiOUTDRvRlMFV+DzyjkwnokisskHbCWkS3Ly5w==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "darwin"
-      ]
-    },
-    "node_modules/@lmdb/lmdb-linux-arm": {
-      "version": "3.5.1",
-      "resolved": "https://registry.npmjs.org/@lmdb/lmdb-linux-arm/-/lmdb-linux-arm-3.5.1.tgz",
-      "integrity": "sha512-0EgcE6reYr8InjD7V37EgXcYrloqpxVPINy3ig1MwDSbl6LF/vXTYRH9OE1Ti1D8YZnB35ZH9aTcdfSb5lql2A==",
-      "cpu": [
-        "arm"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
-    },
-    "node_modules/@lmdb/lmdb-linux-arm64": {
-      "version": "3.5.1",
-      "resolved": "https://registry.npmjs.org/@lmdb/lmdb-linux-arm64/-/lmdb-linux-arm64-3.5.1.tgz",
-      "integrity": "sha512-aoERa5B6ywXdyFeYGQ1gbQpkMkDbEo45qVoXE5QpIRavqjnyPwjOulMkmkypkmsbJ5z4Wi0TBztON8agCTG0Vg==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
-    },
-    "node_modules/@lmdb/lmdb-linux-x64": {
-      "version": "3.5.1",
-      "resolved": "https://registry.npmjs.org/@lmdb/lmdb-linux-x64/-/lmdb-linux-x64-3.5.1.tgz",
-      "integrity": "sha512-SqNDY1+vpji7bh0sFH5wlWyFTOzjbDOl0/kB5RLLYDAFyd/uw3n7wyrmas3rYPpAW7z18lMOi1yKlTPv967E3g==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
-    },
-    "node_modules/@lmdb/lmdb-win32-arm64": {
-      "version": "3.5.1",
-      "resolved": "https://registry.npmjs.org/@lmdb/lmdb-win32-arm64/-/lmdb-win32-arm64-3.5.1.tgz",
-      "integrity": "sha512-50v0O1Lt37cwrmR9vWZK5hRW0Aw+KEmxJJ75fge/zIYdvNKB/0bSMSVR5Uc2OV9JhosIUyklOmrEvavwNJ8D6w==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ]
-    },
-    "node_modules/@lmdb/lmdb-win32-x64": {
-      "version": "3.5.1",
-      "resolved": "https://registry.npmjs.org/@lmdb/lmdb-win32-x64/-/lmdb-win32-x64-3.5.1.tgz",
-      "integrity": "sha512-qwosvPyl+zpUlp3gRb7UcJ3H8S28XHCzkv0Y0EgQToXjQP91ZD67EHSCDmaLjtKhe+GVIW5om1KUpzVLA0l6pg==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ]
-    },
-    "node_modules/@modelcontextprotocol/sdk": {
-      "version": "1.26.0",
-      "resolved": "https://registry.npmjs.org/@modelcontextprotocol/sdk/-/sdk-1.26.0.tgz",
-      "integrity": "sha512-Y5RmPncpiDtTXDbLKswIJzTqu2hyBKxTNsgKqKclDbhIgg1wgtf1fRuvxgTnRfcnxtvvgbIEcqUOzZrJ6iSReg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@hono/node-server": "^1.19.9",
-        "ajv": "^8.17.1",
-        "ajv-formats": "^3.0.1",
-        "content-type": "^1.0.5",
-        "cors": "^2.8.5",
-        "cross-spawn": "^7.0.5",
-        "eventsource": "^3.0.2",
-        "eventsource-parser": "^3.0.0",
-        "express": "^5.2.1",
-        "express-rate-limit": "^8.2.1",
-        "hono": "^4.11.4",
-        "jose": "^6.1.3",
-        "json-schema-typed": "^8.0.2",
-        "pkce-challenge": "^5.0.0",
-        "raw-body": "^3.0.0",
-        "zod": "^3.25 || ^4.0",
-        "zod-to-json-schema": "^3.25.1"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "peerDependencies": {
-        "@cfworker/json-schema": "^4.1.1",
-        "zod": "^3.25 || ^4.0"
-      },
-      "peerDependenciesMeta": {
-        "@cfworker/json-schema": {
-          "optional": true
-        },
-        "zod": {
-          "optional": false
-        }
-      }
-    },
-    "node_modules/@msgpackr-extract/msgpackr-extract-darwin-arm64": {
-      "version": "3.0.4",
-      "resolved": "https://registry.npmjs.org/@msgpackr-extract/msgpackr-extract-darwin-arm64/-/msgpackr-extract-darwin-arm64-3.0.4.tgz",
-      "integrity": "sha512-LCkGo6JDfaBhgST7UpPWgNgLINpcpabaHfyz5OBx75nUYxBsaEPxjnyNjWpeb/xBup/682QnBfRBy2/LvPutZQ==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "darwin"
-      ]
-    },
-    "node_modules/@msgpackr-extract/msgpackr-extract-darwin-x64": {
-      "version": "3.0.4",
-      "resolved": "https://registry.npmjs.org/@msgpackr-extract/msgpackr-extract-darwin-x64/-/msgpackr-extract-darwin-x64-3.0.4.tgz",
-      "integrity": "sha512-zExlW9zUJKZH/tOtVMttwjKa4Xm/3KcNjnE3dPN92uCktwavMxpgCA3MoJK/DOnTWsQgo224OaST27/mPNAf+w==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "darwin"
-      ]
-    },
-    "node_modules/@msgpackr-extract/msgpackr-extract-linux-arm": {
-      "version": "3.0.4",
-      "resolved": "https://registry.npmjs.org/@msgpackr-extract/msgpackr-extract-linux-arm/-/msgpackr-extract-linux-arm-3.0.4.tgz",
-      "integrity": "sha512-Tg3yX65f5GbtXLkrYEHE5oibZG9epyYWas7FogTTEJeDEF9JlXJzKgXaNhT3UXlTOeA+AfZpYZYZ0uPj7Cfquw==",
-      "cpu": [
-        "arm"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
-    },
-    "node_modules/@msgpackr-extract/msgpackr-extract-linux-arm64": {
-      "version": "3.0.4",
-      "resolved": "https://registry.npmjs.org/@msgpackr-extract/msgpackr-extract-linux-arm64/-/msgpackr-extract-linux-arm64-3.0.4.tgz",
-      "integrity": "sha512-dgX0P/9wGPJeHFBG+ZmhgE6bmtMt7NP5CRBGyyktpopdk/mW4POnrpQsSLtKI1dwpc+pPLuXHDh6vvskyQE/sw==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
-    },
-    "node_modules/@msgpackr-extract/msgpackr-extract-linux-x64": {
-      "version": "3.0.4",
-      "resolved": "https://registry.npmjs.org/@msgpackr-extract/msgpackr-extract-linux-x64/-/msgpackr-extract-linux-x64-3.0.4.tgz",
-      "integrity": "sha512-8TNXMEjJc3QEy7R/x1INhgiU+XakDAFUzBhaz7+Rbrs8NH5UQeHQxxmzsSBJGyV6I1jW79undiQm8tOI+D+8FQ==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
-    },
-    "node_modules/@msgpackr-extract/msgpackr-extract-win32-x64": {
-      "version": "3.0.4",
-      "resolved": "https://registry.npmjs.org/@msgpackr-extract/msgpackr-extract-win32-x64/-/msgpackr-extract-win32-x64-3.0.4.tgz",
-      "integrity": "sha512-CmCXPQrkbwExx3j946/PtHWHbYJiCRBRDl4BlkRQcJB/YOwQxJRTpoo7aTsortjgoJ1x7opzTSxn7C+ASSLVjQ==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ]
-    },
-    "node_modules/@napi-rs/nice": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/@napi-rs/nice/-/nice-1.1.1.tgz",
-      "integrity": "sha512-xJIPs+bYuc9ASBl+cvGsKbGrJmS6fAKaSZCnT0lhahT5rhA2VVy9/EcIgd2JhtEuFOJNx7UHNn/qiTPTY4nrQw==",
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "engines": {
-        "node": ">= 10"
-      },
-      "funding": {
-        "type": "github",
-        "url": "https://github.com/sponsors/Brooooooklyn"
-      },
-      "optionalDependencies": {
-        "@napi-rs/nice-android-arm-eabi": "1.1.1",
-        "@napi-rs/nice-android-arm64": "1.1.1",
-        "@napi-rs/nice-darwin-arm64": "1.1.1",
-        "@napi-rs/nice-darwin-x64": "1.1.1",
-        "@napi-rs/nice-freebsd-x64": "1.1.1",
-        "@napi-rs/nice-linux-arm-gnueabihf": "1.1.1",
-        "@napi-rs/nice-linux-arm64-gnu": "1.1.1",
-        "@napi-rs/nice-linux-arm64-musl": "1.1.1",
-        "@napi-rs/nice-linux-ppc64-gnu": "1.1.1",
-        "@napi-rs/nice-linux-riscv64-gnu": "1.1.1",
-        "@napi-rs/nice-linux-s390x-gnu": "1.1.1",
-        "@napi-rs/nice-linux-x64-gnu": "1.1.1",
-        "@napi-rs/nice-linux-x64-musl": "1.1.1",
-        "@napi-rs/nice-openharmony-arm64": "1.1.1",
-        "@napi-rs/nice-win32-arm64-msvc": "1.1.1",
-        "@napi-rs/nice-win32-ia32-msvc": "1.1.1",
-        "@napi-rs/nice-win32-x64-msvc": "1.1.1"
-      }
-    },
-    "node_modules/@napi-rs/nice-android-arm-eabi": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/@napi-rs/nice-android-arm-eabi/-/nice-android-arm-eabi-1.1.1.tgz",
-      "integrity": "sha512-kjirL3N6TnRPv5iuHw36wnucNqXAO46dzK9oPb0wj076R5Xm8PfUVA9nAFB5ZNMmfJQJVKACAPd/Z2KYMppthw==",
-      "cpu": [
-        "arm"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "android"
-      ],
-      "engines": {
-        "node": ">= 10"
-      }
-    },
-    "node_modules/@napi-rs/nice-android-arm64": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/@napi-rs/nice-android-arm64/-/nice-android-arm64-1.1.1.tgz",
-      "integrity": "sha512-blG0i7dXgbInN5urONoUCNf+DUEAavRffrO7fZSeoRMJc5qD+BJeNcpr54msPF6qfDD6kzs9AQJogZvT2KD5nw==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "android"
-      ],
-      "engines": {
-        "node": ">= 10"
-      }
-    },
-    "node_modules/@napi-rs/nice-darwin-arm64": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/@napi-rs/nice-darwin-arm64/-/nice-darwin-arm64-1.1.1.tgz",
-      "integrity": "sha512-s/E7w45NaLqTGuOjC2p96pct4jRfo61xb9bU1unM/MJ/RFkKlJyJDx7OJI/O0ll/hrfpqKopuAFDV8yo0hfT7A==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "darwin"
-      ],
-      "engines": {
-        "node": ">= 10"
-      }
-    },
-    "node_modules/@napi-rs/nice-darwin-x64": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/@napi-rs/nice-darwin-x64/-/nice-darwin-x64-1.1.1.tgz",
-      "integrity": "sha512-dGoEBnVpsdcC+oHHmW1LRK5eiyzLwdgNQq3BmZIav+9/5WTZwBYX7r5ZkQC07Nxd3KHOCkgbHSh4wPkH1N1LiQ==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "darwin"
-      ],
-      "engines": {
-        "node": ">= 10"
-      }
-    },
-    "node_modules/@napi-rs/nice-freebsd-x64": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/@napi-rs/nice-freebsd-x64/-/nice-freebsd-x64-1.1.1.tgz",
-      "integrity": "sha512-kHv4kEHAylMYmlNwcQcDtXjklYp4FCf0b05E+0h6nDHsZ+F0bDe04U/tXNOqrx5CmIAth4vwfkjjUmp4c4JktQ==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "freebsd"
-      ],
-      "engines": {
-        "node": ">= 10"
-      }
-    },
-    "node_modules/@napi-rs/nice-linux-arm-gnueabihf": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/@napi-rs/nice-linux-arm-gnueabihf/-/nice-linux-arm-gnueabihf-1.1.1.tgz",
-      "integrity": "sha512-E1t7K0efyKXZDoZg1LzCOLxgolxV58HCkaEkEvIYQx12ht2pa8hoBo+4OB3qh7e+QiBlp1SRf+voWUZFxyhyqg==",
-      "cpu": [
-        "arm"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">= 10"
-      }
-    },
-    "node_modules/@napi-rs/nice-linux-arm64-gnu": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/@napi-rs/nice-linux-arm64-gnu/-/nice-linux-arm64-gnu-1.1.1.tgz",
-      "integrity": "sha512-CIKLA12DTIZlmTaaKhQP88R3Xao+gyJxNWEn04wZwC2wmRapNnxCUZkVwggInMJvtVElA+D4ZzOU5sX4jV+SmQ==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">= 10"
-      }
-    },
-    "node_modules/@napi-rs/nice-linux-arm64-musl": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/@napi-rs/nice-linux-arm64-musl/-/nice-linux-arm64-musl-1.1.1.tgz",
-      "integrity": "sha512-+2Rzdb3nTIYZ0YJF43qf2twhqOCkiSrHx2Pg6DJaCPYhhaxbLcdlV8hCRMHghQ+EtZQWGNcS2xF4KxBhSGeutg==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">= 10"
-      }
-    },
-    "node_modules/@napi-rs/nice-linux-ppc64-gnu": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/@napi-rs/nice-linux-ppc64-gnu/-/nice-linux-ppc64-gnu-1.1.1.tgz",
-      "integrity": "sha512-4FS8oc0GeHpwvv4tKciKkw3Y4jKsL7FRhaOeiPei0X9T4Jd619wHNe4xCLmN2EMgZoeGg+Q7GY7BsvwKpL22Tg==",
-      "cpu": [
-        "ppc64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">= 10"
-      }
-    },
-    "node_modules/@napi-rs/nice-linux-riscv64-gnu": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/@napi-rs/nice-linux-riscv64-gnu/-/nice-linux-riscv64-gnu-1.1.1.tgz",
-      "integrity": "sha512-HU0nw9uD4FO/oGCCk409tCi5IzIZpH2agE6nN4fqpwVlCn5BOq0MS1dXGjXaG17JaAvrlpV5ZeyZwSon10XOXw==",
-      "cpu": [
-        "riscv64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">= 10"
-      }
-    },
-    "node_modules/@napi-rs/nice-linux-s390x-gnu": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/@napi-rs/nice-linux-s390x-gnu/-/nice-linux-s390x-gnu-1.1.1.tgz",
-      "integrity": "sha512-2YqKJWWl24EwrX0DzCQgPLKQBxYDdBxOHot1KWEq7aY2uYeX+Uvtv4I8xFVVygJDgf6/92h9N3Y43WPx8+PAgQ==",
-      "cpu": [
-        "s390x"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">= 10"
-      }
-    },
-    "node_modules/@napi-rs/nice-linux-x64-gnu": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/@napi-rs/nice-linux-x64-gnu/-/nice-linux-x64-gnu-1.1.1.tgz",
-      "integrity": "sha512-/gaNz3R92t+dcrfCw/96pDopcmec7oCcAQ3l/M+Zxr82KT4DljD37CpgrnXV+pJC263JkW572pdbP3hP+KjcIg==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">= 10"
-      }
-    },
-    "node_modules/@napi-rs/nice-linux-x64-musl": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/@napi-rs/nice-linux-x64-musl/-/nice-linux-x64-musl-1.1.1.tgz",
-      "integrity": "sha512-xScCGnyj/oppsNPMnevsBe3pvNaoK7FGvMjT35riz9YdhB2WtTG47ZlbxtOLpjeO9SqqQ2J2igCmz6IJOD5JYw==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">= 10"
-      }
-    },
-    "node_modules/@napi-rs/nice-openharmony-arm64": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/@napi-rs/nice-openharmony-arm64/-/nice-openharmony-arm64-1.1.1.tgz",
-      "integrity": "sha512-6uJPRVwVCLDeoOaNyeiW0gp2kFIM4r7PL2MczdZQHkFi9gVlgm+Vn+V6nTWRcu856mJ2WjYJiumEajfSm7arPQ==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "openharmony"
-      ],
-      "engines": {
-        "node": ">= 10"
-      }
-    },
-    "node_modules/@napi-rs/nice-win32-arm64-msvc": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/@napi-rs/nice-win32-arm64-msvc/-/nice-win32-arm64-msvc-1.1.1.tgz",
-      "integrity": "sha512-uoTb4eAvM5B2aj/z8j+Nv8OttPf2m+HVx3UjA5jcFxASvNhQriyCQF1OB1lHL43ZhW+VwZlgvjmP5qF3+59atA==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ],
-      "engines": {
-        "node": ">= 10"
-      }
-    },
-    "node_modules/@napi-rs/nice-win32-ia32-msvc": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/@napi-rs/nice-win32-ia32-msvc/-/nice-win32-ia32-msvc-1.1.1.tgz",
-      "integrity": "sha512-CNQqlQT9MwuCsg1Vd/oKXiuH+TcsSPJmlAFc5frFyX/KkOh0UpBLEj7aoY656d5UKZQMQFP7vJNa1DNUNORvug==",
-      "cpu": [
-        "ia32"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ],
-      "engines": {
-        "node": ">= 10"
-      }
-    },
-    "node_modules/@napi-rs/nice-win32-x64-msvc": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/@napi-rs/nice-win32-x64-msvc/-/nice-win32-x64-msvc-1.1.1.tgz",
-      "integrity": "sha512-vB+4G/jBQCAh0jelMTY3+kgFy00Hlx2f2/1zjMoH821IbplbWZOkLiTYXQkygNTzQJTq5cvwBDgn2ppHD+bglQ==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ],
-      "engines": {
-        "node": ">= 10"
-      }
-    },
-    "node_modules/@napi-rs/wasm-runtime": {
-      "version": "1.1.4",
-      "resolved": "https://registry.npmjs.org/@napi-rs/wasm-runtime/-/wasm-runtime-1.1.4.tgz",
-      "integrity": "sha512-3NQNNgA1YSlJb/kMH1ildASP9HW7/7kYnRI2szWJaofaS1hWmbGI4H+d3+22aGzXXN9IJ+n+GiFVcGipJP18ow==",
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "dependencies": {
-        "@tybys/wasm-util": "^0.10.1"
-      },
-      "funding": {
-        "type": "github",
-        "url": "https://github.com/sponsors/Brooooooklyn"
-      },
-      "peerDependencies": {
-        "@emnapi/core": "^1.7.1",
-        "@emnapi/runtime": "^1.7.1"
-      }
-    },
-    "node_modules/@npmcli/agent": {
-      "version": "4.0.2",
-      "resolved": "https://registry.npmjs.org/@npmcli/agent/-/agent-4.0.2.tgz",
-      "integrity": "sha512-EUEuWAxnL07Sp5/iC/1X6Xj+XThUvnbei9zfRWZdEXa7lss9RTHMhAHBeg+MZ5To9s/gGaSI+UwZTPdYMvKSeg==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "agent-base": "^7.1.0",
-        "http-proxy-agent": "^7.0.0",
-        "https-proxy-agent": "^7.0.1",
-        "lru-cache": "^11.2.1",
-        "socks-proxy-agent": "^8.0.3"
-      },
-      "engines": {
-        "node": "^20.17.0 || >=22.9.0"
-      }
-    },
-    "node_modules/@npmcli/agent/node_modules/lru-cache": {
-      "version": "11.5.1",
-      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-11.5.1.tgz",
-      "integrity": "sha512-RPimw/7aMdv2oqRrxKwvZXcPfwBrn/JZ2xYcY9Hus/6LaS3VOAKVWKWgNLCFSiOm1ESXinjsDlidVU7JlnCN2A==",
-      "dev": true,
-      "license": "BlueOak-1.0.0",
-      "engines": {
-        "node": "20 || >=22"
-      }
-    },
-    "node_modules/@npmcli/fs": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/@npmcli/fs/-/fs-5.0.0.tgz",
-      "integrity": "sha512-7OsC1gNORBEawOa5+j2pXN9vsicaIOH5cPXxoR6fJOmH6/EXpJB2CajXOu1fPRFun2m1lktEFX11+P89hqO/og==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "semver": "^7.3.5"
-      },
-      "engines": {
-        "node": "^20.17.0 || >=22.9.0"
-      }
-    },
-    "node_modules/@npmcli/git": {
-      "version": "7.0.2",
-      "resolved": "https://registry.npmjs.org/@npmcli/git/-/git-7.0.2.tgz",
-      "integrity": "sha512-oeolHDjExNAJAnlYP2qzNjMX/Xi9bmu78C9dIGr4xjobrSKbuMYCph8lTzn4vnW3NjIqVmw/f8BCfouqyJXlRg==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "@gar/promise-retry": "^1.0.0",
-        "@npmcli/promise-spawn": "^9.0.0",
-        "ini": "^6.0.0",
-        "lru-cache": "^11.2.1",
-        "npm-pick-manifest": "^11.0.1",
-        "proc-log": "^6.0.0",
-        "semver": "^7.3.5",
-        "which": "^6.0.0"
-      },
-      "engines": {
-        "node": "^20.17.0 || >=22.9.0"
-      }
-    },
-    "node_modules/@npmcli/git/node_modules/isexe": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/isexe/-/isexe-4.0.0.tgz",
-      "integrity": "sha512-FFUtZMpoZ8RqHS3XeXEmHWLA4thH+ZxCv2lOiPIn1Xc7CxrqhWzNSDzD+/chS/zbYezmiwWLdQC09JdQKmthOw==",
-      "dev": true,
-      "license": "BlueOak-1.0.0",
-      "engines": {
-        "node": ">=20"
-      }
-    },
-    "node_modules/@npmcli/git/node_modules/lru-cache": {
-      "version": "11.5.1",
-      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-11.5.1.tgz",
-      "integrity": "sha512-RPimw/7aMdv2oqRrxKwvZXcPfwBrn/JZ2xYcY9Hus/6LaS3VOAKVWKWgNLCFSiOm1ESXinjsDlidVU7JlnCN2A==",
-      "dev": true,
-      "license": "BlueOak-1.0.0",
-      "engines": {
-        "node": "20 || >=22"
-      }
-    },
-    "node_modules/@npmcli/git/node_modules/which": {
-      "version": "6.0.1",
-      "resolved": "https://registry.npmjs.org/which/-/which-6.0.1.tgz",
-      "integrity": "sha512-oGLe46MIrCRqX7ytPUf66EAYvdeMIZYn3WaocqqKZAxrBpkqHfL/qvTyJ/bTk5+AqHCjXmrv3CEWgy368zhRUg==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "isexe": "^4.0.0"
-      },
-      "bin": {
-        "node-which": "bin/which.js"
-      },
-      "engines": {
-        "node": "^20.17.0 || >=22.9.0"
-      }
-    },
-    "node_modules/@npmcli/installed-package-contents": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/@npmcli/installed-package-contents/-/installed-package-contents-4.0.0.tgz",
-      "integrity": "sha512-yNyAdkBxB72gtZ4GrwXCM0ZUedo9nIbOMKfGjt6Cu6DXf0p8y1PViZAKDC8q8kv/fufx0WTjRBdSlyrvnP7hmA==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "npm-bundled": "^5.0.0",
-        "npm-normalize-package-bin": "^5.0.0"
-      },
-      "bin": {
-        "installed-package-contents": "bin/index.js"
-      },
-      "engines": {
-        "node": "^20.17.0 || >=22.9.0"
-      }
-    },
-    "node_modules/@npmcli/node-gyp": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/@npmcli/node-gyp/-/node-gyp-5.0.0.tgz",
-      "integrity": "sha512-uuG5HZFXLfyFKqg8QypsmgLQW7smiRjVc45bqD/ofZZcR/uxEjgQU8qDPv0s9TEeMUiAAU/GC5bR6++UdTirIQ==",
-      "dev": true,
-      "license": "ISC",
-      "engines": {
-        "node": "^20.17.0 || >=22.9.0"
-      }
-    },
-    "node_modules/@npmcli/package-json": {
-      "version": "7.0.5",
-      "resolved": "https://registry.npmjs.org/@npmcli/package-json/-/package-json-7.0.5.tgz",
-      "integrity": "sha512-iVuTlG3ORq2iaVa1IWUxAO/jIp77tUKBhoMjuzYW2kL4MLN1bi/ofqkZ7D7OOwh8coAx1/S2ge0rMdGv8sLSOQ==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "@npmcli/git": "^7.0.0",
-        "glob": "^13.0.0",
-        "hosted-git-info": "^9.0.0",
-        "json-parse-even-better-errors": "^5.0.0",
-        "proc-log": "^6.0.0",
-        "semver": "^7.5.3",
-        "spdx-expression-parse": "^4.0.0"
-      },
-      "engines": {
-        "node": "^20.17.0 || >=22.9.0"
-      }
-    },
-    "node_modules/@npmcli/promise-spawn": {
-      "version": "9.0.1",
-      "resolved": "https://registry.npmjs.org/@npmcli/promise-spawn/-/promise-spawn-9.0.1.tgz",
-      "integrity": "sha512-OLUaoqBuyxeTqUvjA3FZFiXUfYC1alp3Sa99gW3EUDz3tZ3CbXDdcZ7qWKBzicrJleIgucoWamWH1saAmH/l2Q==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "which": "^6.0.0"
-      },
-      "engines": {
-        "node": "^20.17.0 || >=22.9.0"
-      }
-    },
-    "node_modules/@npmcli/promise-spawn/node_modules/isexe": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/isexe/-/isexe-4.0.0.tgz",
-      "integrity": "sha512-FFUtZMpoZ8RqHS3XeXEmHWLA4thH+ZxCv2lOiPIn1Xc7CxrqhWzNSDzD+/chS/zbYezmiwWLdQC09JdQKmthOw==",
-      "dev": true,
-      "license": "BlueOak-1.0.0",
-      "engines": {
-        "node": ">=20"
-      }
-    },
-    "node_modules/@npmcli/promise-spawn/node_modules/which": {
-      "version": "6.0.1",
-      "resolved": "https://registry.npmjs.org/which/-/which-6.0.1.tgz",
-      "integrity": "sha512-oGLe46MIrCRqX7ytPUf66EAYvdeMIZYn3WaocqqKZAxrBpkqHfL/qvTyJ/bTk5+AqHCjXmrv3CEWgy368zhRUg==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "isexe": "^4.0.0"
-      },
-      "bin": {
-        "node-which": "bin/which.js"
-      },
-      "engines": {
-        "node": "^20.17.0 || >=22.9.0"
-      }
-    },
-    "node_modules/@npmcli/redact": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/@npmcli/redact/-/redact-4.0.0.tgz",
-      "integrity": "sha512-gOBg5YHMfZy+TfHArfVogwgfBeQnKbbGo3pSUyK/gSI0AVu+pEiDVcKlQb0D8Mg1LNRZILZ6XG8I5dJ4KuAd9Q==",
-      "dev": true,
-      "license": "ISC",
-      "engines": {
-        "node": "^20.17.0 || >=22.9.0"
-      }
-    },
-    "node_modules/@npmcli/run-script": {
-      "version": "10.0.4",
-      "resolved": "https://registry.npmjs.org/@npmcli/run-script/-/run-script-10.0.4.tgz",
-      "integrity": "sha512-mGUWr1uMnf0le2TwfOZY4SFxZGXGfm4Jtay/nwAa2FLNAKXUoUwaGwBMNH36UHPtinWfTSJ3nqFQr0091CxVGg==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "@npmcli/node-gyp": "^5.0.0",
-        "@npmcli/package-json": "^7.0.0",
-        "@npmcli/promise-spawn": "^9.0.0",
-        "node-gyp": "^12.1.0",
-        "proc-log": "^6.0.0"
-      },
-      "engines": {
-        "node": "^20.17.0 || >=22.9.0"
-      }
-    },
-    "node_modules/@oxc-project/types": {
-      "version": "0.113.0",
-      "resolved": "https://registry.npmjs.org/@oxc-project/types/-/types-0.113.0.tgz",
-      "integrity": "sha512-Tp3XmgxwNQ9pEN9vxgJBAqdRamHibi76iowQ38O2I4PMpcvNRQNVsU2n1x1nv9yh0XoTrGFzf7cZSGxmixxrhA==",
-      "dev": true,
-      "license": "MIT",
-      "funding": {
-        "url": "https://github.com/sponsors/Boshen"
-      }
-    },
-    "node_modules/@parcel/watcher": {
-      "version": "2.5.6",
-      "resolved": "https://registry.npmjs.org/@parcel/watcher/-/watcher-2.5.6.tgz",
-      "integrity": "sha512-tmmZ3lQxAe/k/+rNnXQRawJ4NjxO2hqiOLTHvWchtGZULp4RyFeh6aU4XdOYBFe2KE1oShQTv4AblOs2iOrNnQ==",
-      "dev": true,
-      "hasInstallScript": true,
-      "license": "MIT",
-      "optional": true,
-      "dependencies": {
-        "detect-libc": "^2.0.3",
-        "is-glob": "^4.0.3",
-        "node-addon-api": "^7.0.0",
-        "picomatch": "^4.0.3"
-      },
-      "engines": {
-        "node": ">= 10.0.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/parcel"
-      },
-      "optionalDependencies": {
-        "@parcel/watcher-android-arm64": "2.5.6",
-        "@parcel/watcher-darwin-arm64": "2.5.6",
-        "@parcel/watcher-darwin-x64": "2.5.6",
-        "@parcel/watcher-freebsd-x64": "2.5.6",
-        "@parcel/watcher-linux-arm-glibc": "2.5.6",
-        "@parcel/watcher-linux-arm-musl": "2.5.6",
-        "@parcel/watcher-linux-arm64-glibc": "2.5.6",
-        "@parcel/watcher-linux-arm64-musl": "2.5.6",
-        "@parcel/watcher-linux-x64-glibc": "2.5.6",
-        "@parcel/watcher-linux-x64-musl": "2.5.6",
-        "@parcel/watcher-win32-arm64": "2.5.6",
-        "@parcel/watcher-win32-ia32": "2.5.6",
-        "@parcel/watcher-win32-x64": "2.5.6"
-      }
-    },
-    "node_modules/@parcel/watcher-android-arm64": {
-      "version": "2.5.6",
-      "resolved": "https://registry.npmjs.org/@parcel/watcher-android-arm64/-/watcher-android-arm64-2.5.6.tgz",
-      "integrity": "sha512-YQxSS34tPF/6ZG7r/Ih9xy+kP/WwediEUsqmtf0cuCV5TPPKw/PQHRhueUo6JdeFJaqV3pyjm0GdYjZotbRt/A==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "android"
-      ],
-      "engines": {
-        "node": ">= 10.0.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/parcel"
-      }
-    },
-    "node_modules/@parcel/watcher-darwin-arm64": {
-      "version": "2.5.6",
-      "resolved": "https://registry.npmjs.org/@parcel/watcher-darwin-arm64/-/watcher-darwin-arm64-2.5.6.tgz",
-      "integrity": "sha512-Z2ZdrnwyXvvvdtRHLmM4knydIdU9adO3D4n/0cVipF3rRiwP+3/sfzpAwA/qKFL6i1ModaabkU7IbpeMBgiVEA==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "darwin"
-      ],
-      "engines": {
-        "node": ">= 10.0.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/parcel"
-      }
-    },
-    "node_modules/@parcel/watcher-darwin-x64": {
-      "version": "2.5.6",
-      "resolved": "https://registry.npmjs.org/@parcel/watcher-darwin-x64/-/watcher-darwin-x64-2.5.6.tgz",
-      "integrity": "sha512-HgvOf3W9dhithcwOWX9uDZyn1lW9R+7tPZ4sug+NGrGIo4Rk1hAXLEbcH1TQSqxts0NYXXlOWqVpvS1SFS4fRg==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "darwin"
-      ],
-      "engines": {
-        "node": ">= 10.0.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/parcel"
-      }
-    },
-    "node_modules/@parcel/watcher-freebsd-x64": {
-      "version": "2.5.6",
-      "resolved": "https://registry.npmjs.org/@parcel/watcher-freebsd-x64/-/watcher-freebsd-x64-2.5.6.tgz",
-      "integrity": "sha512-vJVi8yd/qzJxEKHkeemh7w3YAn6RJCtYlE4HPMoVnCpIXEzSrxErBW5SJBgKLbXU3WdIpkjBTeUNtyBVn8TRng==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "freebsd"
-      ],
-      "engines": {
-        "node": ">= 10.0.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/parcel"
-      }
-    },
-    "node_modules/@parcel/watcher-linux-arm-glibc": {
-      "version": "2.5.6",
-      "resolved": "https://registry.npmjs.org/@parcel/watcher-linux-arm-glibc/-/watcher-linux-arm-glibc-2.5.6.tgz",
-      "integrity": "sha512-9JiYfB6h6BgV50CCfasfLf/uvOcJskMSwcdH1PHH9rvS1IrNy8zad6IUVPVUfmXr+u+Km9IxcfMLzgdOudz9EQ==",
-      "cpu": [
-        "arm"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">= 10.0.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/parcel"
-      }
-    },
-    "node_modules/@parcel/watcher-linux-arm-musl": {
-      "version": "2.5.6",
-      "resolved": "https://registry.npmjs.org/@parcel/watcher-linux-arm-musl/-/watcher-linux-arm-musl-2.5.6.tgz",
-      "integrity": "sha512-Ve3gUCG57nuUUSyjBq/MAM0CzArtuIOxsBdQ+ftz6ho8n7s1i9E1Nmk/xmP323r2YL0SONs1EuwqBp2u1k5fxg==",
-      "cpu": [
-        "arm"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">= 10.0.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/parcel"
-      }
-    },
-    "node_modules/@parcel/watcher-linux-arm64-glibc": {
-      "version": "2.5.6",
-      "resolved": "https://registry.npmjs.org/@parcel/watcher-linux-arm64-glibc/-/watcher-linux-arm64-glibc-2.5.6.tgz",
-      "integrity": "sha512-f2g/DT3NhGPdBmMWYoxixqYr3v/UXcmLOYy16Bx0TM20Tchduwr4EaCbmxh1321TABqPGDpS8D/ggOTaljijOA==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">= 10.0.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/parcel"
-      }
-    },
-    "node_modules/@parcel/watcher-linux-arm64-musl": {
-      "version": "2.5.6",
-      "resolved": "https://registry.npmjs.org/@parcel/watcher-linux-arm64-musl/-/watcher-linux-arm64-musl-2.5.6.tgz",
-      "integrity": "sha512-qb6naMDGlbCwdhLj6hgoVKJl2odL34z2sqkC7Z6kzir8b5W65WYDpLB6R06KabvZdgoHI/zxke4b3zR0wAbDTA==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">= 10.0.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/parcel"
-      }
-    },
-    "node_modules/@parcel/watcher-linux-x64-glibc": {
-      "version": "2.5.6",
-      "resolved": "https://registry.npmjs.org/@parcel/watcher-linux-x64-glibc/-/watcher-linux-x64-glibc-2.5.6.tgz",
-      "integrity": "sha512-kbT5wvNQlx7NaGjzPFu8nVIW1rWqV780O7ZtkjuWaPUgpv2NMFpjYERVi0UYj1msZNyCzGlaCWEtzc+exjMGbQ==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">= 10.0.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/parcel"
-      }
-    },
-    "node_modules/@parcel/watcher-linux-x64-musl": {
-      "version": "2.5.6",
-      "resolved": "https://registry.npmjs.org/@parcel/watcher-linux-x64-musl/-/watcher-linux-x64-musl-2.5.6.tgz",
-      "integrity": "sha512-1JRFeC+h7RdXwldHzTsmdtYR/Ku8SylLgTU/reMuqdVD7CtLwf0VR1FqeprZ0eHQkO0vqsbvFLXUmYm/uNKJBg==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">= 10.0.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/parcel"
-      }
-    },
-    "node_modules/@parcel/watcher-win32-arm64": {
-      "version": "2.5.6",
-      "resolved": "https://registry.npmjs.org/@parcel/watcher-win32-arm64/-/watcher-win32-arm64-2.5.6.tgz",
-      "integrity": "sha512-3ukyebjc6eGlw9yRt678DxVF7rjXatWiHvTXqphZLvo7aC5NdEgFufVwjFfY51ijYEWpXbqF5jtrK275z52D4Q==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ],
-      "engines": {
-        "node": ">= 10.0.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/parcel"
-      }
-    },
-    "node_modules/@parcel/watcher-win32-ia32": {
-      "version": "2.5.6",
-      "resolved": "https://registry.npmjs.org/@parcel/watcher-win32-ia32/-/watcher-win32-ia32-2.5.6.tgz",
-      "integrity": "sha512-k35yLp1ZMwwee3Ez/pxBi5cf4AoBKYXj00CZ80jUz5h8prpiaQsiRPKQMxoLstNuqe2vR4RNPEAEcjEFzhEz/g==",
-      "cpu": [
-        "ia32"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ],
-      "engines": {
-        "node": ">= 10.0.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/parcel"
-      }
-    },
-    "node_modules/@parcel/watcher-win32-x64": {
-      "version": "2.5.6",
-      "resolved": "https://registry.npmjs.org/@parcel/watcher-win32-x64/-/watcher-win32-x64-2.5.6.tgz",
-      "integrity": "sha512-hbQlYcCq5dlAX9Qx+kFb0FHue6vbjlf0FrNzSKdYK2APUf7tGfGxQCk2ihEREmbR6ZMc0MVAD5RIX/41gpUzTw==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ],
-      "engines": {
-        "node": ">= 10.0.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/parcel"
-      }
-    },
-    "node_modules/@parcel/watcher/node_modules/node-addon-api": {
-      "version": "7.1.1",
-      "resolved": "https://registry.npmjs.org/node-addon-api/-/node-addon-api-7.1.1.tgz",
-      "integrity": "sha512-5m3bsyrjFWE1xf7nz7YXdN4udnVtXK6/Yfgn5qnahL6bCkf2yKt4k3nuTKAtT4r3IG8JNR2ncsIMdZuAzJjHQQ==",
-      "dev": true,
-      "license": "MIT",
-      "optional": true
-    },
-    "node_modules/@rolldown/binding-android-arm64": {
-      "version": "1.0.0-rc.4",
-      "resolved": "https://registry.npmjs.org/@rolldown/binding-android-arm64/-/binding-android-arm64-1.0.0-rc.4.tgz",
-      "integrity": "sha512-vRq9f4NzvbdZavhQbjkJBx7rRebDKYR9zHfO/Wg486+I7bSecdUapzCm5cyXoK+LHokTxgSq7A5baAXUZkIz0w==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "android"
-      ],
-      "engines": {
-        "node": "^20.19.0 || >=22.12.0"
-      }
-    },
-    "node_modules/@rolldown/binding-darwin-arm64": {
-      "version": "1.0.0-rc.4",
-      "resolved": "https://registry.npmjs.org/@rolldown/binding-darwin-arm64/-/binding-darwin-arm64-1.0.0-rc.4.tgz",
-      "integrity": "sha512-kFgEvkWLqt3YCgKB5re9RlIrx9bRsvyVUnaTakEpOPuLGzLpLapYxE9BufJNvPg8GjT6mB1alN4yN1NjzoeM8Q==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "darwin"
-      ],
-      "engines": {
-        "node": "^20.19.0 || >=22.12.0"
-      }
-    },
-    "node_modules/@rolldown/binding-darwin-x64": {
-      "version": "1.0.0-rc.4",
-      "resolved": "https://registry.npmjs.org/@rolldown/binding-darwin-x64/-/binding-darwin-x64-1.0.0-rc.4.tgz",
-      "integrity": "sha512-JXmaOJGsL/+rsmMfutcDjxWM2fTaVgCHGoXS7nE8Z3c9NAYjGqHvXrAhMUZvMpHS/k7Mg+X7n/MVKb7NYWKKww==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "darwin"
-      ],
-      "engines": {
-        "node": "^20.19.0 || >=22.12.0"
-      }
-    },
-    "node_modules/@rolldown/binding-freebsd-x64": {
-      "version": "1.0.0-rc.4",
-      "resolved": "https://registry.npmjs.org/@rolldown/binding-freebsd-x64/-/binding-freebsd-x64-1.0.0-rc.4.tgz",
-      "integrity": "sha512-ep3Catd6sPnHTM0P4hNEvIv5arnDvk01PfyJIJ+J3wVCG1eEaPo09tvFqdtcaTrkwQy0VWR24uz+cb4IsK53Qw==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "freebsd"
-      ],
-      "engines": {
-        "node": "^20.19.0 || >=22.12.0"
-      }
-    },
-    "node_modules/@rolldown/binding-linux-arm-gnueabihf": {
-      "version": "1.0.0-rc.4",
-      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm-gnueabihf/-/binding-linux-arm-gnueabihf-1.0.0-rc.4.tgz",
-      "integrity": "sha512-LwA5ayKIpnsgXJEwWc3h8wPiS33NMIHd9BhsV92T8VetVAbGe2qXlJwNVDGHN5cOQ22R9uYvbrQir2AB+ntT2w==",
-      "cpu": [
-        "arm"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": "^20.19.0 || >=22.12.0"
-      }
-    },
-    "node_modules/@rolldown/binding-linux-arm64-gnu": {
-      "version": "1.0.0-rc.4",
-      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm64-gnu/-/binding-linux-arm64-gnu-1.0.0-rc.4.tgz",
-      "integrity": "sha512-AC1WsGdlV1MtGay/OQ4J9T7GRadVnpYRzTcygV1hKnypbYN20Yh4t6O1Sa2qRBMqv1etulUknqXjc3CTIsBu6A==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": "^20.19.0 || >=22.12.0"
-      }
-    },
-    "node_modules/@rolldown/binding-linux-arm64-musl": {
-      "version": "1.0.0-rc.4",
-      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm64-musl/-/binding-linux-arm64-musl-1.0.0-rc.4.tgz",
-      "integrity": "sha512-lU+6rgXXViO61B4EudxtVMXSOfiZONR29Sys5VGSetUY7X8mg9FCKIIjcPPj8xNDeYzKl+H8F/qSKOBVFJChCQ==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": "^20.19.0 || >=22.12.0"
-      }
-    },
-    "node_modules/@rolldown/binding-linux-x64-gnu": {
-      "version": "1.0.0-rc.4",
-      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-x64-gnu/-/binding-linux-x64-gnu-1.0.0-rc.4.tgz",
-      "integrity": "sha512-DZaN1f0PGp/bSvKhtw50pPsnln4T13ycDq1FrDWRiHmWt1JeW+UtYg9touPFf8yt993p8tS2QjybpzKNTxYEwg==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": "^20.19.0 || >=22.12.0"
-      }
-    },
-    "node_modules/@rolldown/binding-linux-x64-musl": {
-      "version": "1.0.0-rc.4",
-      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-x64-musl/-/binding-linux-x64-musl-1.0.0-rc.4.tgz",
-      "integrity": "sha512-RnGxwZLN7fhMMAItnD6dZ7lvy+TI7ba+2V54UF4dhaWa/p8I/ys1E73KO6HmPmgz92ZkfD8TXS1IMV8+uhbR9g==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": "^20.19.0 || >=22.12.0"
-      }
-    },
-    "node_modules/@rolldown/binding-openharmony-arm64": {
-      "version": "1.0.0-rc.4",
-      "resolved": "https://registry.npmjs.org/@rolldown/binding-openharmony-arm64/-/binding-openharmony-arm64-1.0.0-rc.4.tgz",
-      "integrity": "sha512-6lcI79+X8klGiGd8yHuTgQRjuuJYNggmEml+RsyN596P23l/zf9FVmJ7K0KVKkFAeYEdg0iMUKyIxiV5vebDNQ==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "openharmony"
-      ],
-      "engines": {
-        "node": "^20.19.0 || >=22.12.0"
-      }
-    },
-    "node_modules/@rolldown/binding-wasm32-wasi": {
-      "version": "1.0.0-rc.4",
-      "resolved": "https://registry.npmjs.org/@rolldown/binding-wasm32-wasi/-/binding-wasm32-wasi-1.0.0-rc.4.tgz",
-      "integrity": "sha512-wz7ohsKCAIWy91blZ/1FlpPdqrsm1xpcEOQVveWoL6+aSPKL4VUcoYmmzuLTssyZxRpEwzuIxL/GDsvpjaBtOw==",
-      "cpu": [
-        "wasm32"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "dependencies": {
-        "@napi-rs/wasm-runtime": "^1.1.1"
-      },
-      "engines": {
-        "node": ">=14.0.0"
-      }
-    },
-    "node_modules/@rolldown/binding-win32-arm64-msvc": {
-      "version": "1.0.0-rc.4",
-      "resolved": "https://registry.npmjs.org/@rolldown/binding-win32-arm64-msvc/-/binding-win32-arm64-msvc-1.0.0-rc.4.tgz",
-      "integrity": "sha512-cfiMrfuWCIgsFmcVG0IPuO6qTRHvF7NuG3wngX1RZzc6dU8FuBFb+J3MIR5WrdTNozlumfgL4cvz+R4ozBCvsQ==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ],
-      "engines": {
-        "node": "^20.19.0 || >=22.12.0"
-      }
-    },
-    "node_modules/@rolldown/binding-win32-x64-msvc": {
-      "version": "1.0.0-rc.4",
-      "resolved": "https://registry.npmjs.org/@rolldown/binding-win32-x64-msvc/-/binding-win32-x64-msvc-1.0.0-rc.4.tgz",
-      "integrity": "sha512-p6UeR9y7ht82AH57qwGuFYn69S6CZ7LLKdCKy/8T3zS9VTrJei2/CGsTUV45Da4Z9Rbhc7G4gyWQ/Ioamqn09g==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ],
-      "engines": {
-        "node": "^20.19.0 || >=22.12.0"
-      }
-    },
-    "node_modules/@rolldown/pluginutils": {
-      "version": "1.0.0-rc.4",
-      "resolved": "https://registry.npmjs.org/@rolldown/pluginutils/-/pluginutils-1.0.0-rc.4.tgz",
-      "integrity": "sha512-1BrrmTu0TWfOP1riA8uakjFc9bpIUGzVKETsOtzY39pPga8zELGDl8eu1Dx7/gjM5CAz14UknsUMpBO8L+YntQ==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@rollup/rollup-android-arm-eabi": {
-      "version": "4.60.4",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.60.4.tgz",
-      "integrity": "sha512-F5QXMSiFebS9hKZj02XhWLLnRpJ3B3AROP0tWbFBSj+6kCbg5m9j5JoHKd4mmSVy5mS/IMQloYgYxCuJC0fxEQ==",
-      "cpu": [
-        "arm"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "android"
-      ]
-    },
-    "node_modules/@rollup/rollup-android-arm64": {
-      "version": "4.60.4",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.60.4.tgz",
-      "integrity": "sha512-GxxTKApUpzRhof7poWvCJHRF51C67u1R7D6DiluBE8wKU1u5GWE8t+v81JvJYtbawoBFX1hLv5Ei4eVjkWokaw==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "android"
-      ]
-    },
-    "node_modules/@rollup/rollup-darwin-arm64": {
-      "version": "4.60.4",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.60.4.tgz",
-      "integrity": "sha512-tua0TaJxMOB1R0V0RS1jFZ/RpURFDJIOR2A6jWwQeawuFyS4gBW+rntLRaQd0EQ4bd6Vp44Z2rXW+YYDBsj6IA==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "darwin"
-      ]
-    },
-    "node_modules/@rollup/rollup-darwin-x64": {
-      "version": "4.60.4",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.60.4.tgz",
-      "integrity": "sha512-CSKq7MsP+5PFIcydhAiR1K0UhEI1A2jWXVKHPCBZ151yOutENwvnPocgVHkivu2kviURtCEB6zUQw0vs8RrhMg==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "darwin"
-      ]
-    },
-    "node_modules/@rollup/rollup-freebsd-arm64": {
-      "version": "4.60.4",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.60.4.tgz",
-      "integrity": "sha512-+O8OkVdyvXMtJEciu2wS/pzm1IxntEEQx3z5TAVy4l32G0etZn+RsA48ARRrFm6Ri8fvqPQfgrvNxSjKAbnd3g==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "freebsd"
-      ]
-    },
-    "node_modules/@rollup/rollup-freebsd-x64": {
-      "version": "4.60.4",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.60.4.tgz",
-      "integrity": "sha512-Iw3oMskH3AfNuhU0MSN7vNbdi4me/NiYo2azqPz/Le16zHSa+3RRmliCMWWQmh4lcndccU40xcJuTYJZxNo/lw==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "freebsd"
-      ]
-    },
-    "node_modules/@rollup/rollup-linux-arm-gnueabihf": {
-      "version": "4.60.4",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.60.4.tgz",
-      "integrity": "sha512-EIPRXTVQpHyF8WOo219AD2yEltPehLTcTMz2fn6JsatLYSzQf00hj3rulF+yauOlF9/FtM2WpkT/hJh/KJFGhA==",
-      "cpu": [
-        "arm"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
-    },
-    "node_modules/@rollup/rollup-linux-arm-musleabihf": {
-      "version": "4.60.4",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.60.4.tgz",
-      "integrity": "sha512-J3Yh9PzzF1Ovah2At+lHiGQdsYgArxBbXv/zHfSyaiFQEqvNv7DcW98pCrmdjCZBrqBiKrKKe2V+aaSGWuBe/w==",
-      "cpu": [
-        "arm"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
-    },
-    "node_modules/@rollup/rollup-linux-arm64-gnu": {
-      "version": "4.60.4",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.60.4.tgz",
-      "integrity": "sha512-BFDEZMYfUvLn37ONE1yMBojPxnMlTFsdyNoqncT0qFq1mAfllL+ATMMJd8TeuVMiX84s1KbcxcZbXInmcO2mRg==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
-    },
-    "node_modules/@rollup/rollup-linux-arm64-musl": {
-      "version": "4.60.4",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.60.4.tgz",
-      "integrity": "sha512-pc9EYOSlOgdQ2uPl1o9PF6/kLSgaUosia7gOuS8mB69IxJvlclko1MECXysjs5ryez1/5zjYqx3+xYU0TU6R1A==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
-    },
-    "node_modules/@rollup/rollup-linux-loong64-gnu": {
-      "version": "4.60.4",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.60.4.tgz",
-      "integrity": "sha512-NxnomyxYerDh5n4iLrNa+sH+Z+U4BMEE46V2PgQ/hoB909i8gV1M5wPojWg9fk1jWpO3IQnOs20K4wyZuFLEFQ==",
-      "cpu": [
-        "loong64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
-    },
-    "node_modules/@rollup/rollup-linux-loong64-musl": {
-      "version": "4.60.4",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-musl/-/rollup-linux-loong64-musl-4.60.4.tgz",
-      "integrity": "sha512-nbJnQ8a3z1mtmrwImCYhc6BGpThAyYVRQxw9uKSKG4wR6aAYno9sVjJ0zaZcW9BPJX1GbrDPf+SvdWjgTuDmnw==",
-      "cpu": [
-        "loong64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
-    },
-    "node_modules/@rollup/rollup-linux-ppc64-gnu": {
-      "version": "4.60.4",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.60.4.tgz",
-      "integrity": "sha512-2EU6acNrQLd8tYvo/LXW535wupT3m6fo7HKo6lr7ktQoItxTyOL1ZCR/GfGCuXl2vR+zmfI6eRXkSemafv+iVg==",
-      "cpu": [
-        "ppc64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
-    },
-    "node_modules/@rollup/rollup-linux-ppc64-musl": {
-      "version": "4.60.4",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-musl/-/rollup-linux-ppc64-musl-4.60.4.tgz",
-      "integrity": "sha512-WeBtoMuaMxiiIrO2IYP3xs6GMWkJP2C0EoT8beTLkUPmzV1i/UcOSVw1d5r9KBODtHKilG5yFxsGRnBbK3wJ4A==",
-      "cpu": [
-        "ppc64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
-    },
-    "node_modules/@rollup/rollup-linux-riscv64-gnu": {
-      "version": "4.60.4",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.60.4.tgz",
-      "integrity": "sha512-FJHFfqpKUI3A10WrWKiFbBZ7yVbGT4q4B5o1qKFFojqpaYoh9LrQgqWCmmcxQzVSXYtyB5bzkXrYzlHTs21MYA==",
-      "cpu": [
-        "riscv64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
-    },
-    "node_modules/@rollup/rollup-linux-riscv64-musl": {
-      "version": "4.60.4",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.60.4.tgz",
-      "integrity": "sha512-mcEl6CUT5IAUmQf1m9FYSmVqCJlpQ8r8eyftFUHG8i9OhY7BkBXSUdnLH5DOf0wCOjcP9v/QO93zpmF1SptCCw==",
-      "cpu": [
-        "riscv64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
-    },
-    "node_modules/@rollup/rollup-linux-s390x-gnu": {
-      "version": "4.60.4",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.60.4.tgz",
-      "integrity": "sha512-ynt3JxVd2w2buzoKDWIyiV1pJW93xlQic1THVLXilz429oijRpSHivZAgp65KBu+cMcgf1eVVjdnTLvPxgCuoQ==",
-      "cpu": [
-        "s390x"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
-    },
-    "node_modules/@rollup/rollup-linux-x64-gnu": {
-      "version": "4.60.4",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.60.4.tgz",
-      "integrity": "sha512-Boiz5+MsaROEWDf+GGEwF8VMHGhlUoQMtIPjOgA5fv4osupqTVnJteQNKJwUcnUog2G55jYXH7KZFFiJe0TEzQ==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
-    },
-    "node_modules/@rollup/rollup-linux-x64-musl": {
-      "version": "4.60.4",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.60.4.tgz",
-      "integrity": "sha512-+qfSY27qIrFfI/Hom04KYFw3GKZSGU4lXus51wsb5EuySfFlWRwjkKWoE9emgRw/ukoT4Udsj4W/+xxG8VbPKg==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
-    },
-    "node_modules/@rollup/rollup-openbsd-x64": {
-      "version": "4.60.4",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-openbsd-x64/-/rollup-openbsd-x64-4.60.4.tgz",
-      "integrity": "sha512-VpTfOPHgVXEBeeR8hZ2O0F3aSso+JDWqTWmTmzcQKted54IAdUVbxE+j/MVxUsKa8L20HJhv3vUezVPoquqWjA==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "openbsd"
-      ]
-    },
-    "node_modules/@rollup/rollup-openharmony-arm64": {
-      "version": "4.60.4",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.60.4.tgz",
-      "integrity": "sha512-IPOsh5aRYuLv/nkU51X10Bf75Bsf6+gZdx1X+QP5QM6lIJFHHqbHLG0uJn/hWthzo13UAc2umiUorqZy3axoZg==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "openharmony"
-      ]
-    },
-    "node_modules/@rollup/rollup-win32-arm64-msvc": {
-      "version": "4.60.4",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.60.4.tgz",
-      "integrity": "sha512-4QzE9E81OohJ/HKzHhsqU+zcYYojVOXlFMs1DdyMT6qXl/niOH7AVElmmEdUNHHS/oRkc++d5k6Vy85zFs0DEw==",
-      "cpu": [
-        "arm64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ]
-    },
-    "node_modules/@rollup/rollup-win32-ia32-msvc": {
-      "version": "4.60.4",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.60.4.tgz",
-      "integrity": "sha512-zTPgT1YuHHcd+Tmx7h8aml0FWFVelV5N54oHow9SLj+GfoDy/huQ+UV396N/C7KpMDMiPspRktzM1/0r1usYEA==",
-      "cpu": [
-        "ia32"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ]
-    },
-    "node_modules/@rollup/rollup-win32-x64-gnu": {
-      "version": "4.60.4",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.60.4.tgz",
-      "integrity": "sha512-DRS4G7mi9lJxqEDezIkKCaUIKCrLUUDCUaCsTPCi/rtqaC6D/jjwslMQyiDU50Ka0JKpeXeRBFBAXwArY52vBw==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ]
-    },
-    "node_modules/@rollup/rollup-win32-x64-msvc": {
-      "version": "4.60.4",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.60.4.tgz",
-      "integrity": "sha512-QVTUovf40zgTqlFVrKA1uXMVvU2QWEFWfAH8Wdc48IxLvrJMQVMBRjuQyUpzZCDkakImib9eVazbWlC6ksWtJw==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ]
-    },
-    "node_modules/@schematics/angular": {
-      "version": "21.2.13",
-      "resolved": "https://registry.npmjs.org/@schematics/angular/-/angular-21.2.13.tgz",
-      "integrity": "sha512-e5guslSLKbb3PJ6gUuVqM+V9xgn68cJkG1IyBohho34shbpOeoWW2eYdWQQjxvn0KUdgEhYSRBluBamCHngaUA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@angular-devkit/core": "21.2.13",
-        "@angular-devkit/schematics": "21.2.13",
-        "jsonc-parser": "3.3.1"
-      },
-      "engines": {
-        "node": "^20.19.0 || ^22.12.0 || >=24.0.0",
-        "npm": "^6.11.0 || ^7.5.6 || >=8.0.0",
-        "yarn": ">= 1.13.0"
-      }
-    },
-    "node_modules/@sigstore/bundle": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/@sigstore/bundle/-/bundle-4.0.0.tgz",
-      "integrity": "sha512-NwCl5Y0V6Di0NexvkTqdoVfmjTaQwoLM236r89KEojGmq/jMls8S+zb7yOwAPdXvbwfKDlP+lmXgAL4vKSQT+A==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@sigstore/protobuf-specs": "^0.5.0"
-      },
-      "engines": {
-        "node": "^20.17.0 || >=22.9.0"
-      }
-    },
-    "node_modules/@sigstore/core": {
-      "version": "3.2.1",
-      "resolved": "https://registry.npmjs.org/@sigstore/core/-/core-3.2.1.tgz",
-      "integrity": "sha512-qRsxPnCrbC/puegGxKuynfnxgLiHqWStrSjxkoB4YKqq3Z3s4cyZyj42ZdWFAEblNP65C+rBH8EuREHIXoi83g==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "engines": {
-        "node": "^20.17.0 || >=22.9.0"
-      }
-    },
-    "node_modules/@sigstore/protobuf-specs": {
-      "version": "0.5.1",
-      "resolved": "https://registry.npmjs.org/@sigstore/protobuf-specs/-/protobuf-specs-0.5.1.tgz",
-      "integrity": "sha512-/ScWUhhoFasJsSRGTVBwId1loQjjnjAfE4djL6ZhrXRpNCmPTnUKF5Jokd58ILseOMjzET3UrMOtJPS9sYeI0g==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "engines": {
-        "node": "^18.17.0 || >=20.5.0"
-      }
-    },
-    "node_modules/@sigstore/sign": {
-      "version": "4.1.1",
-      "resolved": "https://registry.npmjs.org/@sigstore/sign/-/sign-4.1.1.tgz",
-      "integrity": "sha512-Hf4xglukg0XXQ2RiD5vSoLjdPe8OBUPA8XeVjUObheuDcWdYWrnH/BNmxZCzkAy68MzmNCxXLeurJvs6hcP2OQ==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@gar/promise-retry": "^1.0.2",
-        "@sigstore/bundle": "^4.0.0",
-        "@sigstore/core": "^3.2.0",
-        "@sigstore/protobuf-specs": "^0.5.0",
-        "make-fetch-happen": "^15.0.4",
-        "proc-log": "^6.1.0"
-      },
-      "engines": {
-        "node": "^20.17.0 || >=22.9.0"
-      }
-    },
-    "node_modules/@sigstore/tuf": {
-      "version": "4.0.2",
-      "resolved": "https://registry.npmjs.org/@sigstore/tuf/-/tuf-4.0.2.tgz",
-      "integrity": "sha512-TCAzTy0xzdP79EnxSjq9KQ3eaR7+FmudLC6eRKknVKZbV7ZNlGLClAAQb/HMNJ5n2OBNk2GT1tEmU0xuPr+SLQ==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@sigstore/protobuf-specs": "^0.5.0",
-        "tuf-js": "^4.1.0"
-      },
-      "engines": {
-        "node": "^20.17.0 || >=22.9.0"
-      }
-    },
-    "node_modules/@sigstore/verify": {
-      "version": "3.1.1",
-      "resolved": "https://registry.npmjs.org/@sigstore/verify/-/verify-3.1.1.tgz",
-      "integrity": "sha512-qv7+G3J2cc6wwFj3yKvXOamzqhMwSk1ogPGmhpS8iXllcPrJaIIBA+4HbttlHVu1pqWTdmaCH/WE7UOC51kdoA==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@sigstore/bundle": "^4.0.0",
-        "@sigstore/core": "^3.2.1",
-        "@sigstore/protobuf-specs": "^0.5.0"
-      },
-      "engines": {
-        "node": "^20.17.0 || >=22.9.0"
-      }
-    },
-    "node_modules/@spectrayan/ng-sse-client": {
-      "version": "2.0.0",
-      "resolved": "https://npm.pkg.github.com/download/@spectrayan/ng-sse-client/2.0.0/b430a5226b6d3c2f939ae935b4785a7cda379ce6",
-      "integrity": "sha512-QfMxU2U6O4NmZSFbQjzUs8yelvEFWl67/5Ov4ouzsF5YiulU7pqopnsNrVgyBWjOeUh/QenUjsmTAsTUNEYuZg==",
-      "license": "Apache-2.0",
-      "dependencies": {
-        "tslib": "^2.3.0"
-      },
-      "peerDependencies": {
-        "@angular/common": ">=16 <23",
-        "@angular/core": ">=16 <23",
-        "rxjs": ">=7 <8"
-      }
-    },
-    "node_modules/@standard-schema/spec": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/@standard-schema/spec/-/spec-1.1.0.tgz",
-      "integrity": "sha512-l2aFy5jALhniG5HgqrD6jXLi/rUWrKvqN/qJx6yoJsgKhblVd+iqqU4RCXavm/jPityDo5TCvKMnpjKnOriy0w==",
-      "license": "MIT"
-    },
-    "node_modules/@tufjs/canonical-json": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/@tufjs/canonical-json/-/canonical-json-2.0.0.tgz",
-      "integrity": "sha512-yVtV8zsdo8qFHe+/3kw81dSLyF7D576A5cCFCi4X7B39tWT7SekaEFUnvnWJHz+9qO7qJTah1JbrDjWKqFtdWA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": "^16.14.0 || >=18.0.0"
-      }
-    },
-    "node_modules/@tufjs/models": {
-      "version": "4.1.0",
-      "resolved": "https://registry.npmjs.org/@tufjs/models/-/models-4.1.0.tgz",
-      "integrity": "sha512-Y8cK9aggNRsqJVaKUlEYs4s7CvQ1b1ta2DVPyAimb0I2qhzjNk+A+mxvll/klL0RlfuIUei8BF7YWiua4kQqww==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@tufjs/canonical-json": "2.0.0",
-        "minimatch": "^10.1.1"
-      },
-      "engines": {
-        "node": "^20.17.0 || >=22.9.0"
-      }
-    },
-    "node_modules/@tweenjs/tween.js": {
-      "version": "23.1.3",
-      "resolved": "https://registry.npmjs.org/@tweenjs/tween.js/-/tween.js-23.1.3.tgz",
-      "integrity": "sha512-vJmvvwFxYuGnF2axRtPYocag6Clbb5YS7kLL+SO/TeVFzHqDIWrNKYtcsPMibjDx9O+bu+psAy9NKfWklassUA==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@tybys/wasm-util": {
-      "version": "0.10.2",
-      "resolved": "https://registry.npmjs.org/@tybys/wasm-util/-/wasm-util-0.10.2.tgz",
-      "integrity": "sha512-RoBvJ2X0wuKlWFIjrwffGw1IqZHKQqzIchKaadZZfnNpsAYp2mM0h36JtPCjNDAHGgYez/15uMBpfGwchhiMgg==",
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "dependencies": {
-        "tslib": "^2.4.0"
-      }
-    },
-    "node_modules/@types/estree": {
-      "version": "1.0.8",
-      "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz",
-      "integrity": "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@types/stats.js": {
-      "version": "0.17.4",
-      "resolved": "https://registry.npmjs.org/@types/stats.js/-/stats.js-0.17.4.tgz",
-      "integrity": "sha512-jIBvWWShCvlBqBNIZt0KAshWpvSjhkwkEu4ZUcASoAvhmrgAUI2t1dXrjSL4xXVLB4FznPrIsX3nKXFl/Dt4vA==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@types/three": {
-      "version": "0.184.1",
-      "resolved": "https://registry.npmjs.org/@types/three/-/three-0.184.1.tgz",
-      "integrity": "sha512-6q4VdiqVsrTRqmk62/BnlcAvIrnDM0zf2ZDVKI5kZiniWrSaOHaQzmbp+BNzoggc/8tgW412pL//wZIxu2PPTA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@dimforge/rapier3d-compat": "~0.12.0",
-        "@tweenjs/tween.js": "~23.1.3",
-        "@types/stats.js": "*",
-        "@types/webxr": ">=0.5.17",
-        "fflate": "~0.8.2",
-        "meshoptimizer": "~1.1.1"
-      }
-    },
-    "node_modules/@types/webxr": {
-      "version": "0.5.24",
-      "resolved": "https://registry.npmjs.org/@types/webxr/-/webxr-0.5.24.tgz",
-      "integrity": "sha512-h8fgEd/DpoS9CBrjEQXR+dIDraopAEfu4wYVNY2tEPwk60stPWhvZMf4Foo5FakuQ7HFZoa8WceaWFervK2Ovg==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@vitejs/plugin-basic-ssl": {
-      "version": "2.1.4",
-      "resolved": "https://registry.npmjs.org/@vitejs/plugin-basic-ssl/-/plugin-basic-ssl-2.1.4.tgz",
-      "integrity": "sha512-HXciTXN/sDBYWgeAD4V4s0DN0g72x5mlxQhHxtYu3Tt8BLa6MzcJZUyDVFCdtjNs3bfENVHVzOsmooTVuNgAAw==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": "^18.0.0 || ^20.0.0 || >=22.0.0"
-      },
-      "peerDependencies": {
-        "vite": "^6.0.0 || ^7.0.0"
-      }
-    },
-    "node_modules/@yarnpkg/lockfile": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/@yarnpkg/lockfile/-/lockfile-1.1.0.tgz",
-      "integrity": "sha512-GpSwvyXOcOOlV70vbnzjj4fW5xW/FdUF6nQEt1ENy7m4ZCczi1+/buVUPAqmGfqznsORNFzUMjctTIp8a9tuCQ==",
-      "dev": true,
-      "license": "BSD-2-Clause"
-    },
-    "node_modules/abbrev": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/abbrev/-/abbrev-4.0.0.tgz",
-      "integrity": "sha512-a1wflyaL0tHtJSmLSOVybYhy22vRih4eduhhrkcjgrWGnRfrZtovJ2FRjxuTtkkj47O/baf0R86QU5OuYpz8fA==",
-      "dev": true,
-      "license": "ISC",
-      "engines": {
-        "node": "^20.17.0 || >=22.9.0"
-      }
-    },
-    "node_modules/accepts": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/accepts/-/accepts-2.0.0.tgz",
-      "integrity": "sha512-5cvg6CtKwfgdmVqY1WIiXKc3Q1bkRqGLi+2W/6ao+6Y7gu/RCwRuAhGEzh5B4KlszSuTLgZYuqFqo5bImjNKng==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "mime-types": "^3.0.0",
-        "negotiator": "^1.0.0"
-      },
-      "engines": {
-        "node": ">= 0.6"
-      }
-    },
-    "node_modules/agent-base": {
-      "version": "7.1.4",
-      "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-7.1.4.tgz",
-      "integrity": "sha512-MnA+YT8fwfJPgBx3m60MNqakm30XOkyIoH1y6huTQvC0PwZG7ki8NacLBcrPbNoo8vEZy7Jpuk7+jMO+CUovTQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 14"
-      }
-    },
-    "node_modules/ajv": {
-      "version": "8.18.0",
-      "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.18.0.tgz",
-      "integrity": "sha512-PlXPeEWMXMZ7sPYOHqmDyCJzcfNrUr3fGNKtezX14ykXOEIvyK81d+qydx89KY5O71FKMPaQ2vBfBFI5NHR63A==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "fast-deep-equal": "^3.1.3",
-        "fast-uri": "^3.0.1",
-        "json-schema-traverse": "^1.0.0",
-        "require-from-string": "^2.0.2"
-      },
-      "funding": {
-        "type": "github",
-        "url": "https://github.com/sponsors/epoberezkin"
-      }
-    },
-    "node_modules/ajv-formats": {
-      "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/ajv-formats/-/ajv-formats-3.0.1.tgz",
-      "integrity": "sha512-8iUql50EUR+uUcdRQ3HDqa6EVyo3docL8g5WJ3FNcWmu62IbkGUue/pEyLBW8VGKKucTPgqeks4fIU1DA4yowQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ajv": "^8.0.0"
-      },
-      "peerDependencies": {
-        "ajv": "^8.0.0"
-      },
-      "peerDependenciesMeta": {
-        "ajv": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/algoliasearch": {
-      "version": "5.48.1",
-      "resolved": "https://registry.npmjs.org/algoliasearch/-/algoliasearch-5.48.1.tgz",
-      "integrity": "sha512-Rf7xmeuIo7nb6S4mp4abW2faW8DauZyE2faBIKFaUfP3wnpOvNSbiI5AwVhqBNj0jPgBWEvhyCu0sLjN2q77Rg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@algolia/abtesting": "1.14.1",
-        "@algolia/client-abtesting": "5.48.1",
-        "@algolia/client-analytics": "5.48.1",
-        "@algolia/client-common": "5.48.1",
-        "@algolia/client-insights": "5.48.1",
-        "@algolia/client-personalization": "5.48.1",
-        "@algolia/client-query-suggestions": "5.48.1",
-        "@algolia/client-search": "5.48.1",
-        "@algolia/ingestion": "1.48.1",
-        "@algolia/monitoring": "1.48.1",
-        "@algolia/recommend": "5.48.1",
-        "@algolia/requester-browser-xhr": "5.48.1",
-        "@algolia/requester-fetch": "5.48.1",
-        "@algolia/requester-node-http": "5.48.1"
-      },
-      "engines": {
-        "node": ">= 14.0.0"
-      }
-    },
-    "node_modules/ansi-escapes": {
-      "version": "7.3.0",
-      "resolved": "https://registry.npmjs.org/ansi-escapes/-/ansi-escapes-7.3.0.tgz",
-      "integrity": "sha512-BvU8nYgGQBxcmMuEeUEmNTvrMVjJNSH7RgW24vXexN4Ven6qCvy4TntnvlnwnMLTVlcRQQdbRY8NKnaIoeWDNg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "environment": "^1.0.0"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/ansi-regex": {
-      "version": "6.2.2",
-      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.2.2.tgz",
-      "integrity": "sha512-Bq3SmSpyFHaWjPk8If9yc6svM8c56dB5BAtW4Qbw5jHTwwXXcTLoRMkpDJp6VL0XzlWaCHTXrkFURMYmD0sLqg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/ansi-regex?sponsor=1"
-      }
-    },
-    "node_modules/ansi-styles": {
-      "version": "6.2.3",
-      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-6.2.3.tgz",
-      "integrity": "sha512-4Dj6M28JB+oAH8kFkTLUo+a2jwOFkuqb3yucU0CANcRRUbxS0cP0nZYCGjcc3BNXwRIsUVmDGgzawme7zvJHvg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
-      }
-    },
-    "node_modules/balanced-match": {
-      "version": "4.0.4",
-      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-4.0.4.tgz",
-      "integrity": "sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": "18 || 20 || >=22"
-      }
-    },
-    "node_modules/baseline-browser-mapping": {
-      "version": "2.10.33",
-      "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.10.33.tgz",
-      "integrity": "sha512-bA6+tcSLpz2tIEdDXZPpPTIuxBcC4+w6SieaYyfigIa4h8GlFxbA17v22Vx3JUtuZQj9SgOsnbK+aTBzyDyEuw==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "bin": {
-        "baseline-browser-mapping": "dist/cli.cjs"
-      },
-      "engines": {
-        "node": ">=6.0.0"
-      }
-    },
-    "node_modules/beasties": {
-      "version": "0.4.1",
-      "resolved": "https://registry.npmjs.org/beasties/-/beasties-0.4.1.tgz",
-      "integrity": "sha512-2Imdcw3LznDuxAbJM26RHniOLAzE6WgrK8OuvVXCQtNBS8rsnD9zsSEa3fHl4hHpUY7BYTlrpvtPVbvu9G6neg==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "css-select": "^6.0.0",
-        "css-what": "^7.0.0",
-        "dom-serializer": "^2.0.0",
-        "domhandler": "^5.0.3",
-        "htmlparser2": "^10.0.0",
-        "picocolors": "^1.1.1",
-        "postcss": "^8.4.49",
-        "postcss-media-query-parser": "^0.2.3",
-        "postcss-safe-parser": "^7.0.1"
-      },
-      "engines": {
-        "node": ">=18.0.0"
-      }
-    },
-    "node_modules/body-parser": {
-      "version": "2.2.2",
-      "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-2.2.2.tgz",
-      "integrity": "sha512-oP5VkATKlNwcgvxi0vM0p/D3n2C3EReYVX+DNYs5TjZFn/oQt2j+4sVJtSMr18pdRr8wjTcBl6LoV+FUwzPmNA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "bytes": "^3.1.2",
-        "content-type": "^1.0.5",
-        "debug": "^4.4.3",
-        "http-errors": "^2.0.0",
-        "iconv-lite": "^0.7.0",
-        "on-finished": "^2.4.1",
-        "qs": "^6.14.1",
-        "raw-body": "^3.0.1",
-        "type-is": "^2.0.1"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/express"
-      }
-    },
-    "node_modules/boolbase": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/boolbase/-/boolbase-1.0.0.tgz",
-      "integrity": "sha512-JZOSA7Mo9sNGB8+UjSgzdLtokWAky1zbztM3WRLCbZ70/3cTANmQmOdR7y2g+J0e2WXywy1yS468tY+IruqEww==",
-      "dev": true,
-      "license": "ISC"
-    },
-    "node_modules/brace-expansion": {
-      "version": "5.0.6",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.6.tgz",
-      "integrity": "sha512-kLpxurY4Z4r9sgMsyG0Z9uzsBlgiU/EFKhj/h91/8yHu0edo7XuixOIH3VcJ8kkxs6/jPzoI6U9Vj3WqbMQ94g==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "balanced-match": "^4.0.2"
-      },
-      "engines": {
-        "node": "18 || 20 || >=22"
-      }
-    },
-    "node_modules/browserslist": {
-      "version": "4.28.2",
-      "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.28.2.tgz",
-      "integrity": "sha512-48xSriZYYg+8qXna9kwqjIVzuQxi+KYWp2+5nCYnYKPTr0LvD89Jqk2Or5ogxz0NUMfIjhh2lIUX/LyX9B4oIg==",
-      "dev": true,
-      "funding": [
-        {
-          "type": "opencollective",
-          "url": "https://opencollective.com/browserslist"
-        },
-        {
-          "type": "tidelift",
-          "url": "https://tidelift.com/funding/github/npm/browserslist"
-        },
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/ai"
-        }
-      ],
-      "license": "MIT",
-      "dependencies": {
-        "baseline-browser-mapping": "^2.10.12",
-        "caniuse-lite": "^1.0.30001782",
-        "electron-to-chromium": "^1.5.328",
-        "node-releases": "^2.0.36",
-        "update-browserslist-db": "^1.2.3"
-      },
-      "bin": {
-        "browserslist": "cli.js"
-      },
-      "engines": {
-        "node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7"
-      }
-    },
-    "node_modules/buffer-from": {
-      "version": "1.1.2",
-      "resolved": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.2.tgz",
-      "integrity": "sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/bytes": {
-      "version": "3.1.2",
-      "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.1.2.tgz",
-      "integrity": "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.8"
-      }
-    },
-    "node_modules/cacache": {
-      "version": "20.0.4",
-      "resolved": "https://registry.npmjs.org/cacache/-/cacache-20.0.4.tgz",
-      "integrity": "sha512-M3Lab8NPYlZU2exsL3bMVvMrMqgwCnMWfdZbK28bn3pK6APT/Te/I8hjRPNu1uwORY9a1eEQoifXbKPQMfMTOA==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "@npmcli/fs": "^5.0.0",
-        "fs-minipass": "^3.0.0",
-        "glob": "^13.0.0",
-        "lru-cache": "^11.1.0",
-        "minipass": "^7.0.3",
-        "minipass-collect": "^2.0.1",
-        "minipass-flush": "^1.0.5",
-        "minipass-pipeline": "^1.2.4",
-        "p-map": "^7.0.2",
-        "ssri": "^13.0.0"
-      },
-      "engines": {
-        "node": "^20.17.0 || >=22.9.0"
-      }
-    },
-    "node_modules/cacache/node_modules/lru-cache": {
-      "version": "11.5.1",
-      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-11.5.1.tgz",
-      "integrity": "sha512-RPimw/7aMdv2oqRrxKwvZXcPfwBrn/JZ2xYcY9Hus/6LaS3VOAKVWKWgNLCFSiOm1ESXinjsDlidVU7JlnCN2A==",
-      "dev": true,
-      "license": "BlueOak-1.0.0",
-      "engines": {
-        "node": "20 || >=22"
-      }
-    },
-    "node_modules/call-bind-apply-helpers": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz",
-      "integrity": "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "es-errors": "^1.3.0",
-        "function-bind": "^1.1.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/call-bound": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/call-bound/-/call-bound-1.0.4.tgz",
-      "integrity": "sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bind-apply-helpers": "^1.0.2",
-        "get-intrinsic": "^1.3.0"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/caniuse-lite": {
-      "version": "1.0.30001793",
-      "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001793.tgz",
-      "integrity": "sha512-iwSsYWaCOoh26cV8NwNRViHlrfUvYsHDfRVcbtmw0Kg6PJIZZXwMkj1442FYLBGkeUf1juAsU3DTfxW579mrPA==",
-      "dev": true,
-      "funding": [
-        {
-          "type": "opencollective",
-          "url": "https://opencollective.com/browserslist"
-        },
-        {
-          "type": "tidelift",
-          "url": "https://tidelift.com/funding/github/npm/caniuse-lite"
-        },
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/ai"
-        }
-      ],
-      "license": "CC-BY-4.0"
-    },
-    "node_modules/chalk": {
-      "version": "5.6.2",
-      "resolved": "https://registry.npmjs.org/chalk/-/chalk-5.6.2.tgz",
-      "integrity": "sha512-7NzBL0rN6fMUW+f7A6Io4h40qQlG+xGmtMxfbnH/K7TAtt8JQWVQK+6g0UXKMeVJoyV5EkkNsErQ8pVD3bLHbA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": "^12.17.0 || ^14.13 || >=16.0.0"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/chalk?sponsor=1"
-      }
-    },
-    "node_modules/chardet": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/chardet/-/chardet-2.1.1.tgz",
-      "integrity": "sha512-PsezH1rqdV9VvyNhxxOW32/d75r01NY7TQCmOqomRo15ZSOKbpTFVsfjghxo6JloQUCGnH4k1LGu0R4yCLlWQQ==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/chokidar": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-5.0.0.tgz",
-      "integrity": "sha512-TQMmc3w+5AxjpL8iIiwebF73dRDF4fBIieAqGn9RGCWaEVwQ6Fb2cGe31Yns0RRIzii5goJ1Y7xbMwo1TxMplw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "readdirp": "^5.0.0"
-      },
-      "engines": {
-        "node": ">= 20.19.0"
-      },
-      "funding": {
-        "url": "https://paulmillr.com/funding/"
-      }
-    },
-    "node_modules/chownr": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/chownr/-/chownr-3.0.0.tgz",
-      "integrity": "sha512-+IxzY9BZOQd/XuYPRmrvEVjF/nqj5kgT4kEq7VofrDoM1MxoRjEWkrCC3EtLi59TVawxTAn+orJwFQcrqEN1+g==",
-      "dev": true,
-      "license": "BlueOak-1.0.0",
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/cli-cursor": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/cli-cursor/-/cli-cursor-5.0.0.tgz",
-      "integrity": "sha512-aCj4O5wKyszjMmDT4tZj93kxyydN/K5zPWSCe6/0AV/AA1pqe5ZBIw0a2ZfPQV7lL5/yb5HsUreJ6UFAF1tEQw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "restore-cursor": "^5.0.0"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/cli-spinners": {
-      "version": "3.4.0",
-      "resolved": "https://registry.npmjs.org/cli-spinners/-/cli-spinners-3.4.0.tgz",
-      "integrity": "sha512-bXfOC4QcT1tKXGorxL3wbJm6XJPDqEnij2gQ2m7ESQuE+/z9YFIWnl/5RpTiKWbMq3EVKR4fRLJGn6DVfu0mpw==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=18.20"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/cli-truncate": {
-      "version": "5.2.0",
-      "resolved": "https://registry.npmjs.org/cli-truncate/-/cli-truncate-5.2.0.tgz",
-      "integrity": "sha512-xRwvIOMGrfOAnM1JYtqQImuaNtDEv9v6oIYAs4LIHwTiKee8uwvIi363igssOC0O5U04i4AlENs79LQLu9tEMw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "slice-ansi": "^8.0.0",
-        "string-width": "^8.2.0"
-      },
-      "engines": {
-        "node": ">=20"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/cli-width": {
-      "version": "4.1.0",
-      "resolved": "https://registry.npmjs.org/cli-width/-/cli-width-4.1.0.tgz",
-      "integrity": "sha512-ouuZd4/dm2Sw5Gmqy6bGyNNNe1qt9RpmxveLSO7KcgsTnU7RXfsw+/bukWGo1abgBiMAic068rclZsO4IWmmxQ==",
-      "dev": true,
-      "license": "ISC",
-      "engines": {
-        "node": ">= 12"
-      }
-    },
-    "node_modules/cliui": {
-      "version": "9.0.1",
-      "resolved": "https://registry.npmjs.org/cliui/-/cliui-9.0.1.tgz",
-      "integrity": "sha512-k7ndgKhwoQveBL+/1tqGJYNz097I7WOvwbmmU2AR5+magtbjPWQTS1C5vzGkBC8Ym8UWRzfKUzUUqFLypY4Q+w==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "string-width": "^7.2.0",
-        "strip-ansi": "^7.1.0",
-        "wrap-ansi": "^9.0.0"
-      },
-      "engines": {
-        "node": ">=20"
-      }
-    },
-    "node_modules/cliui/node_modules/string-width": {
-      "version": "7.2.0",
-      "resolved": "https://registry.npmjs.org/string-width/-/string-width-7.2.0.tgz",
-      "integrity": "sha512-tsaTIkKW9b4N+AEj+SVA+WhJzV7/zMhcSu78mLKWSk7cXMOSHsBKFWUs0fWwq8QyK3MgJBQRX6Gbi4kYbdvGkQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "emoji-regex": "^10.3.0",
-        "get-east-asian-width": "^1.0.0",
-        "strip-ansi": "^7.1.0"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/cliui/node_modules/wrap-ansi": {
-      "version": "9.0.2",
-      "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-9.0.2.tgz",
-      "integrity": "sha512-42AtmgqjV+X1VpdOfyTGOYRi0/zsoLqtXQckTmqTeybT+BDIbM/Guxo7x3pE2vtpr1ok6xRqM9OpBe+Jyoqyww==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ansi-styles": "^6.2.1",
-        "string-width": "^7.0.0",
-        "strip-ansi": "^7.1.0"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/wrap-ansi?sponsor=1"
-      }
-    },
-    "node_modules/color-convert": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
-      "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "color-name": "~1.1.4"
-      },
-      "engines": {
-        "node": ">=7.0.0"
-      }
-    },
-    "node_modules/color-name": {
-      "version": "1.1.4",
-      "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
-      "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/colorette": {
-      "version": "2.0.20",
-      "resolved": "https://registry.npmjs.org/colorette/-/colorette-2.0.20.tgz",
-      "integrity": "sha512-IfEDxwoWIjkeXL1eXcDiow4UbKjhLdq6/EuSVR9GMN7KVH3r9gQ83e73hsz1Nd1T3ijd5xv1wcWRYO+D6kCI2w==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/content-disposition": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/content-disposition/-/content-disposition-1.1.0.tgz",
-      "integrity": "sha512-5jRCH9Z/+DRP7rkvY83B+yGIGX96OYdJmzngqnw2SBSxqCFPd0w2km3s5iawpGX8krnwSGmF0FW5Nhr0Hfai3g==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/express"
-      }
-    },
-    "node_modules/content-type": {
-      "version": "1.0.5",
-      "resolved": "https://registry.npmjs.org/content-type/-/content-type-1.0.5.tgz",
-      "integrity": "sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.6"
-      }
-    },
-    "node_modules/convert-source-map": {
-      "version": "1.9.0",
-      "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-1.9.0.tgz",
-      "integrity": "sha512-ASFBup0Mz1uyiIjANan1jzLQami9z1PoYSZCiiYW2FczPbenXc45FZdBZLzOT+r6+iciuEModtmCti+hjaAk0A==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/cookie": {
-      "version": "0.7.2",
-      "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.7.2.tgz",
-      "integrity": "sha512-yki5XnKuf750l50uGTllt6kKILY4nQ1eNIQatoXEByZ5dWgnKqbnqmTrBE5B4N7lrMJKQ2ytWMiTO2o0v6Ew/w==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.6"
-      }
-    },
-    "node_modules/cookie-signature": {
-      "version": "1.2.2",
-      "resolved": "https://registry.npmjs.org/cookie-signature/-/cookie-signature-1.2.2.tgz",
-      "integrity": "sha512-D76uU73ulSXrD1UXF4KE2TMxVVwhsnCgfAyTg9k8P6KGZjlXKrOLe4dJQKI3Bxi5wjesZoFXJWElNWBjPZMbhg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=6.6.0"
-      }
-    },
-    "node_modules/cors": {
-      "version": "2.8.6",
-      "resolved": "https://registry.npmjs.org/cors/-/cors-2.8.6.tgz",
-      "integrity": "sha512-tJtZBBHA6vjIAaF6EnIaq6laBBP9aq/Y3ouVJjEfoHbRBcHBAHYcMh/w8LDrk2PvIMMq8gmopa5D4V8RmbrxGw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "object-assign": "^4",
-        "vary": "^1"
-      },
-      "engines": {
-        "node": ">= 0.10"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/express"
-      }
-    },
-    "node_modules/cross-spawn": {
-      "version": "7.0.6",
-      "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz",
-      "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "path-key": "^3.1.0",
-        "shebang-command": "^2.0.0",
-        "which": "^2.0.1"
-      },
-      "engines": {
-        "node": ">= 8"
-      }
-    },
-    "node_modules/css-select": {
-      "version": "6.0.0",
-      "resolved": "https://registry.npmjs.org/css-select/-/css-select-6.0.0.tgz",
-      "integrity": "sha512-rZZVSLle8v0+EY8QAkDWrKhpgt6SA5OtHsgBnsj6ZaLb5dmDVOWUDtQitd9ydxxvEjhewNudS6eTVU7uOyzvXw==",
-      "dev": true,
-      "license": "BSD-2-Clause",
-      "dependencies": {
-        "boolbase": "^1.0.0",
-        "css-what": "^7.0.0",
-        "domhandler": "^5.0.3",
-        "domutils": "^3.2.2",
-        "nth-check": "^2.1.1"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/fb55"
-      }
-    },
-    "node_modules/css-what": {
-      "version": "7.0.0",
-      "resolved": "https://registry.npmjs.org/css-what/-/css-what-7.0.0.tgz",
-      "integrity": "sha512-wD5oz5xibMOPHzy13CyGmogB3phdvcDaB5t0W/Nr5Z2O/agcB8YwOz6e2Lsp10pNDzBoDO9nVa3RGs/2BttpHQ==",
-      "dev": true,
-      "license": "BSD-2-Clause",
-      "engines": {
-        "node": ">= 6"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/fb55"
-      }
-    },
-    "node_modules/debug": {
-      "version": "4.4.3",
-      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
-      "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ms": "^2.1.3"
-      },
-      "engines": {
-        "node": ">=6.0"
-      },
-      "peerDependenciesMeta": {
-        "supports-color": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/depd": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/depd/-/depd-2.0.0.tgz",
-      "integrity": "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.8"
-      }
-    },
-    "node_modules/detect-libc": {
-      "version": "2.1.2",
-      "resolved": "https://registry.npmjs.org/detect-libc/-/detect-libc-2.1.2.tgz",
-      "integrity": "sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "optional": true,
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/dom-serializer": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/dom-serializer/-/dom-serializer-2.0.0.tgz",
-      "integrity": "sha512-wIkAryiqt/nV5EQKqQpo3SToSOV9J0DnbJqwK7Wv/Trc92zIAYZ4FlMu+JPFW1DfGFt81ZTCGgDEabffXeLyJg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "domelementtype": "^2.3.0",
-        "domhandler": "^5.0.2",
-        "entities": "^4.2.0"
-      },
-      "funding": {
-        "url": "https://github.com/cheeriojs/dom-serializer?sponsor=1"
-      }
-    },
-    "node_modules/domelementtype": {
-      "version": "2.3.0",
-      "resolved": "https://registry.npmjs.org/domelementtype/-/domelementtype-2.3.0.tgz",
-      "integrity": "sha512-OLETBj6w0OsagBwdXnPdN0cnMfF9opN69co+7ZrbfPGrdpPVNBUj02spi6B1N7wChLQiPn4CSH/zJvXw56gmHw==",
-      "dev": true,
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/fb55"
-        }
-      ],
-      "license": "BSD-2-Clause"
-    },
-    "node_modules/domhandler": {
-      "version": "5.0.3",
-      "resolved": "https://registry.npmjs.org/domhandler/-/domhandler-5.0.3.tgz",
-      "integrity": "sha512-cgwlv/1iFQiFnU96XXgROh8xTeetsnJiDsTc7TYCLFd9+/WNkIqPTxiM/8pSd8VIrhXGTf1Ny1q1hquVqDJB5w==",
-      "dev": true,
-      "license": "BSD-2-Clause",
-      "dependencies": {
-        "domelementtype": "^2.3.0"
-      },
-      "engines": {
-        "node": ">= 4"
-      },
-      "funding": {
-        "url": "https://github.com/fb55/domhandler?sponsor=1"
-      }
-    },
-    "node_modules/domutils": {
-      "version": "3.2.2",
-      "resolved": "https://registry.npmjs.org/domutils/-/domutils-3.2.2.tgz",
-      "integrity": "sha512-6kZKyUajlDuqlHKVX1w7gyslj9MPIXzIFiz/rGu35uC1wMi+kMhQwGhl4lt9unC9Vb9INnY9Z3/ZA3+FhASLaw==",
-      "dev": true,
-      "license": "BSD-2-Clause",
-      "dependencies": {
-        "dom-serializer": "^2.0.0",
-        "domelementtype": "^2.3.0",
-        "domhandler": "^5.0.3"
-      },
-      "funding": {
-        "url": "https://github.com/fb55/domutils?sponsor=1"
-      }
-    },
-    "node_modules/dunder-proto": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz",
-      "integrity": "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bind-apply-helpers": "^1.0.1",
-        "es-errors": "^1.3.0",
-        "gopd": "^1.2.0"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/echarts": {
-      "version": "6.1.0",
-      "resolved": "https://registry.npmjs.org/echarts/-/echarts-6.1.0.tgz",
-      "integrity": "sha512-q0yaFPggC9FUdsWH4blavRWFmxdrIodbkoKNAjJudAI6CA9gNPxHtV2RcZNEepZVlk4yvBYkOkbk6HIVpIyHZA==",
-      "license": "Apache-2.0",
-      "dependencies": {
-        "tslib": "2.3.0",
-        "zrender": "6.1.0"
-      }
-    },
-    "node_modules/echarts/node_modules/tslib": {
-      "version": "2.3.0",
-      "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.3.0.tgz",
-      "integrity": "sha512-N82ooyxVNm6h1riLCoyS9e3fuJ3AMG2zIZs2Gd1ATcSFjSA23Q0fzjjZeh0jbJvWVDZ0cJT8yaNNaaXHzueNjg==",
-      "license": "0BSD"
-    },
-    "node_modules/ee-first": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/ee-first/-/ee-first-1.1.1.tgz",
-      "integrity": "sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/electron-to-chromium": {
-      "version": "1.5.364",
-      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.364.tgz",
-      "integrity": "sha512-G/dYE3+AYhyHwzTwg8UbnXf7zqMERYh7l2jJ3QujhFsH8agSYwtnGAR2aZ7f0AakIKJXd5En/Hre4igIUrdlYw==",
-      "dev": true,
-      "license": "ISC"
-    },
-    "node_modules/emoji-regex": {
-      "version": "10.6.0",
-      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-10.6.0.tgz",
-      "integrity": "sha512-toUI84YS5YmxW219erniWD0CIVOo46xGKColeNQRgOzDorgBi1v4D71/OFzgD9GO2UGKIv1C3Sp8DAn0+j5w7A==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/encodeurl": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-2.0.0.tgz",
-      "integrity": "sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.8"
-      }
-    },
-    "node_modules/entities": {
-      "version": "4.5.0",
-      "resolved": "https://registry.npmjs.org/entities/-/entities-4.5.0.tgz",
-      "integrity": "sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw==",
-      "dev": true,
-      "license": "BSD-2-Clause",
-      "engines": {
-        "node": ">=0.12"
-      },
-      "funding": {
-        "url": "https://github.com/fb55/entities?sponsor=1"
-      }
-    },
-    "node_modules/env-paths": {
-      "version": "2.2.1",
-      "resolved": "https://registry.npmjs.org/env-paths/-/env-paths-2.2.1.tgz",
-      "integrity": "sha512-+h1lkLKhZMTYjog1VEpJNG7NZJWcuc2DDk/qsqSTRRCOXiLjeQ1d1/udrUGhqMxUgAlwKNZ0cf2uqan5GLuS2A==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/environment": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/environment/-/environment-1.1.0.tgz",
-      "integrity": "sha512-xUtoPkMggbz0MPyPiIWr1Kp4aeWJjDZ6SMvURhimjdZgsRuDplF5/s9hcgGhyXMhs+6vpnuoiZ2kFiu3FMnS8Q==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/err-code": {
-      "version": "2.0.3",
-      "resolved": "https://registry.npmjs.org/err-code/-/err-code-2.0.3.tgz",
-      "integrity": "sha512-2bmlRpNKBxT/CRmPOlyISQpNj+qSeYvcym/uT0Jx2bMOlKLtSy1ZmLuVxSEKKyor/N5yhvp/ZiG1oE3DEYMSFA==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/es-define-property": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz",
-      "integrity": "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/es-errors": {
-      "version": "1.3.0",
-      "resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz",
-      "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/es-object-atoms": {
-      "version": "1.1.2",
-      "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.2.tgz",
-      "integrity": "sha512-HWcBoN6NileqtSydK2FqHbS/LoDd2pqrnQHLyJzBj4kOp/ky2MWMN694xOfkK8/SnUsW2DH7EfyVlydKCsm1Zw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "es-errors": "^1.3.0"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/esbuild": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.27.3.tgz",
-      "integrity": "sha512-8VwMnyGCONIs6cWue2IdpHxHnAjzxnw2Zr7MkVxB2vjmQ2ivqGFb4LEG3SMnv0Gb2F/G/2yA8zUaiL1gywDCCg==",
-      "dev": true,
-      "hasInstallScript": true,
-      "license": "MIT",
-      "bin": {
-        "esbuild": "bin/esbuild"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "optionalDependencies": {
-        "@esbuild/aix-ppc64": "0.27.3",
-        "@esbuild/android-arm": "0.27.3",
-        "@esbuild/android-arm64": "0.27.3",
-        "@esbuild/android-x64": "0.27.3",
-        "@esbuild/darwin-arm64": "0.27.3",
-        "@esbuild/darwin-x64": "0.27.3",
-        "@esbuild/freebsd-arm64": "0.27.3",
-        "@esbuild/freebsd-x64": "0.27.3",
-        "@esbuild/linux-arm": "0.27.3",
-        "@esbuild/linux-arm64": "0.27.3",
-        "@esbuild/linux-ia32": "0.27.3",
-        "@esbuild/linux-loong64": "0.27.3",
-        "@esbuild/linux-mips64el": "0.27.3",
-        "@esbuild/linux-ppc64": "0.27.3",
-        "@esbuild/linux-riscv64": "0.27.3",
-        "@esbuild/linux-s390x": "0.27.3",
-        "@esbuild/linux-x64": "0.27.3",
-        "@esbuild/netbsd-arm64": "0.27.3",
-        "@esbuild/netbsd-x64": "0.27.3",
-        "@esbuild/openbsd-arm64": "0.27.3",
-        "@esbuild/openbsd-x64": "0.27.3",
-        "@esbuild/openharmony-arm64": "0.27.3",
-        "@esbuild/sunos-x64": "0.27.3",
-        "@esbuild/win32-arm64": "0.27.3",
-        "@esbuild/win32-ia32": "0.27.3",
-        "@esbuild/win32-x64": "0.27.3"
-      }
-    },
-    "node_modules/escalade": {
-      "version": "3.2.0",
-      "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz",
-      "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/escape-html": {
-      "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/escape-html/-/escape-html-1.0.3.tgz",
-      "integrity": "sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/etag": {
-      "version": "1.8.1",
-      "resolved": "https://registry.npmjs.org/etag/-/etag-1.8.1.tgz",
-      "integrity": "sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.6"
-      }
-    },
-    "node_modules/eventemitter3": {
-      "version": "5.0.4",
-      "resolved": "https://registry.npmjs.org/eventemitter3/-/eventemitter3-5.0.4.tgz",
-      "integrity": "sha512-mlsTRyGaPBjPedk6Bvw+aqbsXDtoAyAzm5MO7JgU+yVRyMQ5O8bD4Kcci7BS85f93veegeCPkL8R4GLClnjLFw==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/eventsource": {
-      "version": "3.0.7",
-      "resolved": "https://registry.npmjs.org/eventsource/-/eventsource-3.0.7.tgz",
-      "integrity": "sha512-CRT1WTyuQoD771GW56XEZFQ/ZoSfWid1alKGDYMmkt2yl8UXrVR4pspqWNEcqKvVIzg6PAltWjxcSSPrboA4iA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "eventsource-parser": "^3.0.1"
-      },
-      "engines": {
-        "node": ">=18.0.0"
-      }
-    },
-    "node_modules/eventsource-parser": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/eventsource-parser/-/eventsource-parser-3.1.0.tgz",
-      "integrity": "sha512-kJezFj9YFAMLeORyi7aCLxLbD5/qWMQnoMVlVPyHIll7lgRJCc3JVln9Vgl9nwQi0YkMnhdGTMNn7CkRRAptMg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=18.0.0"
-      }
-    },
-    "node_modules/exponential-backoff": {
-      "version": "3.1.3",
-      "resolved": "https://registry.npmjs.org/exponential-backoff/-/exponential-backoff-3.1.3.tgz",
-      "integrity": "sha512-ZgEeZXj30q+I0EN+CbSSpIyPaJ5HVQD18Z1m+u1FXbAeT94mr1zw50q4q6jiiC447Nl/YTcIYSAftiGqetwXCA==",
-      "dev": true,
-      "license": "Apache-2.0"
-    },
-    "node_modules/express": {
-      "version": "5.2.1",
-      "resolved": "https://registry.npmjs.org/express/-/express-5.2.1.tgz",
-      "integrity": "sha512-hIS4idWWai69NezIdRt2xFVofaF4j+6INOpJlVOLDO8zXGpUVEVzIYk12UUi2JzjEzWL3IOAxcTubgz9Po0yXw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "accepts": "^2.0.0",
-        "body-parser": "^2.2.1",
-        "content-disposition": "^1.0.0",
-        "content-type": "^1.0.5",
-        "cookie": "^0.7.1",
-        "cookie-signature": "^1.2.1",
-        "debug": "^4.4.0",
-        "depd": "^2.0.0",
-        "encodeurl": "^2.0.0",
-        "escape-html": "^1.0.3",
-        "etag": "^1.8.1",
-        "finalhandler": "^2.1.0",
-        "fresh": "^2.0.0",
-        "http-errors": "^2.0.0",
-        "merge-descriptors": "^2.0.0",
-        "mime-types": "^3.0.0",
-        "on-finished": "^2.4.1",
-        "once": "^1.4.0",
-        "parseurl": "^1.3.3",
-        "proxy-addr": "^2.0.7",
-        "qs": "^6.14.0",
-        "range-parser": "^1.2.1",
-        "router": "^2.2.0",
-        "send": "^1.1.0",
-        "serve-static": "^2.2.0",
-        "statuses": "^2.0.1",
-        "type-is": "^2.0.1",
-        "vary": "^1.1.2"
-      },
-      "engines": {
-        "node": ">= 18"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/express"
-      }
-    },
-    "node_modules/express-rate-limit": {
-      "version": "8.5.2",
-      "resolved": "https://registry.npmjs.org/express-rate-limit/-/express-rate-limit-8.5.2.tgz",
-      "integrity": "sha512-5Kb34ipNX694DH48vN9irak1Qx30nb0PLYHXfJgw4YEjiC3ZEmZJhwOp+VfiCYwFzvFTdB9QkArYS5kXa2cx2A==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ip-address": "^10.2.0"
-      },
-      "engines": {
-        "node": ">= 16"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/express-rate-limit"
-      },
-      "peerDependencies": {
-        "express": ">= 4.11"
-      }
-    },
-    "node_modules/fast-deep-equal": {
-      "version": "3.1.3",
-      "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz",
-      "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/fast-uri": {
-      "version": "3.1.2",
-      "resolved": "https://registry.npmjs.org/fast-uri/-/fast-uri-3.1.2.tgz",
-      "integrity": "sha512-rVjf7ArG3LTk+FS6Yw81V1DLuZl1bRbNrev6Tmd/9RaroeeRRJhAt7jg/6YFxbvAQXUCavSoZhPPj6oOx+5KjQ==",
-      "dev": true,
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/fastify"
-        },
-        {
-          "type": "opencollective",
-          "url": "https://opencollective.com/fastify"
-        }
-      ],
-      "license": "BSD-3-Clause"
-    },
-    "node_modules/fdir": {
-      "version": "6.5.0",
-      "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz",
-      "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=12.0.0"
-      },
-      "peerDependencies": {
-        "picomatch": "^3 || ^4"
-      },
-      "peerDependenciesMeta": {
-        "picomatch": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/fflate": {
-      "version": "0.8.3",
-      "resolved": "https://registry.npmjs.org/fflate/-/fflate-0.8.3.tgz",
-      "integrity": "sha512-tbZNuJrLwGUp3zshBtdy4W+ORxZuIh8a5ilyIEQDC5rY1f3U20JMry0Ll3WBzU58EZKsEuJFXhb5gwv8CsPvgA==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/finalhandler": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-2.1.1.tgz",
-      "integrity": "sha512-S8KoZgRZN+a5rNwqTxlZZePjT/4cnm0ROV70LedRHZ0p8u9fRID0hJUZQpkKLzro8LfmC8sx23bY6tVNxv8pQA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "debug": "^4.4.0",
-        "encodeurl": "^2.0.0",
-        "escape-html": "^1.0.3",
-        "on-finished": "^2.4.1",
-        "parseurl": "^1.3.3",
-        "statuses": "^2.0.1"
-      },
-      "engines": {
-        "node": ">= 18.0.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/express"
-      }
-    },
-    "node_modules/forwarded": {
-      "version": "0.2.0",
-      "resolved": "https://registry.npmjs.org/forwarded/-/forwarded-0.2.0.tgz",
-      "integrity": "sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.6"
-      }
-    },
-    "node_modules/fresh": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/fresh/-/fresh-2.0.0.tgz",
-      "integrity": "sha512-Rx/WycZ60HOaqLKAi6cHRKKI7zxWbJ31MhntmtwMoaTeF7XFH9hhBp8vITaMidfljRQ6eYWCKkaTK+ykVJHP2A==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.8"
-      }
-    },
-    "node_modules/fs-minipass": {
-      "version": "3.0.3",
-      "resolved": "https://registry.npmjs.org/fs-minipass/-/fs-minipass-3.0.3.tgz",
-      "integrity": "sha512-XUBA9XClHbnJWSfBzjkm6RvPsyg3sryZt06BEQoXcF7EK/xpGaQYJgQKDJSUH5SGZ76Y7pFx1QBnXz09rU5Fbw==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "minipass": "^7.0.3"
-      },
-      "engines": {
-        "node": "^14.17.0 || ^16.13.0 || >=18.0.0"
-      }
-    },
-    "node_modules/fsevents": {
-      "version": "2.3.3",
-      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
-      "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
-      "dev": true,
-      "hasInstallScript": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "darwin"
-      ],
-      "engines": {
-        "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
-      }
-    },
-    "node_modules/function-bind": {
-      "version": "1.1.2",
-      "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz",
-      "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==",
-      "dev": true,
-      "license": "MIT",
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/gensync": {
-      "version": "1.0.0-beta.2",
-      "resolved": "https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.2.tgz",
-      "integrity": "sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=6.9.0"
-      }
-    },
-    "node_modules/get-caller-file": {
-      "version": "2.0.5",
-      "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz",
-      "integrity": "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==",
-      "dev": true,
-      "license": "ISC",
-      "engines": {
-        "node": "6.* || 8.* || >= 10.*"
-      }
-    },
-    "node_modules/get-east-asian-width": {
-      "version": "1.6.0",
-      "resolved": "https://registry.npmjs.org/get-east-asian-width/-/get-east-asian-width-1.6.0.tgz",
-      "integrity": "sha512-QRbvDIbx6YklUe6RxeTeleMR0yv3cYH6PsPZHcnVn7xv7zO1BHN8r0XETu8n6Ye3Q+ahtSarc3WgtNWmehIBfA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/get-intrinsic": {
-      "version": "1.3.0",
-      "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.3.0.tgz",
-      "integrity": "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bind-apply-helpers": "^1.0.2",
-        "es-define-property": "^1.0.1",
-        "es-errors": "^1.3.0",
-        "es-object-atoms": "^1.1.1",
-        "function-bind": "^1.1.2",
-        "get-proto": "^1.0.1",
-        "gopd": "^1.2.0",
-        "has-symbols": "^1.1.0",
-        "hasown": "^2.0.2",
-        "math-intrinsics": "^1.1.0"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/get-proto": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/get-proto/-/get-proto-1.0.1.tgz",
-      "integrity": "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "dunder-proto": "^1.0.1",
-        "es-object-atoms": "^1.0.0"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/glob": {
-      "version": "13.0.6",
-      "resolved": "https://registry.npmjs.org/glob/-/glob-13.0.6.tgz",
-      "integrity": "sha512-Wjlyrolmm8uDpm/ogGyXZXb1Z+Ca2B8NbJwqBVg0axK9GbBeoS7yGV6vjXnYdGm6X53iehEuxxbyiKp8QmN4Vw==",
-      "dev": true,
-      "license": "BlueOak-1.0.0",
-      "dependencies": {
-        "minimatch": "^10.2.2",
-        "minipass": "^7.1.3",
-        "path-scurry": "^2.0.2"
-      },
-      "engines": {
-        "node": "18 || 20 || >=22"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/isaacs"
-      }
-    },
-    "node_modules/glob-to-regexp": {
-      "version": "0.4.1",
-      "resolved": "https://registry.npmjs.org/glob-to-regexp/-/glob-to-regexp-0.4.1.tgz",
-      "integrity": "sha512-lkX1HJXwyMcprw/5YUZc2s7DrpAiHB21/V+E1rHUrVNokkvB6bqMzT0VfV6/86ZNabt1k14YOIaT7nDvOX3Iiw==",
-      "dev": true,
-      "license": "BSD-2-Clause"
-    },
-    "node_modules/gopd": {
-      "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz",
-      "integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/graceful-fs": {
-      "version": "4.2.11",
-      "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz",
-      "integrity": "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==",
-      "dev": true,
-      "license": "ISC"
-    },
-    "node_modules/has-symbols": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz",
-      "integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/hasown": {
-      "version": "2.0.4",
-      "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.4.tgz",
-      "integrity": "sha512-T2UbfbBEF32wiepXIsMlTW9+dDYC6wMh/t/vYA4tuOMKqWz/n3vr1NFSxQiyP+zk2mXsoMA/i/7qV6LKut1t1A==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "function-bind": "^1.1.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/hono": {
-      "version": "4.12.23",
-      "resolved": "https://registry.npmjs.org/hono/-/hono-4.12.23.tgz",
-      "integrity": "sha512-eIaZ9qDgu7XV0pxOCrg7/WhnQ6Ivm22UcxhXx/A3dcbqbbYgBEkc6e/J/s7j2tS96zoB0S9VBdLwQNCWwUo4LA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=16.9.0"
-      }
-    },
-    "node_modules/hosted-git-info": {
-      "version": "9.0.3",
-      "resolved": "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-9.0.3.tgz",
-      "integrity": "sha512-Hc+ghLoSt6QaYZUv0WBiIvmMDZuZZ7oaDvdH8MbfOO4lOsxdXLEvuC6ePoGs9H1X9oCLyq6+NVN0MKqD+ydxyg==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "lru-cache": "^11.1.0"
-      },
-      "engines": {
-        "node": "^20.17.0 || >=22.9.0"
-      }
-    },
-    "node_modules/hosted-git-info/node_modules/lru-cache": {
-      "version": "11.5.1",
-      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-11.5.1.tgz",
-      "integrity": "sha512-RPimw/7aMdv2oqRrxKwvZXcPfwBrn/JZ2xYcY9Hus/6LaS3VOAKVWKWgNLCFSiOm1ESXinjsDlidVU7JlnCN2A==",
-      "dev": true,
-      "license": "BlueOak-1.0.0",
-      "engines": {
-        "node": "20 || >=22"
-      }
-    },
-    "node_modules/htmlparser2": {
-      "version": "10.1.0",
-      "resolved": "https://registry.npmjs.org/htmlparser2/-/htmlparser2-10.1.0.tgz",
-      "integrity": "sha512-VTZkM9GWRAtEpveh7MSF6SjjrpNVNNVJfFup7xTY3UpFtm67foy9HDVXneLtFVt4pMz5kZtgNcvCniNFb1hlEQ==",
-      "dev": true,
-      "funding": [
-        "https://github.com/fb55/htmlparser2?sponsor=1",
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/fb55"
-        }
-      ],
-      "license": "MIT",
-      "dependencies": {
-        "domelementtype": "^2.3.0",
-        "domhandler": "^5.0.3",
-        "domutils": "^3.2.2",
-        "entities": "^7.0.1"
-      }
-    },
-    "node_modules/htmlparser2/node_modules/entities": {
-      "version": "7.0.1",
-      "resolved": "https://registry.npmjs.org/entities/-/entities-7.0.1.tgz",
-      "integrity": "sha512-TWrgLOFUQTH994YUyl1yT4uyavY5nNB5muff+RtWaqNVCAK408b5ZnnbNAUEWLTCpum9w6arT70i1XdQ4UeOPA==",
-      "dev": true,
-      "license": "BSD-2-Clause",
-      "engines": {
-        "node": ">=0.12"
-      },
-      "funding": {
-        "url": "https://github.com/fb55/entities?sponsor=1"
-      }
-    },
-    "node_modules/http-cache-semantics": {
-      "version": "4.2.0",
-      "resolved": "https://registry.npmjs.org/http-cache-semantics/-/http-cache-semantics-4.2.0.tgz",
-      "integrity": "sha512-dTxcvPXqPvXBQpq5dUr6mEMJX4oIEFv6bwom3FDwKRDsuIjjJGANqhBuoAn9c1RQJIdAKav33ED65E2ys+87QQ==",
-      "dev": true,
-      "license": "BSD-2-Clause"
-    },
-    "node_modules/http-errors": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-2.0.1.tgz",
-      "integrity": "sha512-4FbRdAX+bSdmo4AUFuS0WNiPz8NgFt+r8ThgNWmlrjQjt1Q7ZR9+zTlce2859x4KSXrwIsaeTqDoKQmtP8pLmQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "depd": "~2.0.0",
-        "inherits": "~2.0.4",
-        "setprototypeof": "~1.2.0",
-        "statuses": "~2.0.2",
-        "toidentifier": "~1.0.1"
-      },
-      "engines": {
-        "node": ">= 0.8"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/express"
-      }
-    },
-    "node_modules/http-proxy-agent": {
-      "version": "7.0.2",
-      "resolved": "https://registry.npmjs.org/http-proxy-agent/-/http-proxy-agent-7.0.2.tgz",
-      "integrity": "sha512-T1gkAiYYDWYx3V5Bmyu7HcfcvL7mUrTWiM6yOfa3PIphViJ/gFPbvidQ+veqSOHci/PxBcDabeUNCzpOODJZig==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "agent-base": "^7.1.0",
-        "debug": "^4.3.4"
-      },
-      "engines": {
-        "node": ">= 14"
-      }
-    },
-    "node_modules/https-proxy-agent": {
-      "version": "7.0.6",
-      "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-7.0.6.tgz",
-      "integrity": "sha512-vK9P5/iUfdl95AI+JVyUuIcVtd4ofvtrOr3HNtM2yxC9bnMbEdp3x01OhQNnjb8IJYi38VlTE3mBXwcfvywuSw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "agent-base": "^7.1.2",
-        "debug": "4"
-      },
-      "engines": {
-        "node": ">= 14"
-      }
-    },
-    "node_modules/iconv-lite": {
-      "version": "0.7.2",
-      "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.7.2.tgz",
-      "integrity": "sha512-im9DjEDQ55s9fL4EYzOAv0yMqmMBSZp6G0VvFyTMPKWxiSBHUj9NW/qqLmXUwXrrM7AvqSlTCfvqRb0cM8yYqw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "safer-buffer": ">= 2.1.2 < 3.0.0"
-      },
-      "engines": {
-        "node": ">=0.10.0"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/express"
-      }
-    },
-    "node_modules/ignore-walk": {
-      "version": "8.0.0",
-      "resolved": "https://registry.npmjs.org/ignore-walk/-/ignore-walk-8.0.0.tgz",
-      "integrity": "sha512-FCeMZT4NiRQGh+YkeKMtWrOmBgWjHjMJ26WQWrRQyoyzqevdaGSakUaJW5xQYmjLlUVk2qUnCjYVBax9EKKg8A==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "minimatch": "^10.0.3"
-      },
-      "engines": {
-        "node": "^20.17.0 || >=22.9.0"
-      }
-    },
-    "node_modules/immutable": {
-      "version": "5.1.6",
-      "resolved": "https://registry.npmjs.org/immutable/-/immutable-5.1.6.tgz",
-      "integrity": "sha512-q1swsS8K7L8usSHuOqF2TAoCCkonYz0SG38wLAggaa4Wml70zixIvt2ql4coQ2C2B3hTjltJry4r6bULwgAXLQ==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/inherits": {
-      "version": "2.0.4",
-      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
-      "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
-      "dev": true,
-      "license": "ISC"
-    },
-    "node_modules/ini": {
-      "version": "6.0.0",
-      "resolved": "https://registry.npmjs.org/ini/-/ini-6.0.0.tgz",
-      "integrity": "sha512-IBTdIkzZNOpqm7q3dRqJvMaldXjDHWkEDfrwGEQTs5eaQMWV+djAhR+wahyNNMAa+qpbDUhBMVt4ZKNwpPm7xQ==",
-      "dev": true,
-      "license": "ISC",
-      "engines": {
-        "node": "^20.17.0 || >=22.9.0"
-      }
-    },
-    "node_modules/ip-address": {
-      "version": "10.2.0",
-      "resolved": "https://registry.npmjs.org/ip-address/-/ip-address-10.2.0.tgz",
-      "integrity": "sha512-/+S6j4E9AHvW9SWMSEY9Xfy66O5PWvVEJ08O0y5JGyEKQpojb0K0GKpz/v5HJ/G0vi3D2sjGK78119oXZeE0qA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 12"
-      }
-    },
-    "node_modules/ipaddr.js": {
-      "version": "1.9.1",
-      "resolved": "https://registry.npmjs.org/ipaddr.js/-/ipaddr.js-1.9.1.tgz",
-      "integrity": "sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.10"
-      }
-    },
-    "node_modules/is-extglob": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz",
-      "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==",
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/is-fullwidth-code-point": {
-      "version": "5.1.0",
-      "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-5.1.0.tgz",
-      "integrity": "sha512-5XHYaSyiqADb4RnZ1Bdad6cPp8Toise4TzEjcOYDHZkTCbKgiUl7WTUCpNWHuxmDt91wnsZBc9xinNzopv3JMQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "get-east-asian-width": "^1.3.1"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/is-glob": {
-      "version": "4.0.3",
-      "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz",
-      "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==",
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "dependencies": {
-        "is-extglob": "^2.1.1"
-      },
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/is-interactive": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/is-interactive/-/is-interactive-2.0.0.tgz",
-      "integrity": "sha512-qP1vozQRI+BMOPcjFzrjXuQvdak2pHNUMZoeG2eRbiSqyvbEf/wQtEOTOX1guk6E3t36RkaqiSt8A/6YElNxLQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/is-promise": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/is-promise/-/is-promise-4.0.0.tgz",
-      "integrity": "sha512-hvpoI6korhJMnej285dSg6nu1+e6uxs7zG3BYAm5byqDsgJNWwxzM6z6iZiAgQR4TJ30JmBTOwqZUw3WlyH3AQ==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/is-unicode-supported": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/is-unicode-supported/-/is-unicode-supported-2.1.0.tgz",
-      "integrity": "sha512-mE00Gnza5EEB3Ds0HfMyllZzbBrmLOX3vfWoj9A9PEnTfratQ/BcaJOuMhnkhjXvb2+FkY3VuHqtAGpTPmglFQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/isexe": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
-      "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==",
-      "dev": true,
-      "license": "ISC"
-    },
-    "node_modules/istanbul-lib-coverage": {
-      "version": "3.2.2",
-      "resolved": "https://registry.npmjs.org/istanbul-lib-coverage/-/istanbul-lib-coverage-3.2.2.tgz",
-      "integrity": "sha512-O8dpsF+r0WV/8MNRKfnmrtCWhuKjxrq2w+jpzBL5UZKTi2LeVWnWOmWRxFlesJONmc+wLAGvKQZEOanko0LFTg==",
-      "dev": true,
-      "license": "BSD-3-Clause",
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/istanbul-lib-instrument": {
-      "version": "6.0.3",
-      "resolved": "https://registry.npmjs.org/istanbul-lib-instrument/-/istanbul-lib-instrument-6.0.3.tgz",
-      "integrity": "sha512-Vtgk7L/R2JHyyGW07spoFlB8/lpjiOLTjMdms6AFMraYt3BaJauod/NGrfnVG/y4Ix1JEuMRPDPEj2ua+zz1/Q==",
-      "dev": true,
-      "license": "BSD-3-Clause",
-      "dependencies": {
-        "@babel/core": "^7.23.9",
-        "@babel/parser": "^7.23.9",
-        "@istanbuljs/schema": "^0.1.3",
-        "istanbul-lib-coverage": "^3.2.0",
-        "semver": "^7.5.4"
-      },
-      "engines": {
-        "node": ">=10"
-      }
-    },
-    "node_modules/jose": {
-      "version": "6.2.3",
-      "resolved": "https://registry.npmjs.org/jose/-/jose-6.2.3.tgz",
-      "integrity": "sha512-YYVDInQKFJfR/xa3ojUTl8c2KoTwiL1R5Wg9YCydwH0x0B9grbzlg5HC7mMjCtUJjbQ/YnGEZIhI5tCgfTb4Hw==",
-      "dev": true,
-      "license": "MIT",
-      "funding": {
-        "url": "https://github.com/sponsors/panva"
-      }
-    },
-    "node_modules/js-tokens": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz",
-      "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/jsesc": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-3.1.0.tgz",
-      "integrity": "sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==",
-      "dev": true,
-      "license": "MIT",
-      "bin": {
-        "jsesc": "bin/jsesc"
-      },
-      "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/json-parse-even-better-errors": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/json-parse-even-better-errors/-/json-parse-even-better-errors-5.0.0.tgz",
-      "integrity": "sha512-ZF1nxZ28VhQouRWhUcVlUIN3qwSgPuswK05s/HIaoetAoE/9tngVmCHjSxmSQPav1nd+lPtTL0YZ/2AFdR/iYQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": "^20.17.0 || >=22.9.0"
-      }
-    },
-    "node_modules/json-schema-traverse": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz",
-      "integrity": "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/json-schema-typed": {
-      "version": "8.0.2",
-      "resolved": "https://registry.npmjs.org/json-schema-typed/-/json-schema-typed-8.0.2.tgz",
-      "integrity": "sha512-fQhoXdcvc3V28x7C7BMs4P5+kNlgUURe2jmUT1T//oBRMDrqy1QPelJimwZGo7Hg9VPV3EQV5Bnq4hbFy2vetA==",
-      "dev": true,
-      "license": "BSD-2-Clause"
-    },
-    "node_modules/json5": {
-      "version": "2.2.3",
-      "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.3.tgz",
-      "integrity": "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==",
-      "dev": true,
-      "license": "MIT",
-      "bin": {
-        "json5": "lib/cli.js"
-      },
-      "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/jsonc-parser": {
-      "version": "3.3.1",
-      "resolved": "https://registry.npmjs.org/jsonc-parser/-/jsonc-parser-3.3.1.tgz",
-      "integrity": "sha512-HUgH65KyejrUFPvHFPbqOY0rsFip3Bo5wb4ngvdi1EpCYWUQDC5V+Y7mZws+DLkr4M//zQJoanu1SP+87Dv1oQ==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/jsonparse": {
-      "version": "1.3.1",
-      "resolved": "https://registry.npmjs.org/jsonparse/-/jsonparse-1.3.1.tgz",
-      "integrity": "sha512-POQXvpdL69+CluYsillJ7SUhKvytYjW9vG/GKpnf+xP8UWgYEM/RaMzHHofbALDiKbbP1W8UEYmgGl39WkPZsg==",
-      "dev": true,
-      "engines": [
-        "node >= 0.2.0"
-      ],
-      "license": "MIT"
-    },
-    "node_modules/listr2": {
-      "version": "9.0.5",
-      "resolved": "https://registry.npmjs.org/listr2/-/listr2-9.0.5.tgz",
-      "integrity": "sha512-ME4Fb83LgEgwNw96RKNvKV4VTLuXfoKudAmm2lP8Kk87KaMK0/Xrx/aAkMWmT8mDb+3MlFDspfbCs7adjRxA2g==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "cli-truncate": "^5.0.0",
-        "colorette": "^2.0.20",
-        "eventemitter3": "^5.0.1",
-        "log-update": "^6.1.0",
-        "rfdc": "^1.4.1",
-        "wrap-ansi": "^9.0.0"
-      },
-      "engines": {
-        "node": ">=20.0.0"
-      }
-    },
-    "node_modules/listr2/node_modules/string-width": {
-      "version": "7.2.0",
-      "resolved": "https://registry.npmjs.org/string-width/-/string-width-7.2.0.tgz",
-      "integrity": "sha512-tsaTIkKW9b4N+AEj+SVA+WhJzV7/zMhcSu78mLKWSk7cXMOSHsBKFWUs0fWwq8QyK3MgJBQRX6Gbi4kYbdvGkQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "emoji-regex": "^10.3.0",
-        "get-east-asian-width": "^1.0.0",
-        "strip-ansi": "^7.1.0"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/listr2/node_modules/wrap-ansi": {
-      "version": "9.0.2",
-      "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-9.0.2.tgz",
-      "integrity": "sha512-42AtmgqjV+X1VpdOfyTGOYRi0/zsoLqtXQckTmqTeybT+BDIbM/Guxo7x3pE2vtpr1ok6xRqM9OpBe+Jyoqyww==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ansi-styles": "^6.2.1",
-        "string-width": "^7.0.0",
-        "strip-ansi": "^7.1.0"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/wrap-ansi?sponsor=1"
-      }
-    },
-    "node_modules/lmdb": {
-      "version": "3.5.1",
-      "resolved": "https://registry.npmjs.org/lmdb/-/lmdb-3.5.1.tgz",
-      "integrity": "sha512-NYHA0MRPjvNX+vSw8Xxg6FLKxzAG+e7Pt8RqAQA/EehzHVXq9SxDqJIN3JL1hK0dweb884y8kIh6rkWvPyg9Wg==",
-      "dev": true,
-      "hasInstallScript": true,
-      "license": "MIT",
-      "optional": true,
-      "dependencies": {
-        "@harperfast/extended-iterable": "^1.0.3",
-        "msgpackr": "^1.11.2",
-        "node-addon-api": "^6.1.0",
-        "node-gyp-build-optional-packages": "5.2.2",
-        "ordered-binary": "^1.5.3",
-        "weak-lru-cache": "^1.2.2"
-      },
-      "bin": {
-        "download-lmdb-prebuilds": "bin/download-prebuilds.js"
-      },
-      "optionalDependencies": {
-        "@lmdb/lmdb-darwin-arm64": "3.5.1",
-        "@lmdb/lmdb-darwin-x64": "3.5.1",
-        "@lmdb/lmdb-linux-arm": "3.5.1",
-        "@lmdb/lmdb-linux-arm64": "3.5.1",
-        "@lmdb/lmdb-linux-x64": "3.5.1",
-        "@lmdb/lmdb-win32-arm64": "3.5.1",
-        "@lmdb/lmdb-win32-x64": "3.5.1"
-      }
-    },
-    "node_modules/log-symbols": {
-      "version": "7.0.1",
-      "resolved": "https://registry.npmjs.org/log-symbols/-/log-symbols-7.0.1.tgz",
-      "integrity": "sha512-ja1E3yCr9i/0hmBVaM0bfwDjnGy8I/s6PP4DFp+yP+a+mrHO4Rm7DtmnqROTUkHIkqffC84YY7AeqX6oFk0WFg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "is-unicode-supported": "^2.0.0",
-        "yoctocolors": "^2.1.1"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/log-update": {
-      "version": "6.1.0",
-      "resolved": "https://registry.npmjs.org/log-update/-/log-update-6.1.0.tgz",
-      "integrity": "sha512-9ie8ItPR6tjY5uYJh8K/Zrv/RMZ5VOlOWvtZdEHYSTFKZfIBPQa9tOAEeAWhd+AnIneLJ22w5fjOYtoutpWq5w==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ansi-escapes": "^7.0.0",
-        "cli-cursor": "^5.0.0",
-        "slice-ansi": "^7.1.0",
-        "strip-ansi": "^7.1.0",
-        "wrap-ansi": "^9.0.0"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/log-update/node_modules/slice-ansi": {
-      "version": "7.1.2",
-      "resolved": "https://registry.npmjs.org/slice-ansi/-/slice-ansi-7.1.2.tgz",
-      "integrity": "sha512-iOBWFgUX7caIZiuutICxVgX1SdxwAVFFKwt1EvMYYec/NWO5meOJ6K5uQxhrYBdQJne4KxiqZc+KptFOWFSI9w==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ansi-styles": "^6.2.1",
-        "is-fullwidth-code-point": "^5.0.0"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/slice-ansi?sponsor=1"
-      }
-    },
-    "node_modules/log-update/node_modules/string-width": {
-      "version": "7.2.0",
-      "resolved": "https://registry.npmjs.org/string-width/-/string-width-7.2.0.tgz",
-      "integrity": "sha512-tsaTIkKW9b4N+AEj+SVA+WhJzV7/zMhcSu78mLKWSk7cXMOSHsBKFWUs0fWwq8QyK3MgJBQRX6Gbi4kYbdvGkQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "emoji-regex": "^10.3.0",
-        "get-east-asian-width": "^1.0.0",
-        "strip-ansi": "^7.1.0"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/log-update/node_modules/wrap-ansi": {
-      "version": "9.0.2",
-      "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-9.0.2.tgz",
-      "integrity": "sha512-42AtmgqjV+X1VpdOfyTGOYRi0/zsoLqtXQckTmqTeybT+BDIbM/Guxo7x3pE2vtpr1ok6xRqM9OpBe+Jyoqyww==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ansi-styles": "^6.2.1",
-        "string-width": "^7.0.0",
-        "strip-ansi": "^7.1.0"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/wrap-ansi?sponsor=1"
-      }
-    },
-    "node_modules/lru-cache": {
-      "version": "5.1.1",
-      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz",
-      "integrity": "sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "yallist": "^3.0.2"
-      }
-    },
-    "node_modules/magic-string": {
-      "version": "0.30.21",
-      "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.21.tgz",
-      "integrity": "sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@jridgewell/sourcemap-codec": "^1.5.5"
-      }
-    },
-    "node_modules/make-fetch-happen": {
-      "version": "15.0.6",
-      "resolved": "https://registry.npmjs.org/make-fetch-happen/-/make-fetch-happen-15.0.6.tgz",
-      "integrity": "sha512-Je0fLJ0F5atA7F+eIlLzk+Wkcl57JDf4kf+EW8xiP5E31xOQxkIxTbgf1Oi1Lw9tRI9UEMRdI5Vz2xTzoNU1Jw==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "@gar/promise-retry": "^1.0.0",
-        "@npmcli/agent": "^4.0.0",
-        "@npmcli/redact": "^4.0.0",
-        "cacache": "^20.0.1",
-        "http-cache-semantics": "^4.1.1",
-        "minipass": "^7.0.2",
-        "minipass-fetch": "^5.0.0",
-        "minipass-flush": "^1.0.5",
-        "minipass-pipeline": "^1.2.4",
-        "negotiator": "^1.0.0",
-        "proc-log": "^6.0.0",
-        "ssri": "^13.0.0"
-      },
-      "engines": {
-        "node": "^20.17.0 || >=22.9.0"
-      }
-    },
-    "node_modules/math-intrinsics": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz",
-      "integrity": "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/media-typer": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/media-typer/-/media-typer-1.1.0.tgz",
-      "integrity": "sha512-aisnrDP4GNe06UcKFnV5bfMNPBUw4jsLGaWwWfnH3v02GnBuXX2MCVn5RbrWo0j3pczUilYblq7fQ7Nw2t5XKw==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.8"
-      }
-    },
-    "node_modules/merge-descriptors": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/merge-descriptors/-/merge-descriptors-2.0.0.tgz",
-      "integrity": "sha512-Snk314V5ayFLhp3fkUREub6WtjBfPdCPY1Ln8/8munuLuiYhsABgBVWsozAG+MWMbVEvcdcpbi9R7ww22l9Q3g==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/meshoptimizer": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/meshoptimizer/-/meshoptimizer-1.1.1.tgz",
-      "integrity": "sha512-oRFNWJRDA/WTrVj7NWvqa5HqE1t9MYDj2VaWirQCzCCrAd2GHrqR/sQezCxiWATPNlKTcRaPRHPJwIRoPBAp5g==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/mime-db": {
-      "version": "1.54.0",
-      "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.54.0.tgz",
-      "integrity": "sha512-aU5EJuIN2WDemCcAp2vFBfp/m4EAhWJnUNSSw0ixs7/kXbd6Pg64EmwJkNdFhB8aWt1sH2CTXrLxo/iAGV3oPQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.6"
-      }
-    },
-    "node_modules/mime-types": {
-      "version": "3.0.2",
-      "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-3.0.2.tgz",
-      "integrity": "sha512-Lbgzdk0h4juoQ9fCKXW4by0UJqj+nOOrI9MJ1sSj4nI8aI2eo1qmvQEie4VD1glsS250n15LsWsYtCugiStS5A==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "mime-db": "^1.54.0"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/express"
-      }
-    },
-    "node_modules/mimic-function": {
-      "version": "5.0.1",
-      "resolved": "https://registry.npmjs.org/mimic-function/-/mimic-function-5.0.1.tgz",
-      "integrity": "sha512-VP79XUPxV2CigYP3jWwAUFSku2aKqBH7uTAapFWCBqutsbmDo96KY5o8uh6U+/YSIn5OxJnXp73beVkpqMIGhA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/minimatch": {
-      "version": "10.2.5",
-      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-10.2.5.tgz",
-      "integrity": "sha512-MULkVLfKGYDFYejP07QOurDLLQpcjk7Fw+7jXS2R2czRQzR56yHRveU5NDJEOviH+hETZKSkIk5c+T23GjFUMg==",
-      "dev": true,
-      "license": "BlueOak-1.0.0",
-      "dependencies": {
-        "brace-expansion": "^5.0.5"
-      },
-      "engines": {
-        "node": "18 || 20 || >=22"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/isaacs"
-      }
-    },
-    "node_modules/minipass": {
-      "version": "7.1.3",
-      "resolved": "https://registry.npmjs.org/minipass/-/minipass-7.1.3.tgz",
-      "integrity": "sha512-tEBHqDnIoM/1rXME1zgka9g6Q2lcoCkxHLuc7ODJ5BxbP5d4c2Z5cGgtXAku59200Cx7diuHTOYfSBD8n6mm8A==",
-      "dev": true,
-      "license": "BlueOak-1.0.0",
-      "engines": {
-        "node": ">=16 || 14 >=14.17"
-      }
-    },
-    "node_modules/minipass-collect": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/minipass-collect/-/minipass-collect-2.0.1.tgz",
-      "integrity": "sha512-D7V8PO9oaz7PWGLbCACuI1qEOsq7UKfLotx/C0Aet43fCUB/wfQ7DYeq2oR/svFJGYDHPr38SHATeaj/ZoKHKw==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "minipass": "^7.0.3"
-      },
-      "engines": {
-        "node": ">=16 || 14 >=14.17"
-      }
-    },
-    "node_modules/minipass-fetch": {
-      "version": "5.0.2",
-      "resolved": "https://registry.npmjs.org/minipass-fetch/-/minipass-fetch-5.0.2.tgz",
-      "integrity": "sha512-2d0q2a8eCi2IRg/IGubCNRJoYbA1+YPXAzQVRFmB45gdGZafyivnZ5YSEfo3JikbjGxOdntGFvBQGqaSMXlAFQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "minipass": "^7.0.3",
-        "minipass-sized": "^2.0.0",
-        "minizlib": "^3.0.1"
-      },
-      "engines": {
-        "node": "^20.17.0 || >=22.9.0"
-      },
-      "optionalDependencies": {
-        "iconv-lite": "^0.7.2"
-      }
-    },
-    "node_modules/minipass-flush": {
-      "version": "1.0.7",
-      "resolved": "https://registry.npmjs.org/minipass-flush/-/minipass-flush-1.0.7.tgz",
-      "integrity": "sha512-TbqTz9cUwWyHS2Dy89P3ocAGUGxKjjLuR9z8w4WUTGAVgEj17/4nhgo2Du56i0Fm3Pm30g4iA8Lcqctc76jCzA==",
-      "dev": true,
-      "license": "BlueOak-1.0.0",
-      "dependencies": {
-        "minipass": "^3.0.0"
-      },
-      "engines": {
-        "node": ">= 8"
-      }
-    },
-    "node_modules/minipass-flush/node_modules/minipass": {
-      "version": "3.3.6",
-      "resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz",
-      "integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "yallist": "^4.0.0"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/minipass-flush/node_modules/yallist": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz",
-      "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==",
-      "dev": true,
-      "license": "ISC"
-    },
-    "node_modules/minipass-pipeline": {
-      "version": "1.2.4",
-      "resolved": "https://registry.npmjs.org/minipass-pipeline/-/minipass-pipeline-1.2.4.tgz",
-      "integrity": "sha512-xuIq7cIOt09RPRJ19gdi4b+RiNvDFYe5JH+ggNvBqGqpQXcru3PcRmOZuHBKWK1Txf9+cQ+HMVN4d6z46LZP7A==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "minipass": "^3.0.0"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/minipass-pipeline/node_modules/minipass": {
-      "version": "3.3.6",
-      "resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz",
-      "integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "yallist": "^4.0.0"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/minipass-pipeline/node_modules/yallist": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz",
-      "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==",
-      "dev": true,
-      "license": "ISC"
-    },
-    "node_modules/minipass-sized": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/minipass-sized/-/minipass-sized-2.0.0.tgz",
-      "integrity": "sha512-zSsHhto5BcUVM2m1LurnXY6M//cGhVaegT71OfOXoprxT6o780GZd792ea6FfrQkuU4usHZIUczAQMRUE2plzA==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "minipass": "^7.1.2"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/minizlib": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/minizlib/-/minizlib-3.1.0.tgz",
-      "integrity": "sha512-KZxYo1BUkWD2TVFLr0MQoM8vUUigWD3LlD83a/75BqC+4qE0Hb1Vo5v1FgcfaNXvfXzr+5EhQ6ing/CaBijTlw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "minipass": "^7.1.2"
-      },
-      "engines": {
-        "node": ">= 18"
-      }
-    },
-    "node_modules/mrmime": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/mrmime/-/mrmime-2.0.1.tgz",
-      "integrity": "sha512-Y3wQdFg2Va6etvQ5I82yUhGdsKrcYox6p7FfL1LbK2J4V01F9TGlepTIhnK24t7koZibmg82KGglhA1XK5IsLQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=10"
-      }
-    },
-    "node_modules/ms": {
-      "version": "2.1.3",
-      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
-      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/msgpackr": {
-      "version": "1.11.12",
-      "resolved": "https://registry.npmjs.org/msgpackr/-/msgpackr-1.11.12.tgz",
-      "integrity": "sha512-RBdJ1Un7yGlXWajrkxcSa93nvQ0w4zBf60c0yYv7YtBelP8H2FA7XsfBbMHtXKXUMUxH7zV3Zuozh+kUQWhHvg==",
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "optionalDependencies": {
-        "msgpackr-extract": "^3.0.2"
-      }
-    },
-    "node_modules/msgpackr-extract": {
-      "version": "3.0.4",
-      "resolved": "https://registry.npmjs.org/msgpackr-extract/-/msgpackr-extract-3.0.4.tgz",
-      "integrity": "sha512-4kmO/MdyUIkLIvTPr8VHLil4AtoKIoniWPIEk5+CDy0xnWC84azhSFmuJ7PxZdsYtiP5kEeQsORAVIeMgxT+Hw==",
-      "dev": true,
-      "hasInstallScript": true,
-      "license": "MIT",
-      "optional": true,
-      "dependencies": {
-        "node-gyp-build-optional-packages": "5.2.2"
-      },
-      "bin": {
-        "download-msgpackr-prebuilds": "bin/download-prebuilds.js"
-      },
-      "optionalDependencies": {
-        "@msgpackr-extract/msgpackr-extract-darwin-arm64": "3.0.4",
-        "@msgpackr-extract/msgpackr-extract-darwin-x64": "3.0.4",
-        "@msgpackr-extract/msgpackr-extract-linux-arm": "3.0.4",
-        "@msgpackr-extract/msgpackr-extract-linux-arm64": "3.0.4",
-        "@msgpackr-extract/msgpackr-extract-linux-x64": "3.0.4",
-        "@msgpackr-extract/msgpackr-extract-win32-x64": "3.0.4"
-      }
-    },
-    "node_modules/mute-stream": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/mute-stream/-/mute-stream-2.0.0.tgz",
-      "integrity": "sha512-WWdIxpyjEn+FhQJQQv9aQAYlHoNVdzIzUySNV1gHUPDSdZJ3yZn7pAAbQcV7B56Mvu881q9FZV+0Vx2xC44VWA==",
-      "dev": true,
-      "license": "ISC",
-      "engines": {
-        "node": "^18.17.0 || >=20.5.0"
-      }
-    },
-    "node_modules/nanoid": {
-      "version": "3.3.12",
-      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.12.tgz",
-      "integrity": "sha512-ZB9RH/39qpq5Vu6Y+NmUaFhQR6pp+M2Xt76XBnEwDaGcVAqhlvxrl3B2bKS5D3NH3QR76v3aSrKaF/Kiy7lEtQ==",
-      "dev": true,
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/ai"
-        }
-      ],
-      "license": "MIT",
-      "bin": {
-        "nanoid": "bin/nanoid.cjs"
-      },
-      "engines": {
-        "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
-      }
-    },
-    "node_modules/negotiator": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-1.0.0.tgz",
-      "integrity": "sha512-8Ofs/AUQh8MaEcrlq5xOX0CQ9ypTF5dl78mjlMNfOK08fzpgTHQRQPBxcPlEtIw0yRpws+Zo/3r+5WRby7u3Gg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.6"
-      }
-    },
-    "node_modules/ngx-echarts": {
-      "version": "21.0.0",
-      "resolved": "https://registry.npmjs.org/ngx-echarts/-/ngx-echarts-21.0.0.tgz",
-      "integrity": "sha512-vivBRmGYMFlnPxK/uxliY+sexGwHqnFZ2pylGbIMF2wikt9RpZpGGSitLmuUXvzYwkVFGo6dQmiUQh1+6Pbfuw==",
-      "license": "MIT",
-      "dependencies": {
-        "tslib": "^2.3.0"
-      },
-      "peerDependencies": {
-        "@angular/core": ">=21.0.0",
-        "echarts": ">=5.0.0"
-      }
-    },
-    "node_modules/node-addon-api": {
-      "version": "6.1.0",
-      "resolved": "https://registry.npmjs.org/node-addon-api/-/node-addon-api-6.1.0.tgz",
-      "integrity": "sha512-+eawOlIgy680F0kBzPUNFhMZGtJ1YmqM6l4+Crf4IkImjYrO/mqPwRMh352g23uIaQKFItcQ64I7KMaJxHgAVA==",
-      "dev": true,
-      "license": "MIT",
-      "optional": true
-    },
-    "node_modules/node-gyp": {
-      "version": "12.3.0",
-      "resolved": "https://registry.npmjs.org/node-gyp/-/node-gyp-12.3.0.tgz",
-      "integrity": "sha512-QNcUWM+HgJplcPzBvFBZ9VXacyGZ4+VTOb80PwWR+TlVzoHbRKULNEzpRsnaoxG3Wzr7Qh7BYxGDU3CbKib2Yg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "env-paths": "^2.2.0",
-        "exponential-backoff": "^3.1.1",
-        "graceful-fs": "^4.2.6",
-        "nopt": "^9.0.0",
-        "proc-log": "^6.0.0",
-        "semver": "^7.3.5",
-        "tar": "^7.5.4",
-        "tinyglobby": "^0.2.12",
-        "undici": "^6.25.0",
-        "which": "^6.0.0"
-      },
-      "bin": {
-        "node-gyp": "bin/node-gyp.js"
-      },
-      "engines": {
-        "node": "^20.17.0 || >=22.9.0"
-      }
-    },
-    "node_modules/node-gyp-build-optional-packages": {
-      "version": "5.2.2",
-      "resolved": "https://registry.npmjs.org/node-gyp-build-optional-packages/-/node-gyp-build-optional-packages-5.2.2.tgz",
-      "integrity": "sha512-s+w+rBWnpTMwSFbaE0UXsRlg7hU4FjekKU4eyAih5T8nJuNZT1nNsskXpxmeqSK9UzkBl6UgRlnKc8hz8IEqOw==",
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "dependencies": {
-        "detect-libc": "^2.0.1"
-      },
-      "bin": {
-        "node-gyp-build-optional-packages": "bin.js",
-        "node-gyp-build-optional-packages-optional": "optional.js",
-        "node-gyp-build-optional-packages-test": "build-test.js"
-      }
-    },
-    "node_modules/node-gyp/node_modules/isexe": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/isexe/-/isexe-4.0.0.tgz",
-      "integrity": "sha512-FFUtZMpoZ8RqHS3XeXEmHWLA4thH+ZxCv2lOiPIn1Xc7CxrqhWzNSDzD+/chS/zbYezmiwWLdQC09JdQKmthOw==",
-      "dev": true,
-      "license": "BlueOak-1.0.0",
-      "engines": {
-        "node": ">=20"
-      }
-    },
-    "node_modules/node-gyp/node_modules/undici": {
-      "version": "6.26.0",
-      "resolved": "https://registry.npmjs.org/undici/-/undici-6.26.0.tgz",
-      "integrity": "sha512-4yqz8a3n5HmGTlsbADNtr/dJlhkh/55Rq798G6ibiULcXbDtaLpTl1pvdqcbFfeoj3iSi52lePFM7h9H21cw/A==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=18.17"
-      }
-    },
-    "node_modules/node-gyp/node_modules/which": {
-      "version": "6.0.1",
-      "resolved": "https://registry.npmjs.org/which/-/which-6.0.1.tgz",
-      "integrity": "sha512-oGLe46MIrCRqX7ytPUf66EAYvdeMIZYn3WaocqqKZAxrBpkqHfL/qvTyJ/bTk5+AqHCjXmrv3CEWgy368zhRUg==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "isexe": "^4.0.0"
-      },
-      "bin": {
-        "node-which": "bin/which.js"
-      },
-      "engines": {
-        "node": "^20.17.0 || >=22.9.0"
-      }
-    },
-    "node_modules/node-releases": {
-      "version": "2.0.46",
-      "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.46.tgz",
-      "integrity": "sha512-GYVXHE2KnrzAfsAjl4uP++evGFCrAU1jta4ubEjIG7YWt/64Gqv66a30yKwWczVjA6j3bM4nBwH7Pk1JmDHaxQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/nopt": {
-      "version": "9.0.0",
-      "resolved": "https://registry.npmjs.org/nopt/-/nopt-9.0.0.tgz",
-      "integrity": "sha512-Zhq3a+yFKrYwSBluL4H9XP3m3y5uvQkB/09CwDruCiRmR/UJYnn9W4R48ry0uGC70aeTPKLynBtscP9efFFcPw==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "abbrev": "^4.0.0"
-      },
-      "bin": {
-        "nopt": "bin/nopt.js"
-      },
-      "engines": {
-        "node": "^20.17.0 || >=22.9.0"
-      }
-    },
-    "node_modules/npm-bundled": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/npm-bundled/-/npm-bundled-5.0.0.tgz",
-      "integrity": "sha512-JLSpbzh6UUXIEoqPsYBvVNVmyrjVZ1fzEFbqxKkTJQkWBO3xFzFT+KDnSKQWwOQNbuWRwt5LSD6HOTLGIWzfrw==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "npm-normalize-package-bin": "^5.0.0"
-      },
-      "engines": {
-        "node": "^20.17.0 || >=22.9.0"
-      }
-    },
-    "node_modules/npm-install-checks": {
-      "version": "8.0.0",
-      "resolved": "https://registry.npmjs.org/npm-install-checks/-/npm-install-checks-8.0.0.tgz",
-      "integrity": "sha512-ScAUdMpyzkbpxoNekQ3tNRdFI8SJ86wgKZSQZdUxT+bj0wVFpsEMWnkXP0twVe1gJyNF5apBWDJhhIbgrIViRA==",
-      "dev": true,
-      "license": "BSD-2-Clause",
-      "dependencies": {
-        "semver": "^7.1.1"
-      },
-      "engines": {
-        "node": "^20.17.0 || >=22.9.0"
-      }
-    },
-    "node_modules/npm-normalize-package-bin": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/npm-normalize-package-bin/-/npm-normalize-package-bin-5.0.0.tgz",
-      "integrity": "sha512-CJi3OS4JLsNMmr2u07OJlhcrPxCeOeP/4xq67aWNai6TNWWbTrlNDgl8NcFKVlcBKp18GPj+EzbNIgrBfZhsag==",
-      "dev": true,
-      "license": "ISC",
-      "engines": {
-        "node": "^20.17.0 || >=22.9.0"
-      }
-    },
-    "node_modules/npm-package-arg": {
-      "version": "13.0.2",
-      "resolved": "https://registry.npmjs.org/npm-package-arg/-/npm-package-arg-13.0.2.tgz",
-      "integrity": "sha512-IciCE3SY3uE84Ld8WZU23gAPPV9rIYod4F+rc+vJ7h7cwAJt9Vk6TVsK60ry7Uj3SRS3bqRRIGuTp9YVlk6WNA==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "hosted-git-info": "^9.0.0",
-        "proc-log": "^6.0.0",
-        "semver": "^7.3.5",
-        "validate-npm-package-name": "^7.0.0"
-      },
-      "engines": {
-        "node": "^20.17.0 || >=22.9.0"
-      }
-    },
-    "node_modules/npm-packlist": {
-      "version": "10.0.4",
-      "resolved": "https://registry.npmjs.org/npm-packlist/-/npm-packlist-10.0.4.tgz",
-      "integrity": "sha512-uMW73iajD8hiH4ZBxEV3HC+eTnppIqwakjOYuvgddnalIw2lJguKviK1pcUJDlIWm1wSJkchpDZDSVVsZEYRng==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "ignore-walk": "^8.0.0",
-        "proc-log": "^6.0.0"
-      },
-      "engines": {
-        "node": "^20.17.0 || >=22.9.0"
-      }
-    },
-    "node_modules/npm-pick-manifest": {
-      "version": "11.0.3",
-      "resolved": "https://registry.npmjs.org/npm-pick-manifest/-/npm-pick-manifest-11.0.3.tgz",
-      "integrity": "sha512-buzyCfeoGY/PxKqmBqn1IUJrZnUi1VVJTdSSRPGI60tJdUhUoSQFhs0zycJokDdOznQentgrpf8LayEHyyYlqQ==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "npm-install-checks": "^8.0.0",
-        "npm-normalize-package-bin": "^5.0.0",
-        "npm-package-arg": "^13.0.0",
-        "semver": "^7.3.5"
-      },
-      "engines": {
-        "node": "^20.17.0 || >=22.9.0"
-      }
-    },
-    "node_modules/npm-registry-fetch": {
-      "version": "19.1.1",
-      "resolved": "https://registry.npmjs.org/npm-registry-fetch/-/npm-registry-fetch-19.1.1.tgz",
-      "integrity": "sha512-TakBap6OM1w0H73VZVDf44iFXsOS3h+L4wVMXmbWOQroZgFhMch0juN6XSzBNlD965yIKvWg2dfu7NSiaYLxtw==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "@npmcli/redact": "^4.0.0",
-        "jsonparse": "^1.3.1",
-        "make-fetch-happen": "^15.0.0",
-        "minipass": "^7.0.2",
-        "minipass-fetch": "^5.0.0",
-        "minizlib": "^3.0.1",
-        "npm-package-arg": "^13.0.0",
-        "proc-log": "^6.0.0"
-      },
-      "engines": {
-        "node": "^20.17.0 || >=22.9.0"
-      }
-    },
-    "node_modules/nth-check": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/nth-check/-/nth-check-2.1.1.tgz",
-      "integrity": "sha512-lqjrjmaOoAnWfMmBPL+XNnynZh2+swxiX3WUE0s4yEHI6m+AwrK2UZOimIRl3X/4QctVqS8AiZjFqyOGrMXb/w==",
-      "dev": true,
-      "license": "BSD-2-Clause",
-      "dependencies": {
-        "boolbase": "^1.0.0"
-      },
-      "funding": {
-        "url": "https://github.com/fb55/nth-check?sponsor=1"
-      }
-    },
-    "node_modules/object-assign": {
-      "version": "4.1.1",
-      "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz",
-      "integrity": "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/object-inspect": {
-      "version": "1.13.4",
-      "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.13.4.tgz",
-      "integrity": "sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/on-finished": {
-      "version": "2.4.1",
-      "resolved": "https://registry.npmjs.org/on-finished/-/on-finished-2.4.1.tgz",
-      "integrity": "sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ee-first": "1.1.1"
-      },
-      "engines": {
-        "node": ">= 0.8"
-      }
-    },
-    "node_modules/once": {
-      "version": "1.4.0",
-      "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
-      "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "wrappy": "1"
-      }
-    },
-    "node_modules/onetime": {
-      "version": "7.0.0",
-      "resolved": "https://registry.npmjs.org/onetime/-/onetime-7.0.0.tgz",
-      "integrity": "sha512-VXJjc87FScF88uafS3JllDgvAm+c/Slfz06lorj2uAY34rlUu0Nt+v8wreiImcrgAjjIHp1rXpTDlLOGw29WwQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "mimic-function": "^5.0.0"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/ora": {
-      "version": "9.3.0",
-      "resolved": "https://registry.npmjs.org/ora/-/ora-9.3.0.tgz",
-      "integrity": "sha512-lBX72MWFduWEf7v7uWf5DHp9Jn5BI8bNPGuFgtXMmr2uDz2Gz2749y3am3agSDdkhHPHYmmxEGSKH85ZLGzgXw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "chalk": "^5.6.2",
-        "cli-cursor": "^5.0.0",
-        "cli-spinners": "^3.2.0",
-        "is-interactive": "^2.0.0",
-        "is-unicode-supported": "^2.1.0",
-        "log-symbols": "^7.0.1",
-        "stdin-discarder": "^0.3.1",
-        "string-width": "^8.1.0"
-      },
-      "engines": {
-        "node": ">=20"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/ordered-binary": {
-      "version": "1.6.1",
-      "resolved": "https://registry.npmjs.org/ordered-binary/-/ordered-binary-1.6.1.tgz",
-      "integrity": "sha512-QkCdPooczexPLiXIrbVOPYkR3VO3T6v2OyKRkR1Xbhpy7/LAVXwahnRCgRp78Oe/Ehf0C/HATAxfSr6eA1oX+w==",
-      "dev": true,
-      "license": "MIT",
-      "optional": true
-    },
-    "node_modules/p-map": {
-      "version": "7.0.4",
-      "resolved": "https://registry.npmjs.org/p-map/-/p-map-7.0.4.tgz",
-      "integrity": "sha512-tkAQEw8ysMzmkhgw8k+1U/iPhWNhykKnSk4Rd5zLoPJCuJaGRPo6YposrZgaxHKzDHdDWWZvE/Sk7hsL2X/CpQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/pacote": {
-      "version": "21.3.1",
-      "resolved": "https://registry.npmjs.org/pacote/-/pacote-21.3.1.tgz",
-      "integrity": "sha512-O0EDXi85LF4AzdjG74GUwEArhdvawi/YOHcsW6IijKNj7wm8IvEWNF5GnfuxNpQ/ZpO3L37+v8hqdVh8GgWYhg==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "@npmcli/git": "^7.0.0",
-        "@npmcli/installed-package-contents": "^4.0.0",
-        "@npmcli/package-json": "^7.0.0",
-        "@npmcli/promise-spawn": "^9.0.0",
-        "@npmcli/run-script": "^10.0.0",
-        "cacache": "^20.0.0",
-        "fs-minipass": "^3.0.0",
-        "minipass": "^7.0.2",
-        "npm-package-arg": "^13.0.0",
-        "npm-packlist": "^10.0.1",
-        "npm-pick-manifest": "^11.0.1",
-        "npm-registry-fetch": "^19.0.0",
-        "proc-log": "^6.0.0",
-        "promise-retry": "^2.0.1",
-        "sigstore": "^4.0.0",
-        "ssri": "^13.0.0",
-        "tar": "^7.4.3"
-      },
-      "bin": {
-        "pacote": "bin/index.js"
-      },
-      "engines": {
-        "node": "^20.17.0 || >=22.9.0"
-      }
-    },
-    "node_modules/parse5": {
-      "version": "8.0.1",
-      "resolved": "https://registry.npmjs.org/parse5/-/parse5-8.0.1.tgz",
-      "integrity": "sha512-z1e/HMG90obSGeidlli3hj7cbocou0/wa5HacvI3ASx34PecNjNQeaHNo5WIZpWofN9kgkqV1q5YvXe3F0FoPw==",
-      "license": "MIT",
-      "dependencies": {
-        "entities": "^8.0.0"
-      },
-      "funding": {
-        "url": "https://github.com/inikulin/parse5?sponsor=1"
-      }
-    },
-    "node_modules/parse5-html-rewriting-stream": {
-      "version": "8.0.0",
-      "resolved": "https://registry.npmjs.org/parse5-html-rewriting-stream/-/parse5-html-rewriting-stream-8.0.0.tgz",
-      "integrity": "sha512-wzh11mj8KKkno1pZEu+l2EVeWsuKDfR5KNWZOTsslfUX8lPDZx77m9T0kIoAVkFtD1nx6YF8oh4BnPHvxMtNMw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "entities": "^6.0.0",
-        "parse5": "^8.0.0",
-        "parse5-sax-parser": "^8.0.0"
-      },
-      "funding": {
-        "url": "https://github.com/inikulin/parse5?sponsor=1"
-      }
-    },
-    "node_modules/parse5-html-rewriting-stream/node_modules/entities": {
-      "version": "6.0.1",
-      "resolved": "https://registry.npmjs.org/entities/-/entities-6.0.1.tgz",
-      "integrity": "sha512-aN97NXWF6AWBTahfVOIrB/NShkzi5H7F9r1s9mD3cDj4Ko5f2qhhVoYMibXF7GlLveb/D2ioWay8lxI97Ven3g==",
-      "dev": true,
-      "license": "BSD-2-Clause",
-      "engines": {
-        "node": ">=0.12"
-      },
-      "funding": {
-        "url": "https://github.com/fb55/entities?sponsor=1"
-      }
-    },
-    "node_modules/parse5-sax-parser": {
-      "version": "8.0.0",
-      "resolved": "https://registry.npmjs.org/parse5-sax-parser/-/parse5-sax-parser-8.0.0.tgz",
-      "integrity": "sha512-/dQ8UzHZwnrzs3EvDj6IkKrD/jIZyTlB+8XrHJvcjNgRdmWruNdN9i9RK/JtxakmlUdPwKubKPTCqvbTgzGhrw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "parse5": "^8.0.0"
-      },
-      "funding": {
-        "url": "https://github.com/inikulin/parse5?sponsor=1"
-      }
-    },
-    "node_modules/parse5/node_modules/entities": {
-      "version": "8.0.0",
-      "resolved": "https://registry.npmjs.org/entities/-/entities-8.0.0.tgz",
-      "integrity": "sha512-zwfzJecQ/Uej6tusMqwAqU/6KL2XaB2VZ2Jg54Je6ahNBGNH6Ek6g3jjNCF0fG9EWQKGZNddNjU5F1ZQn/sBnA==",
-      "license": "BSD-2-Clause",
-      "engines": {
-        "node": ">=20.19.0"
-      },
-      "funding": {
-        "url": "https://github.com/fb55/entities?sponsor=1"
-      }
-    },
-    "node_modules/parseurl": {
-      "version": "1.3.3",
-      "resolved": "https://registry.npmjs.org/parseurl/-/parseurl-1.3.3.tgz",
-      "integrity": "sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.8"
-      }
-    },
-    "node_modules/path-key": {
-      "version": "3.1.1",
-      "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz",
-      "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/path-scurry": {
-      "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/path-scurry/-/path-scurry-2.0.2.tgz",
-      "integrity": "sha512-3O/iVVsJAPsOnpwWIeD+d6z/7PmqApyQePUtCndjatj/9I5LylHvt5qluFaBT3I5h3r1ejfR056c+FCv+NnNXg==",
-      "dev": true,
-      "license": "BlueOak-1.0.0",
-      "dependencies": {
-        "lru-cache": "^11.0.0",
-        "minipass": "^7.1.2"
-      },
-      "engines": {
-        "node": "18 || 20 || >=22"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/isaacs"
-      }
-    },
-    "node_modules/path-scurry/node_modules/lru-cache": {
-      "version": "11.5.1",
-      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-11.5.1.tgz",
-      "integrity": "sha512-RPimw/7aMdv2oqRrxKwvZXcPfwBrn/JZ2xYcY9Hus/6LaS3VOAKVWKWgNLCFSiOm1ESXinjsDlidVU7JlnCN2A==",
-      "dev": true,
-      "license": "BlueOak-1.0.0",
-      "engines": {
-        "node": "20 || >=22"
-      }
-    },
-    "node_modules/path-to-regexp": {
-      "version": "8.4.2",
-      "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-8.4.2.tgz",
-      "integrity": "sha512-qRcuIdP69NPm4qbACK+aDogI5CBDMi1jKe0ry5rSQJz8JVLsC7jV8XpiJjGRLLol3N+R5ihGYcrPLTno6pAdBA==",
-      "dev": true,
-      "license": "MIT",
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/express"
-      }
-    },
-    "node_modules/picocolors": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
-      "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==",
-      "dev": true,
-      "license": "ISC"
-    },
-    "node_modules/picomatch": {
-      "version": "4.0.4",
-      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.4.tgz",
-      "integrity": "sha512-QP88BAKvMam/3NxH6vj2o21R6MjxZUAd6nlwAS/pnGvN9IVLocLHxGYIzFhg6fUQ+5th6P4dv4eW9jX3DSIj7A==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/jonschlinkert"
-      }
-    },
-    "node_modules/piscina": {
-      "version": "5.1.4",
-      "resolved": "https://registry.npmjs.org/piscina/-/piscina-5.1.4.tgz",
-      "integrity": "sha512-7uU4ZnKeQq22t9AsmHGD2w4OYQGonwFnTypDypaWi7Qr2EvQIFVtG8J5D/3bE7W123Wdc9+v4CZDu5hJXVCtBg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=20.x"
-      },
-      "optionalDependencies": {
-        "@napi-rs/nice": "^1.0.4"
-      }
-    },
-    "node_modules/pkce-challenge": {
-      "version": "5.0.1",
-      "resolved": "https://registry.npmjs.org/pkce-challenge/-/pkce-challenge-5.0.1.tgz",
-      "integrity": "sha512-wQ0b/W4Fr01qtpHlqSqspcj3EhBvimsdh0KlHhH8HRZnMsEa0ea2fTULOXOS9ccQr3om+GcGRk4e+isrZWV8qQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=16.20.0"
-      }
-    },
-    "node_modules/postcss": {
-      "version": "8.5.15",
-      "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.15.tgz",
-      "integrity": "sha512-FfR8sjd4em2T6fb3I2MwAJU7HWVMr9zba+enmQeeWFfCbm+UOC/0X4DS8XtpUTMwWMGbjKYP7xjfNekzyGmB3A==",
-      "dev": true,
-      "funding": [
-        {
-          "type": "opencollective",
-          "url": "https://opencollective.com/postcss/"
-        },
-        {
-          "type": "tidelift",
-          "url": "https://tidelift.com/funding/github/npm/postcss"
-        },
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/ai"
-        }
-      ],
-      "license": "MIT",
-      "dependencies": {
-        "nanoid": "^3.3.12",
-        "picocolors": "^1.1.1",
-        "source-map-js": "^1.2.1"
-      },
-      "engines": {
-        "node": "^10 || ^12 || >=14"
-      }
-    },
-    "node_modules/postcss-media-query-parser": {
-      "version": "0.2.3",
-      "resolved": "https://registry.npmjs.org/postcss-media-query-parser/-/postcss-media-query-parser-0.2.3.tgz",
-      "integrity": "sha512-3sOlxmbKcSHMjlUXQZKQ06jOswE7oVkXPxmZdoB1r5l0q6gTFTQSHxNxOrCccElbW7dxNytifNEo8qidX2Vsig==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/postcss-safe-parser": {
-      "version": "7.0.1",
-      "resolved": "https://registry.npmjs.org/postcss-safe-parser/-/postcss-safe-parser-7.0.1.tgz",
-      "integrity": "sha512-0AioNCJZ2DPYz5ABT6bddIqlhgwhpHZ/l65YAYo0BCIn0xiDpsnTHz0gnoTGk0OXZW0JRs+cDwL8u/teRdz+8A==",
-      "dev": true,
-      "funding": [
-        {
-          "type": "opencollective",
-          "url": "https://opencollective.com/postcss/"
-        },
-        {
-          "type": "tidelift",
-          "url": "https://tidelift.com/funding/github/npm/postcss-safe-parser"
-        },
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/ai"
-        }
-      ],
-      "license": "MIT",
-      "engines": {
-        "node": ">=18.0"
-      },
-      "peerDependencies": {
-        "postcss": "^8.4.31"
-      }
-    },
-    "node_modules/prettier": {
-      "version": "3.8.3",
-      "resolved": "https://registry.npmjs.org/prettier/-/prettier-3.8.3.tgz",
-      "integrity": "sha512-7igPTM53cGHMW8xWuVTydi2KO233VFiTNyF5hLJqpilHfmn8C8gPf+PS7dUT64YcXFbiMGZxS9pCSxL/Dxm/Jw==",
-      "dev": true,
-      "license": "MIT",
-      "bin": {
-        "prettier": "bin/prettier.cjs"
-      },
-      "engines": {
-        "node": ">=14"
-      },
-      "funding": {
-        "url": "https://github.com/prettier/prettier?sponsor=1"
-      }
-    },
-    "node_modules/proc-log": {
-      "version": "6.1.0",
-      "resolved": "https://registry.npmjs.org/proc-log/-/proc-log-6.1.0.tgz",
-      "integrity": "sha512-iG+GYldRf2BQ0UDUAd6JQ/RwzaQy6mXmsk/IzlYyal4A4SNFw54MeH4/tLkF4I5WoWG9SQwuqWzS99jaFQHBuQ==",
-      "dev": true,
-      "license": "ISC",
-      "engines": {
-        "node": "^20.17.0 || >=22.9.0"
-      }
-    },
-    "node_modules/promise-retry": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/promise-retry/-/promise-retry-2.0.1.tgz",
-      "integrity": "sha512-y+WKFlBR8BGXnsNlIHFGPZmyDf3DFMoLhaflAnyZgV6rG6xu+JwesTo2Q9R6XwYmtmwAFCkAk3e35jEdoeh/3g==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "err-code": "^2.0.2",
-        "retry": "^0.12.0"
-      },
-      "engines": {
-        "node": ">=10"
-      }
-    },
-    "node_modules/proxy-addr": {
-      "version": "2.0.7",
-      "resolved": "https://registry.npmjs.org/proxy-addr/-/proxy-addr-2.0.7.tgz",
-      "integrity": "sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "forwarded": "0.2.0",
-        "ipaddr.js": "1.9.1"
-      },
-      "engines": {
-        "node": ">= 0.10"
-      }
-    },
-    "node_modules/qs": {
-      "version": "6.15.2",
-      "resolved": "https://registry.npmjs.org/qs/-/qs-6.15.2.tgz",
-      "integrity": "sha512-Rzq0KEyX/w/tEybncDgdkZrJgVUsUMk3xjh3t5bv3S1HTAtg+uOYt72+ZfwiQwKdysThkTBdL/rTi6HDmX9Ddw==",
-      "dev": true,
-      "license": "BSD-3-Clause",
-      "dependencies": {
-        "side-channel": "^1.1.0"
-      },
-      "engines": {
-        "node": ">=0.6"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/range-parser": {
-      "version": "1.2.1",
-      "resolved": "https://registry.npmjs.org/range-parser/-/range-parser-1.2.1.tgz",
-      "integrity": "sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.6"
-      }
-    },
-    "node_modules/raw-body": {
-      "version": "3.0.2",
-      "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-3.0.2.tgz",
-      "integrity": "sha512-K5zQjDllxWkf7Z5xJdV0/B0WTNqx6vxG70zJE4N0kBs4LovmEYWJzQGxC9bS9RAKu3bgM40lrd5zoLJ12MQ5BA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "bytes": "~3.1.2",
-        "http-errors": "~2.0.1",
-        "iconv-lite": "~0.7.0",
-        "unpipe": "~1.0.0"
-      },
-      "engines": {
-        "node": ">= 0.10"
-      }
-    },
-    "node_modules/readdirp": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-5.0.0.tgz",
-      "integrity": "sha512-9u/XQ1pvrQtYyMpZe7DXKv2p5CNvyVwzUB6uhLAnQwHMSgKMBR62lc7AHljaeteeHXn11XTAaLLUVZYVZyuRBQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 20.19.0"
-      },
-      "funding": {
-        "type": "individual",
-        "url": "https://paulmillr.com/funding/"
-      }
-    },
-    "node_modules/reflect-metadata": {
-      "version": "0.2.2",
-      "resolved": "https://registry.npmjs.org/reflect-metadata/-/reflect-metadata-0.2.2.tgz",
-      "integrity": "sha512-urBwgfrvVP/eAyXx4hluJivBKzuEbSQs9rKWCrCkbSxNv8mxPcUZKeuoF3Uy4mJl3Lwprp6yy5/39VWigZ4K6Q==",
-      "dev": true,
-      "license": "Apache-2.0"
-    },
-    "node_modules/require-from-string": {
-      "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/require-from-string/-/require-from-string-2.0.2.tgz",
-      "integrity": "sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/restore-cursor": {
-      "version": "5.1.0",
-      "resolved": "https://registry.npmjs.org/restore-cursor/-/restore-cursor-5.1.0.tgz",
-      "integrity": "sha512-oMA2dcrw6u0YfxJQXm342bFKX/E4sG9rbTzO9ptUcR/e8A33cHuvStiYOwH7fszkZlZ1z/ta9AAoPk2F4qIOHA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "onetime": "^7.0.0",
-        "signal-exit": "^4.1.0"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/retry": {
-      "version": "0.12.0",
-      "resolved": "https://registry.npmjs.org/retry/-/retry-0.12.0.tgz",
-      "integrity": "sha512-9LkiTwjUh6rT555DtE9rTX+BKByPfrMzEAtnlEtdEwr3Nkffwiihqe2bWADg+OQRjt9gl6ICdmB/ZFDCGAtSow==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 4"
-      }
-    },
-    "node_modules/rfdc": {
-      "version": "1.4.1",
-      "resolved": "https://registry.npmjs.org/rfdc/-/rfdc-1.4.1.tgz",
-      "integrity": "sha512-q1b3N5QkRUWUl7iyylaaj3kOpIT0N2i9MqIEQXP73GVsN9cw3fdx8X63cEmWhJGi2PPCF23Ijp7ktmd39rawIA==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/rolldown": {
-      "version": "1.0.0-rc.4",
-      "resolved": "https://registry.npmjs.org/rolldown/-/rolldown-1.0.0-rc.4.tgz",
-      "integrity": "sha512-V2tPDUrY3WSevrvU2E41ijZlpF+5PbZu4giH+VpNraaadsJGHa4fR6IFwsocVwEXDoAdIv5qgPPxgrvKAOIPtA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@oxc-project/types": "=0.113.0",
-        "@rolldown/pluginutils": "1.0.0-rc.4"
-      },
-      "bin": {
-        "rolldown": "bin/cli.mjs"
-      },
-      "engines": {
-        "node": "^20.19.0 || >=22.12.0"
-      },
-      "optionalDependencies": {
-        "@rolldown/binding-android-arm64": "1.0.0-rc.4",
-        "@rolldown/binding-darwin-arm64": "1.0.0-rc.4",
-        "@rolldown/binding-darwin-x64": "1.0.0-rc.4",
-        "@rolldown/binding-freebsd-x64": "1.0.0-rc.4",
-        "@rolldown/binding-linux-arm-gnueabihf": "1.0.0-rc.4",
-        "@rolldown/binding-linux-arm64-gnu": "1.0.0-rc.4",
-        "@rolldown/binding-linux-arm64-musl": "1.0.0-rc.4",
-        "@rolldown/binding-linux-x64-gnu": "1.0.0-rc.4",
-        "@rolldown/binding-linux-x64-musl": "1.0.0-rc.4",
-        "@rolldown/binding-openharmony-arm64": "1.0.0-rc.4",
-        "@rolldown/binding-wasm32-wasi": "1.0.0-rc.4",
-        "@rolldown/binding-win32-arm64-msvc": "1.0.0-rc.4",
-        "@rolldown/binding-win32-x64-msvc": "1.0.0-rc.4"
-      }
-    },
-    "node_modules/rollup": {
-      "version": "4.60.4",
-      "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.60.4.tgz",
-      "integrity": "sha512-WHeFSbZYsPu3+bLoNRUuAO+wavNlocOPf3wSHTP7hcFKVnJeWsYlCDbr3mTS14FCizf9ccIxXA8sGL8zKeQN3g==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@types/estree": "1.0.8"
-      },
-      "bin": {
-        "rollup": "dist/bin/rollup"
-      },
-      "engines": {
-        "node": ">=18.0.0",
-        "npm": ">=8.0.0"
-      },
-      "optionalDependencies": {
-        "@rollup/rollup-android-arm-eabi": "4.60.4",
-        "@rollup/rollup-android-arm64": "4.60.4",
-        "@rollup/rollup-darwin-arm64": "4.60.4",
-        "@rollup/rollup-darwin-x64": "4.60.4",
-        "@rollup/rollup-freebsd-arm64": "4.60.4",
-        "@rollup/rollup-freebsd-x64": "4.60.4",
-        "@rollup/rollup-linux-arm-gnueabihf": "4.60.4",
-        "@rollup/rollup-linux-arm-musleabihf": "4.60.4",
-        "@rollup/rollup-linux-arm64-gnu": "4.60.4",
-        "@rollup/rollup-linux-arm64-musl": "4.60.4",
-        "@rollup/rollup-linux-loong64-gnu": "4.60.4",
-        "@rollup/rollup-linux-loong64-musl": "4.60.4",
-        "@rollup/rollup-linux-ppc64-gnu": "4.60.4",
-        "@rollup/rollup-linux-ppc64-musl": "4.60.4",
-        "@rollup/rollup-linux-riscv64-gnu": "4.60.4",
-        "@rollup/rollup-linux-riscv64-musl": "4.60.4",
-        "@rollup/rollup-linux-s390x-gnu": "4.60.4",
-        "@rollup/rollup-linux-x64-gnu": "4.60.4",
-        "@rollup/rollup-linux-x64-musl": "4.60.4",
-        "@rollup/rollup-openbsd-x64": "4.60.4",
-        "@rollup/rollup-openharmony-arm64": "4.60.4",
-        "@rollup/rollup-win32-arm64-msvc": "4.60.4",
-        "@rollup/rollup-win32-ia32-msvc": "4.60.4",
-        "@rollup/rollup-win32-x64-gnu": "4.60.4",
-        "@rollup/rollup-win32-x64-msvc": "4.60.4",
-        "fsevents": "~2.3.2"
-      }
-    },
-    "node_modules/router": {
-      "version": "2.2.0",
-      "resolved": "https://registry.npmjs.org/router/-/router-2.2.0.tgz",
-      "integrity": "sha512-nLTrUKm2UyiL7rlhapu/Zl45FwNgkZGaCpZbIHajDYgwlJCOzLSk+cIPAnsEqV955GjILJnKbdQC1nVPz+gAYQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "debug": "^4.4.0",
-        "depd": "^2.0.0",
-        "is-promise": "^4.0.0",
-        "parseurl": "^1.3.3",
-        "path-to-regexp": "^8.0.0"
-      },
-      "engines": {
-        "node": ">= 18"
-      }
-    },
-    "node_modules/rxjs": {
-      "version": "7.8.2",
-      "resolved": "https://registry.npmjs.org/rxjs/-/rxjs-7.8.2.tgz",
-      "integrity": "sha512-dhKf903U/PQZY6boNNtAGdWbG85WAbjT/1xYoZIC7FAY0yWapOBQVsVrDl58W86//e1VpMNBtRV4MaXfdMySFA==",
-      "license": "Apache-2.0",
-      "dependencies": {
-        "tslib": "^2.1.0"
-      }
-    },
-    "node_modules/safer-buffer": {
-      "version": "2.1.2",
-      "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz",
-      "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/sass": {
-      "version": "1.97.3",
-      "resolved": "https://registry.npmjs.org/sass/-/sass-1.97.3.tgz",
-      "integrity": "sha512-fDz1zJpd5GycprAbu4Q2PV/RprsRtKC/0z82z0JLgdytmcq0+ujJbJ/09bPGDxCLkKY3Np5cRAOcWiVkLXJURg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "chokidar": "^4.0.0",
-        "immutable": "^5.0.2",
-        "source-map-js": ">=0.6.2 <2.0.0"
-      },
-      "bin": {
-        "sass": "sass.js"
-      },
-      "engines": {
-        "node": ">=14.0.0"
-      },
-      "optionalDependencies": {
-        "@parcel/watcher": "^2.4.1"
-      }
-    },
-    "node_modules/sass/node_modules/chokidar": {
-      "version": "4.0.3",
-      "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-4.0.3.tgz",
-      "integrity": "sha512-Qgzu8kfBvo+cA4962jnP1KkS6Dop5NS6g7R5LFYJr4b8Ub94PPQXUksCw9PvXoeXPRRddRNC5C1JQUR2SMGtnA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "readdirp": "^4.0.1"
-      },
-      "engines": {
-        "node": ">= 14.16.0"
-      },
-      "funding": {
-        "url": "https://paulmillr.com/funding/"
-      }
-    },
-    "node_modules/sass/node_modules/readdirp": {
-      "version": "4.1.2",
-      "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-4.1.2.tgz",
-      "integrity": "sha512-GDhwkLfywWL2s6vEjyhri+eXmfH6j1L7JE27WhqLeYzoh/A3DBaYGEj2H/HFZCn/kMfim73FXxEJTw06WtxQwg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 14.18.0"
-      },
-      "funding": {
-        "type": "individual",
-        "url": "https://paulmillr.com/funding/"
-      }
-    },
-    "node_modules/semver": {
-      "version": "7.7.4",
-      "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.4.tgz",
-      "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==",
-      "dev": true,
-      "license": "ISC",
-      "bin": {
-        "semver": "bin/semver.js"
-      },
-      "engines": {
-        "node": ">=10"
-      }
-    },
-    "node_modules/send": {
-      "version": "1.2.1",
-      "resolved": "https://registry.npmjs.org/send/-/send-1.2.1.tgz",
-      "integrity": "sha512-1gnZf7DFcoIcajTjTwjwuDjzuz4PPcY2StKPlsGAQ1+YH20IRVrBaXSWmdjowTJ6u8Rc01PoYOGHXfP1mYcZNQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "debug": "^4.4.3",
-        "encodeurl": "^2.0.0",
-        "escape-html": "^1.0.3",
-        "etag": "^1.8.1",
-        "fresh": "^2.0.0",
-        "http-errors": "^2.0.1",
-        "mime-types": "^3.0.2",
-        "ms": "^2.1.3",
-        "on-finished": "^2.4.1",
-        "range-parser": "^1.2.1",
-        "statuses": "^2.0.2"
-      },
-      "engines": {
-        "node": ">= 18"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/express"
-      }
-    },
-    "node_modules/serve-static": {
-      "version": "2.2.1",
-      "resolved": "https://registry.npmjs.org/serve-static/-/serve-static-2.2.1.tgz",
-      "integrity": "sha512-xRXBn0pPqQTVQiC8wyQrKs2MOlX24zQ0POGaj0kultvoOCstBQM5yvOhAVSUwOMjQtTvsPWoNCHfPGwaaQJhTw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "encodeurl": "^2.0.0",
-        "escape-html": "^1.0.3",
-        "parseurl": "^1.3.3",
-        "send": "^1.2.0"
-      },
-      "engines": {
-        "node": ">= 18"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/express"
-      }
-    },
-    "node_modules/setprototypeof": {
-      "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.2.0.tgz",
-      "integrity": "sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==",
-      "dev": true,
-      "license": "ISC"
-    },
-    "node_modules/shebang-command": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz",
-      "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "shebang-regex": "^3.0.0"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/shebang-regex": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz",
-      "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/side-channel": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.1.0.tgz",
-      "integrity": "sha512-ZX99e6tRweoUXqR+VBrslhda51Nh5MTQwou5tnUDgbtyM0dBgmhEDtWGP/xbKn6hqfPRHujUNwz5fy/wbbhnpw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "es-errors": "^1.3.0",
-        "object-inspect": "^1.13.3",
-        "side-channel-list": "^1.0.0",
-        "side-channel-map": "^1.0.1",
-        "side-channel-weakmap": "^1.0.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/side-channel-list": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/side-channel-list/-/side-channel-list-1.0.1.tgz",
-      "integrity": "sha512-mjn/0bi/oUURjc5Xl7IaWi/OJJJumuoJFQJfDDyO46+hBWsfaVM65TBHq2eoZBhzl9EchxOijpkbRC8SVBQU0w==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "es-errors": "^1.3.0",
-        "object-inspect": "^1.13.4"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/side-channel-map": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/side-channel-map/-/side-channel-map-1.0.1.tgz",
-      "integrity": "sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.2",
-        "es-errors": "^1.3.0",
-        "get-intrinsic": "^1.2.5",
-        "object-inspect": "^1.13.3"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/side-channel-weakmap": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/side-channel-weakmap/-/side-channel-weakmap-1.0.2.tgz",
-      "integrity": "sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.2",
-        "es-errors": "^1.3.0",
-        "get-intrinsic": "^1.2.5",
-        "object-inspect": "^1.13.3",
-        "side-channel-map": "^1.0.1"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/signal-exit": {
-      "version": "4.1.0",
-      "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-4.1.0.tgz",
-      "integrity": "sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==",
-      "dev": true,
-      "license": "ISC",
-      "engines": {
-        "node": ">=14"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/isaacs"
-      }
-    },
-    "node_modules/sigstore": {
-      "version": "4.1.1",
-      "resolved": "https://registry.npmjs.org/sigstore/-/sigstore-4.1.1.tgz",
-      "integrity": "sha512-endqECJkfhozrXMK5ngu/UAA0xVcVEFdnHJCElGaExypjW+HK5i6zu3NteLoaX/iFbRUbC3+DjttQs0GARr+5w==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@sigstore/bundle": "^4.0.0",
-        "@sigstore/core": "^3.2.1",
-        "@sigstore/protobuf-specs": "^0.5.0",
-        "@sigstore/sign": "^4.1.1",
-        "@sigstore/tuf": "^4.0.2",
-        "@sigstore/verify": "^3.1.1"
-      },
-      "engines": {
-        "node": "^20.17.0 || >=22.9.0"
-      }
-    },
-    "node_modules/slice-ansi": {
-      "version": "8.0.0",
-      "resolved": "https://registry.npmjs.org/slice-ansi/-/slice-ansi-8.0.0.tgz",
-      "integrity": "sha512-stxByr12oeeOyY2BlviTNQlYV5xOj47GirPr4yA1hE9JCtxfQN0+tVbkxwCtYDQWhEKWFHsEK48ORg5jrouCAg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ansi-styles": "^6.2.3",
-        "is-fullwidth-code-point": "^5.1.0"
-      },
-      "engines": {
-        "node": ">=20"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/slice-ansi?sponsor=1"
-      }
-    },
-    "node_modules/smart-buffer": {
-      "version": "4.2.0",
-      "resolved": "https://registry.npmjs.org/smart-buffer/-/smart-buffer-4.2.0.tgz",
-      "integrity": "sha512-94hK0Hh8rPqQl2xXc3HsaBoOXKV20MToPkcXvwbISWLEs+64sBq5kFgn2kJDHb1Pry9yrP0dxrCI9RRci7RXKg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 6.0.0",
-        "npm": ">= 3.0.0"
-      }
-    },
-    "node_modules/socks": {
-      "version": "2.8.9",
-      "resolved": "https://registry.npmjs.org/socks/-/socks-2.8.9.tgz",
-      "integrity": "sha512-LJhUYUvItdQ0LkJTmPeaEObWXAqFyfmP85x0tch/ez9cahmhlBBLbIqDFnvBnUJGagb0JbIQrkBs1wJ+yRYpEw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ip-address": "^10.1.1",
-        "smart-buffer": "^4.2.0"
-      },
-      "engines": {
-        "node": ">= 10.0.0",
-        "npm": ">= 3.0.0"
-      }
-    },
-    "node_modules/socks-proxy-agent": {
-      "version": "8.0.5",
-      "resolved": "https://registry.npmjs.org/socks-proxy-agent/-/socks-proxy-agent-8.0.5.tgz",
-      "integrity": "sha512-HehCEsotFqbPW9sJ8WVYB6UbmIMv7kUUORIF2Nncq4VQvBfNBLibW9YZR5dlYCSUhwcD628pRllm7n+E+YTzJw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "agent-base": "^7.1.2",
-        "debug": "^4.3.4",
-        "socks": "^2.8.3"
-      },
-      "engines": {
-        "node": ">= 14"
-      }
-    },
-    "node_modules/source-map": {
-      "version": "0.7.6",
-      "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.7.6.tgz",
-      "integrity": "sha512-i5uvt8C3ikiWeNZSVZNWcfZPItFQOsYTUAOkcUPGd8DqDy1uOUikjt5dG+uRlwyvR108Fb9DOd4GvXfT0N2/uQ==",
-      "dev": true,
-      "license": "BSD-3-Clause",
-      "engines": {
-        "node": ">= 12"
-      }
-    },
-    "node_modules/source-map-js": {
-      "version": "1.2.1",
-      "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz",
-      "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==",
-      "dev": true,
-      "license": "BSD-3-Clause",
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/source-map-support": {
-      "version": "0.5.21",
-      "resolved": "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.21.tgz",
-      "integrity": "sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "buffer-from": "^1.0.0",
-        "source-map": "^0.6.0"
-      }
-    },
-    "node_modules/source-map-support/node_modules/source-map": {
-      "version": "0.6.1",
-      "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz",
-      "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==",
-      "dev": true,
-      "license": "BSD-3-Clause",
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/spdx-exceptions": {
-      "version": "2.5.0",
-      "resolved": "https://registry.npmjs.org/spdx-exceptions/-/spdx-exceptions-2.5.0.tgz",
-      "integrity": "sha512-PiU42r+xO4UbUS1buo3LPJkjlO7430Xn5SVAhdpzzsPHsjbYVflnnFdATgabnLude+Cqu25p6N+g2lw/PFsa4w==",
-      "dev": true,
-      "license": "CC-BY-3.0"
-    },
-    "node_modules/spdx-expression-parse": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/spdx-expression-parse/-/spdx-expression-parse-4.0.0.tgz",
-      "integrity": "sha512-Clya5JIij/7C6bRR22+tnGXbc4VKlibKSVj2iHvVeX5iMW7s1SIQlqu699JkODJJIhh/pUu8L0/VLh8xflD+LQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "spdx-exceptions": "^2.1.0",
-        "spdx-license-ids": "^3.0.0"
-      }
-    },
-    "node_modules/spdx-license-ids": {
-      "version": "3.0.23",
-      "resolved": "https://registry.npmjs.org/spdx-license-ids/-/spdx-license-ids-3.0.23.tgz",
-      "integrity": "sha512-CWLcCCH7VLu13TgOH+r8p1O/Znwhqv/dbb6lqWy67G+pT1kHmeD/+V36AVb/vq8QMIQwVShJ6Ssl5FPh0fuSdw==",
-      "dev": true,
-      "license": "CC0-1.0"
-    },
-    "node_modules/ssri": {
-      "version": "13.0.1",
-      "resolved": "https://registry.npmjs.org/ssri/-/ssri-13.0.1.tgz",
-      "integrity": "sha512-QUiRf1+u9wPTL/76GTYlKttDEBWV1ga9ZXW8BG6kfdeyyM8LGPix9gROyg9V2+P0xNyF3X2Go526xKFdMZrHSQ==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "minipass": "^7.0.3"
-      },
-      "engines": {
-        "node": "^20.17.0 || >=22.9.0"
-      }
-    },
-    "node_modules/statuses": {
-      "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.2.tgz",
-      "integrity": "sha512-DvEy55V3DB7uknRo+4iOGT5fP1slR8wQohVdknigZPMpMstaKJQWhwiYBACJE3Ul2pTnATihhBYnRhZQHGBiRw==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.8"
-      }
-    },
-    "node_modules/stdin-discarder": {
-      "version": "0.3.2",
-      "resolved": "https://registry.npmjs.org/stdin-discarder/-/stdin-discarder-0.3.2.tgz",
-      "integrity": "sha512-eCPu1qRxPVkl5605OTWF8Wz40b4Mf45NY5LQmVPQ599knfs5QhASUm9GbJ5BDMDOXgrnh0wyEdvzmL//YMlw0A==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/string-width": {
-      "version": "8.2.1",
-      "resolved": "https://registry.npmjs.org/string-width/-/string-width-8.2.1.tgz",
-      "integrity": "sha512-IIaP0g3iy9Cyy18w3M9YcaDudujEAVHKt3a3QJg1+sr/oX96TbaGUubG0hJyCjCBThFH+tFpcIyoUHUn1ogaLA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "get-east-asian-width": "^1.5.0",
-        "strip-ansi": "^7.1.2"
-      },
-      "engines": {
-        "node": ">=20"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/strip-ansi": {
-      "version": "7.2.0",
-      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.2.0.tgz",
-      "integrity": "sha512-yDPMNjp4WyfYBkHnjIRLfca1i6KMyGCtsVgoKe/z1+6vukgaENdgGBZt+ZmKPc4gavvEZ5OgHfHdrazhgNyG7w==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ansi-regex": "^6.2.2"
-      },
-      "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/strip-ansi?sponsor=1"
-      }
-    },
-    "node_modules/tar": {
-      "version": "7.5.15",
-      "resolved": "https://registry.npmjs.org/tar/-/tar-7.5.15.tgz",
-      "integrity": "sha512-dzGK0boVlC4W5QFuQN1EFSl3bIDYsk7Tj40U6eIBnK2k/8ml7TZ5agbI5j5+qnoVcAA+rNtBml8SEiLxZpNqRQ==",
-      "dev": true,
-      "license": "BlueOak-1.0.0",
-      "dependencies": {
-        "@isaacs/fs-minipass": "^4.0.0",
-        "chownr": "^3.0.0",
-        "minipass": "^7.1.2",
-        "minizlib": "^3.1.0",
-        "yallist": "^5.0.0"
-      },
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/tar/node_modules/yallist": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/yallist/-/yallist-5.0.0.tgz",
-      "integrity": "sha512-YgvUTfwqyc7UXVMrB+SImsVYSmTS8X/tSrtdNZMImM+n7+QTriRXyXim0mBrTXNeqzVF0KWGgHPeiyViFFrNDw==",
-      "dev": true,
-      "license": "BlueOak-1.0.0",
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/three": {
-      "version": "0.184.0",
-      "resolved": "https://registry.npmjs.org/three/-/three-0.184.0.tgz",
-      "integrity": "sha512-wtTRjG92pM5eUg/KuUnHsqSAlPM296brTOcLgMRqEeylYTh/CdtvKUvCyyCQTzFuStieWxvZb8mVTMvdPyUpxg==",
-      "license": "MIT"
-    },
-    "node_modules/tinyglobby": {
-      "version": "0.2.15",
-      "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.15.tgz",
-      "integrity": "sha512-j2Zq4NyQYG5XMST4cbs02Ak8iJUdxRM0XI5QyxXuZOzKOINmWurp3smXu3y5wDcJrptwpSjgXHzIQxR0omXljQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "fdir": "^6.5.0",
-        "picomatch": "^4.0.3"
-      },
-      "engines": {
-        "node": ">=12.0.0"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/SuperchupuDev"
-      }
-    },
-    "node_modules/toidentifier": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/toidentifier/-/toidentifier-1.0.1.tgz",
-      "integrity": "sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.6"
-      }
-    },
-    "node_modules/tslib": {
-      "version": "2.8.1",
-      "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
-      "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
-      "license": "0BSD"
-    },
-    "node_modules/tuf-js": {
-      "version": "4.1.0",
-      "resolved": "https://registry.npmjs.org/tuf-js/-/tuf-js-4.1.0.tgz",
-      "integrity": "sha512-50QV99kCKH5P/Vs4E2Gzp7BopNV+KzTXqWeaxrfu5IQJBOULRsTIS9seSsOVT8ZnGXzCyx55nYWAi4qJzpZKEQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@tufjs/models": "4.1.0",
-        "debug": "^4.4.3",
-        "make-fetch-happen": "^15.0.1"
-      },
-      "engines": {
-        "node": "^20.17.0 || >=22.9.0"
-      }
-    },
-    "node_modules/type-is": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/type-is/-/type-is-2.1.0.tgz",
-      "integrity": "sha512-faYHw0anBbc/kWF3zFTEnxSFOAGUX9GFbOBthvDdLsIlEoWOFOtS0zgCiQYwIskL9iGXZL3kAXD8OoZ4GmMATA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "content-type": "^2.0.0",
-        "media-typer": "^1.1.0",
-        "mime-types": "^3.0.0"
-      },
-      "engines": {
-        "node": ">= 18"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/express"
-      }
-    },
-    "node_modules/type-is/node_modules/content-type": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/content-type/-/content-type-2.0.0.tgz",
-      "integrity": "sha512-j/O/d7GcZCyNl7/hwZAb606rzqkyvaDctLmckbxLzHvFBzTJHuGEdodATcP3yIRoDrLHkIATJuvzbFlp/ki2cQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/express"
-      }
-    },
-    "node_modules/typescript": {
-      "version": "5.9.3",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz",
-      "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "bin": {
-        "tsc": "bin/tsc",
-        "tsserver": "bin/tsserver"
-      },
-      "engines": {
-        "node": ">=14.17"
-      }
-    },
-    "node_modules/undici": {
-      "version": "7.24.4",
-      "resolved": "https://registry.npmjs.org/undici/-/undici-7.24.4.tgz",
-      "integrity": "sha512-BM/JzwwaRXxrLdElV2Uo6cTLEjhSb3WXboncJamZ15NgUURmvlXvxa6xkwIOILIjPNo9i8ku136ZvWV0Uly8+w==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=20.18.1"
-      }
-    },
-    "node_modules/unpipe": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/unpipe/-/unpipe-1.0.0.tgz",
-      "integrity": "sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.8"
-      }
-    },
-    "node_modules/update-browserslist-db": {
-      "version": "1.2.3",
-      "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.2.3.tgz",
-      "integrity": "sha512-Js0m9cx+qOgDxo0eMiFGEueWztz+d4+M3rGlmKPT+T4IS/jP4ylw3Nwpu6cpTTP8R1MAC1kF4VbdLt3ARf209w==",
-      "dev": true,
-      "funding": [
-        {
-          "type": "opencollective",
-          "url": "https://opencollective.com/browserslist"
-        },
-        {
-          "type": "tidelift",
-          "url": "https://tidelift.com/funding/github/npm/browserslist"
-        },
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/ai"
-        }
-      ],
-      "license": "MIT",
-      "dependencies": {
-        "escalade": "^3.2.0",
-        "picocolors": "^1.1.1"
-      },
-      "bin": {
-        "update-browserslist-db": "cli.js"
-      },
-      "peerDependencies": {
-        "browserslist": ">= 4.21.0"
-      }
-    },
-    "node_modules/validate-npm-package-name": {
-      "version": "7.0.2",
-      "resolved": "https://registry.npmjs.org/validate-npm-package-name/-/validate-npm-package-name-7.0.2.tgz",
-      "integrity": "sha512-hVDIBwsRruT73PbK7uP5ebUt+ezEtCmzZz3F59BSr2F6OVFnJ/6h8liuvdLrQ88Xmnk6/+xGGuq+pG9WwTuy3A==",
-      "dev": true,
-      "license": "ISC",
-      "engines": {
-        "node": "^20.17.0 || >=22.9.0"
-      }
-    },
-    "node_modules/vary": {
-      "version": "1.1.2",
-      "resolved": "https://registry.npmjs.org/vary/-/vary-1.1.2.tgz",
-      "integrity": "sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.8"
-      }
-    },
-    "node_modules/vite": {
-      "version": "7.3.2",
-      "resolved": "https://registry.npmjs.org/vite/-/vite-7.3.2.tgz",
-      "integrity": "sha512-Bby3NOsna2jsjfLVOHKes8sGwgl4TT0E6vvpYgnAYDIF/tie7MRaFthmKuHx1NSXjiTueXH3do80FMQgvEktRg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "esbuild": "^0.27.0",
-        "fdir": "^6.5.0",
-        "picomatch": "^4.0.3",
-        "postcss": "^8.5.6",
-        "rollup": "^4.43.0",
-        "tinyglobby": "^0.2.15"
-      },
-      "bin": {
-        "vite": "bin/vite.js"
-      },
-      "engines": {
-        "node": "^20.19.0 || >=22.12.0"
-      },
-      "funding": {
-        "url": "https://github.com/vitejs/vite?sponsor=1"
-      },
-      "optionalDependencies": {
-        "fsevents": "~2.3.3"
-      },
-      "peerDependencies": {
-        "@types/node": "^20.19.0 || >=22.12.0",
-        "jiti": ">=1.21.0",
-        "less": "^4.0.0",
-        "lightningcss": "^1.21.0",
-        "sass": "^1.70.0",
-        "sass-embedded": "^1.70.0",
-        "stylus": ">=0.54.8",
-        "sugarss": "^5.0.0",
-        "terser": "^5.16.0",
-        "tsx": "^4.8.1",
-        "yaml": "^2.4.2"
-      },
-      "peerDependenciesMeta": {
-        "@types/node": {
-          "optional": true
-        },
-        "jiti": {
-          "optional": true
-        },
-        "less": {
-          "optional": true
-        },
-        "lightningcss": {
-          "optional": true
-        },
-        "sass": {
-          "optional": true
-        },
-        "sass-embedded": {
-          "optional": true
-        },
-        "stylus": {
-          "optional": true
-        },
-        "sugarss": {
-          "optional": true
-        },
-        "terser": {
-          "optional": true
-        },
-        "tsx": {
-          "optional": true
-        },
-        "yaml": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/watchpack": {
-      "version": "2.5.1",
-      "resolved": "https://registry.npmjs.org/watchpack/-/watchpack-2.5.1.tgz",
-      "integrity": "sha512-Zn5uXdcFNIA1+1Ei5McRd+iRzfhENPCe7LeABkJtNulSxjma+l7ltNx55BWZkRlwRnpOgHqxnjyaDgJnNXnqzg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "glob-to-regexp": "^0.4.1",
-        "graceful-fs": "^4.1.2"
-      },
-      "engines": {
-        "node": ">=10.13.0"
-      }
-    },
-    "node_modules/weak-lru-cache": {
-      "version": "1.2.2",
-      "resolved": "https://registry.npmjs.org/weak-lru-cache/-/weak-lru-cache-1.2.2.tgz",
-      "integrity": "sha512-DEAoo25RfSYMuTGc9vPJzZcZullwIqRDSI9LOy+fkCJPi6hykCnfKaXTuPBDuXAUcqHXyOgFtHNp/kB2FjYHbw==",
-      "dev": true,
-      "license": "MIT",
-      "optional": true
-    },
-    "node_modules/which": {
-      "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
-      "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "isexe": "^2.0.0"
-      },
-      "bin": {
-        "node-which": "bin/node-which"
-      },
-      "engines": {
-        "node": ">= 8"
-      }
-    },
-    "node_modules/wrap-ansi": {
-      "version": "6.2.0",
-      "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-6.2.0.tgz",
-      "integrity": "sha512-r6lPcBGxZXlIcymEu7InxDMhdW0KDxpLgoFLcguasxCaJ/SOIZwINatK9KY/tf+ZrlywOKU0UDj3ATXUBfxJXA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ansi-styles": "^4.0.0",
-        "string-width": "^4.1.0",
-        "strip-ansi": "^6.0.0"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/wrap-ansi/node_modules/ansi-regex": {
-      "version": "5.0.1",
-      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
-      "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/wrap-ansi/node_modules/ansi-styles": {
-      "version": "4.3.0",
-      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
-      "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "color-convert": "^2.0.1"
-      },
-      "engines": {
-        "node": ">=8"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
-      }
-    },
-    "node_modules/wrap-ansi/node_modules/emoji-regex": {
-      "version": "8.0.0",
-      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
-      "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/wrap-ansi/node_modules/is-fullwidth-code-point": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",
-      "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/wrap-ansi/node_modules/string-width": {
-      "version": "4.2.3",
-      "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
-      "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "emoji-regex": "^8.0.0",
-        "is-fullwidth-code-point": "^3.0.0",
-        "strip-ansi": "^6.0.1"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/wrap-ansi/node_modules/strip-ansi": {
-      "version": "6.0.1",
-      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
-      "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ansi-regex": "^5.0.1"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/wrappy": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
-      "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==",
-      "dev": true,
-      "license": "ISC"
-    },
-    "node_modules/y18n": {
-      "version": "5.0.8",
-      "resolved": "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz",
-      "integrity": "sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==",
-      "dev": true,
-      "license": "ISC",
-      "engines": {
-        "node": ">=10"
-      }
-    },
-    "node_modules/yallist": {
-      "version": "3.1.1",
-      "resolved": "https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz",
-      "integrity": "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==",
-      "dev": true,
-      "license": "ISC"
-    },
-    "node_modules/yargs": {
-      "version": "18.0.0",
-      "resolved": "https://registry.npmjs.org/yargs/-/yargs-18.0.0.tgz",
-      "integrity": "sha512-4UEqdc2RYGHZc7Doyqkrqiln3p9X2DZVxaGbwhn2pi7MrRagKaOcIKe8L3OxYcbhXLgLFUS3zAYuQjKBQgmuNg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "cliui": "^9.0.1",
-        "escalade": "^3.1.1",
-        "get-caller-file": "^2.0.5",
-        "string-width": "^7.2.0",
-        "y18n": "^5.0.5",
-        "yargs-parser": "^22.0.0"
-      },
-      "engines": {
-        "node": "^20.19.0 || ^22.12.0 || >=23"
-      }
-    },
-    "node_modules/yargs-parser": {
-      "version": "22.0.0",
-      "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-22.0.0.tgz",
-      "integrity": "sha512-rwu/ClNdSMpkSrUb+d6BRsSkLUq1fmfsY6TOpYzTwvwkg1/NRG85KBy3kq++A8LKQwX6lsu+aWad+2khvuXrqw==",
-      "dev": true,
-      "license": "ISC",
-      "engines": {
-        "node": "^20.19.0 || ^22.12.0 || >=23"
-      }
-    },
-    "node_modules/yargs/node_modules/string-width": {
-      "version": "7.2.0",
-      "resolved": "https://registry.npmjs.org/string-width/-/string-width-7.2.0.tgz",
-      "integrity": "sha512-tsaTIkKW9b4N+AEj+SVA+WhJzV7/zMhcSu78mLKWSk7cXMOSHsBKFWUs0fWwq8QyK3MgJBQRX6Gbi4kYbdvGkQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "emoji-regex": "^10.3.0",
-        "get-east-asian-width": "^1.0.0",
-        "strip-ansi": "^7.1.0"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/yoctocolors": {
-      "version": "2.1.2",
-      "resolved": "https://registry.npmjs.org/yoctocolors/-/yoctocolors-2.1.2.tgz",
-      "integrity": "sha512-CzhO+pFNo8ajLM2d2IW/R93ipy99LWjtwblvC1RsoSUMZgyLbYFr221TnSNT7GjGdYui6P459mw9JH/g/zW2ug==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/yoctocolors-cjs": {
-      "version": "2.1.3",
-      "resolved": "https://registry.npmjs.org/yoctocolors-cjs/-/yoctocolors-cjs-2.1.3.tgz",
-      "integrity": "sha512-U/PBtDf35ff0D8X8D0jfdzHYEPFxAI7jJlxZXwCSez5M3190m+QobIfh+sWDWSHMCWWJN2AWamkegn6vr6YBTw==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/zod": {
-      "version": "4.3.6",
-      "resolved": "https://registry.npmjs.org/zod/-/zod-4.3.6.tgz",
-      "integrity": "sha512-rftlrkhHZOcjDwkGlnUtZZkvaPHCsDATp4pGpuOOMDaTdDDXF91wuVDJoWoPsKX/3YPQ5fHuF3STjcYyKr+Qhg==",
-      "dev": true,
-      "license": "MIT",
-      "funding": {
-        "url": "https://github.com/sponsors/colinhacks"
-      }
-    },
-    "node_modules/zod-to-json-schema": {
-      "version": "3.25.2",
-      "resolved": "https://registry.npmjs.org/zod-to-json-schema/-/zod-to-json-schema-3.25.2.tgz",
-      "integrity": "sha512-O/PgfnpT1xKSDeQYSCfRI5Gy3hPf91mKVDuYLUHZJMiDFptvP41MSnWofm8dnCm0256ZNfZIM7DSzuSMAFnjHA==",
-      "dev": true,
-      "license": "ISC",
-      "peerDependencies": {
-        "zod": "^3.25.28 || ^4"
-      }
-    },
-    "node_modules/zrender": {
-      "version": "6.1.0",
-      "resolved": "https://registry.npmjs.org/zrender/-/zrender-6.1.0.tgz",
-      "integrity": "sha512-oEGMDB6pOP2S6OwRR4PdVv610zrjnA3Bh+JnSG12fYJlBKjtNAoEb5fSUoCOOINlH96I2fU38/A2UpRKs67xYQ==",
-      "license": "BSD-3-Clause",
-      "dependencies": {
-        "tslib": "2.3.0"
-      }
-    },
-    "node_modules/zrender/node_modules/tslib": {
-      "version": "2.3.0",
-      "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.3.0.tgz",
-      "integrity": "sha512-N82ooyxVNm6h1riLCoyS9e3fuJ3AMG2zIZs2Gd1ATcSFjSA23Q0fzjjZeh0jbJvWVDZ0cJT8yaNNaaXHzueNjg==",
-      "license": "0BSD"
-    }
-  }
-}
diff --git a/spector-cortex/package.json b/spector-cortex/package.json
deleted file mode 100644
index 68ebbfe..0000000
--- a/spector-cortex/package.json
+++ /dev/null
@@ -1,38 +0,0 @@
-{
-  "name": "spector-cortex",
-  "version": "0.0.0",
-  "scripts": {
-    "ng": "ng",
-    "start": "ng serve",
-    "build": "ng build",
-    "watch": "ng build --watch --configuration development",
-    "test": "ng test"
-  },
-  "private": true,
-  "packageManager": "npm@10.9.3",
-  "dependencies": {
-    "@angular/animations": "^21.2.15",
-    "@angular/cdk": "^21.2.13",
-    "@angular/common": "^21.2.0",
-    "@angular/compiler": "^21.2.0",
-    "@angular/core": "^21.2.0",
-    "@angular/forms": "^21.2.0",
-    "@angular/material": "^21.2.13",
-    "@angular/platform-browser": "^21.2.0",
-    "@angular/router": "^21.2.0",
-    "@spectrayan/ng-sse-client": "^2.0.0",
-    "echarts": "^6.1.0",
-    "ngx-echarts": "^21.0.0",
-    "rxjs": "~7.8.0",
-    "three": "^0.184.0",
-    "tslib": "^2.3.0"
-  },
-  "devDependencies": {
-    "@angular/build": "^21.2.13",
-    "@angular/cli": "^21.2.13",
-    "@angular/compiler-cli": "^21.2.0",
-    "@types/three": "^0.184.1",
-    "prettier": "^3.8.1",
-    "typescript": "~5.9.2"
-  }
-}
diff --git a/spector-cortex/public/favicon.ico b/spector-cortex/public/favicon.ico
deleted file mode 100644
index 57614f9..0000000
Binary files a/spector-cortex/public/favicon.ico and /dev/null differ
diff --git a/spector-cortex/src/app/app.config.ts b/spector-cortex/src/app/app.config.ts
deleted file mode 100644
index c7b84d8..0000000
--- a/spector-cortex/src/app/app.config.ts
+++ /dev/null
@@ -1,28 +0,0 @@
-import {
-  ApplicationConfig,
-  provideBrowserGlobalErrorListeners,
-  provideZonelessChangeDetection,
-  provideAppInitializer,
-  inject,
-} from '@angular/core';
-import { provideRouter, withViewTransitions } from '@angular/router';
-import { provideAnimationsAsync } from '@angular/platform-browser/animations/async';
-import { provideHttpClient, withFetch } from '@angular/common/http';
-
-import { routes } from './app.routes';
-import { ThemeService } from './core/services/theme.service';
-
-export const appConfig: ApplicationConfig = {
-  providers: [
-    provideZonelessChangeDetection(),
-    provideBrowserGlobalErrorListeners(),
-    provideRouter(routes, withViewTransitions()),
-    provideAnimationsAsync(),
-    provideHttpClient(withFetch()),
-
-    // Initialize theme on startup
-    provideAppInitializer(() => {
-      inject(ThemeService);
-    }),
-  ],
-};
diff --git a/spector-cortex/src/app/app.html b/spector-cortex/src/app/app.html
deleted file mode 100644
index 67e7bd4..0000000
--- a/spector-cortex/src/app/app.html
+++ /dev/null
@@ -1 +0,0 @@
-<router-outlet />
diff --git a/spector-cortex/src/app/app.routes.ts b/spector-cortex/src/app/app.routes.ts
deleted file mode 100644
index d78eede..0000000
--- a/spector-cortex/src/app/app.routes.ts
+++ /dev/null
@@ -1,13 +0,0 @@
-import { Route } from '@angular/router';
-
-export const routes: Route[] = [
-  {
-    path: '',
-    loadComponent: () =>
-      import('./features/dashboard/dashboard.component').then(m => m.DashboardComponent),
-  },
-  {
-    path: '**',
-    redirectTo: '',
-  },
-];
diff --git a/spector-cortex/src/app/app.scss b/spector-cortex/src/app/app.scss
deleted file mode 100644
index 68bf19d..0000000
--- a/spector-cortex/src/app/app.scss
+++ /dev/null
@@ -1,5 +0,0 @@
-:host {
-  display: block;
-  height: 100%;
-  width: 100%;
-}
diff --git a/spector-cortex/src/app/app.ts b/spector-cortex/src/app/app.ts
deleted file mode 100644
index 3e7c0e1..0000000
--- a/spector-cortex/src/app/app.ts
+++ /dev/null
@@ -1,10 +0,0 @@
-import { Component } from '@angular/core';
-import { RouterOutlet } from '@angular/router';
-
-@Component({
-  selector: 'cortex-root',
-  imports: [RouterOutlet],
-  templateUrl: './app.html',
-  styleUrl: './app.scss',
-})
-export class App {}
diff --git a/spector-cortex/src/app/core/models/cortex-events.ts b/spector-cortex/src/app/core/models/cortex-events.ts
deleted file mode 100644
index 6702489..0000000
--- a/spector-cortex/src/app/core/models/cortex-events.ts
+++ /dev/null
@@ -1,105 +0,0 @@
-// ═══════════════════════════════════════════════════════════════════════
-// Spector Cortex — Event Type Interfaces
-// ═══════════════════════════════════════════════════════════════════════
-// SSE event payloads from the Spector node backend.
-// Maps to the Java SpectorEvent hierarchy in spector-node.
-
-/** Base interface for all cortex SSE events. */
-export interface CortexEvent {
-  readonly eventType: string;
-  readonly timestamp: number;
-  readonly nodeId: string;
-}
-
-/**
- * Query trace event — emitted after each recall pipeline execution.
- * Shows per-phase record survival counts for the scoring funnel.
- */
-export interface QueryTraceEvent extends CortexEvent {
-  readonly eventType: 'cortex.query.trace';
-  readonly queryText: string;
-  readonly cognitiveProfile: string;
-  readonly synapticTagMask: number;
-  readonly totalRecords: number;
-  readonly afterTombstone: number;
-  readonly afterTagGate: number;
-  readonly afterValence: number;
-  readonly afterDecay: number;
-  readonly afterVectorDistance: number;
-  readonly finalTopK: number;
-  readonly hebbianActivated: number;
-  readonly temporalLinked: number;
-  readonly entityDiscovered: number;
-  readonly latencyMicros: number;
-}
-
-/**
- * SIMD lane event — emitted during vector operations.
- * Reports lane utilization and kernel activity.
- */
-export interface SimdLaneEvent extends CortexEvent {
-  readonly eventType: 'cortex.simd.lane';
-  readonly vectorBitSize: number;
-  readonly laneCount: number;
-  readonly totalIterations: number;
-  readonly tailLanesActive: number;
-  readonly activeKernel: string;
-  readonly fmaOpsCount: number;
-}
-
-/**
- * Memory diagnostic event — periodic system health snapshot.
- * Emitted every ~1s when dashboard is connected.
- */
-export interface MemoryDiagnosticEvent extends CortexEvent {
-  readonly eventType: 'cortex.memory.diagnostic';
-  readonly offHeapBytes: number;
-  readonly pinnedBytes: number;
-  readonly jvmHeapUsed: number;
-  readonly jvmHeapMax: number;
-  readonly gpuAllocated: number;
-  readonly gpuFree: number;
-  readonly softPageFaults: number;
-  readonly hardPageFaults: number;
-  readonly workingCount: number;
-  readonly episodicCount: number;
-  readonly semanticCount: number;
-  readonly proceduralCount: number;
-  readonly hebbianEdges: number;
-  readonly temporalLinks: number;
-  readonly entityNodes: number;
-  readonly entityEdges: number;
-  readonly coActivationPairs: number;
-  readonly stdpEdges: number;
-}
-
-/**
- * Graph pulse event — emitted during spreading activation,
- * temporal chain traversal, or entity BFS.
- */
-export interface GraphPulseEvent extends CortexEvent {
-  readonly eventType: 'cortex.graph.pulse';
-  readonly graphType: 'hebbian' | 'temporal' | 'entity';
-  readonly sourceNode: number;
-  readonly activatedEdges: Array<[number, number]>; // [targetNode, weight×1000]
-  readonly depth: number;
-}
-
-/**
- * Reflect cycle event — emitted after memory consolidation.
- */
-export interface ReflectCycleEvent extends CortexEvent {
-  readonly eventType: 'cortex.reflect.cycle';
-  readonly hebbianEdgesDecayed: number;
-  readonly hebbianEdgesRemoved: number;
-  readonly decayFactor: number;
-  readonly durationMs: number;
-}
-
-/** Union type for all cortex events */
-export type AnyCortexEvent =
-  | QueryTraceEvent
-  | SimdLaneEvent
-  | MemoryDiagnosticEvent
-  | GraphPulseEvent
-  | ReflectCycleEvent;
diff --git a/spector-cortex/src/app/core/models/graph-types.ts b/spector-cortex/src/app/core/models/graph-types.ts
deleted file mode 100644
index 1711ada..0000000
--- a/spector-cortex/src/app/core/models/graph-types.ts
+++ /dev/null
@@ -1,89 +0,0 @@
-// ═══════════════════════════════════════════════════════════════════════
-// Spector Cortex — Graph Type Interfaces
-// ═══════════════════════════════════════════════════════════════════════
-// Data models for the 3D neural graph visualization.
-
-import { MemoryTier } from './memory-types';
-
-/** A memory node in the 3D neural graph. */
-export interface NeuralNode {
-  readonly id: string;
-  readonly index: number;
-  readonly tier: MemoryTier;
-  readonly importance: number;       // 0.0 – 1.0
-  readonly valence: number;          // -128 to 127
-  readonly arousal: number;          // 0 – 255
-  readonly recallCount: number;
-  readonly decayFactor: number;      // 0.0 – 1.0
-  readonly isResolved: boolean;      // Zeigarnik flag
-  readonly isPinned: boolean;
-  readonly isTombstoned: boolean;
-  readonly synapticTags: number;     // 64-bit bitmask
-  readonly label: string;
-
-  // Visual state (mutable during animation)
-  activation: number;               // 0.0 = dormant, 1.0 = fully firing
-  position: [number, number, number];
-}
-
-/** Hebbian edge — undirected association between memory nodes. */
-export interface HebbianEdge {
-  readonly from: number;             // source node index
-  readonly to: number;               // target node index
-  readonly weight: number;           // association strength 0.0 – 1.0
-  activation: number;               // glow intensity during spreading activation
-}
-
-/** Temporal link — directed session-ordered connection. */
-export interface TemporalLink {
-  readonly from: number;
-  readonly to: number;
-  readonly sessionId: number;
-  activation: number;
-}
-
-/** Entity relation — typed knowledge graph edge. */
-export interface EntityRelation {
-  readonly sourceEntity: string;
-  readonly targetEntity: string;
-  readonly relationType: string;
-  readonly weight: number;
-  activation: number;
-}
-
-/** Entity node in the knowledge graph. */
-export interface EntityNode {
-  readonly name: string;
-  readonly entityType: string;
-  readonly memoryRefCount: number;
-  activation: number;
-  position: [number, number, number];
-}
-
-/** Active traversal path for query animation. */
-export interface TraversalPath {
-  readonly queryText: string;
-  readonly visitedNodes: number[];
-  readonly activeEdges: Array<[number, number]>;
-  readonly phase: 'tag-gate' | 'vector-scan' | 'hebbian' | 'temporal' | 'entity' | 'complete';
-  readonly progress: number;         // 0.0 – 1.0
-}
-
-/** Memory segment for heatmap visualization. */
-export interface MemorySegmentInfo {
-  readonly name: string;
-  readonly tier: MemoryTier | 'HEBBIAN' | 'TEMPORAL' | 'ENTITY' | 'COACTIVATION' | 'STDP';
-  readonly sizeBytes: number;
-  readonly usedBytes: number;
-  readonly recordCount: number;
-  readonly bytesPerRecord: number;
-  readonly heatIntensity: number;    // 0.0 – 1.0 (read/write activity)
-}
-
-/** SIMD register lane state. */
-export interface SimdLaneState {
-  readonly laneIndex: number;
-  readonly isActive: boolean;
-  readonly value: number;
-  intensity: number;                 // glow intensity 0.0 – 1.0
-}
diff --git a/spector-cortex/src/app/core/models/memory-types.ts b/spector-cortex/src/app/core/models/memory-types.ts
deleted file mode 100644
index c1170d9..0000000
--- a/spector-cortex/src/app/core/models/memory-types.ts
+++ /dev/null
@@ -1,138 +0,0 @@
-// ═══════════════════════════════════════════════════════════════════════
-// Spector Cortex — Memory Tier & Cognitive Profile Enums
-// ═══════════════════════════════════════════════════════════════════════
-
-/** Memory tier classification — maps to Java MemoryType enum. */
-export enum MemoryTier {
-  WORKING = 'WORKING',
-  EPISODIC = 'EPISODIC',
-  SEMANTIC = 'SEMANTIC',
-  PROCEDURAL = 'PROCEDURAL',
-}
-
-/** Cognitive graph layer for visualization. */
-export enum GraphLayer {
-  HEBBIAN = 'HEBBIAN',
-  TEMPORAL = 'TEMPORAL',
-  ENTITY = 'ENTITY',
-}
-
-/**
- * Cognitive profile — maps to Java CognitiveProfile enum.
- * Each profile has unique α/β weights and visual behavior.
- */
-export enum CognitiveProfile {
-  BALANCED = 'BALANCED',
-  EXPLORING = 'EXPLORING',
-  DEBUGGING = 'DEBUGGING',
-  RECALLING = 'RECALLING',
-  CRITICAL = 'CRITICAL',
-  HYPERFOCUS = 'HYPERFOCUS',
-  SYSTEMATIZER = 'SYSTEMATIZER',
-  DIVERGENT = 'DIVERGENT',
-  PARANOID_SENTINEL = 'PARANOID_SENTINEL',
-  THE_EXECUTOR = 'THE_EXECUTOR',
-  HIGHLY_SENSITIVE = 'HIGHLY_SENSITIVE',
-  DEFAULT_MODE_NETWORK = 'DEFAULT_MODE_NETWORK',
-}
-
-/** Profile parameter set for radar chart display. */
-export interface ProfileParams {
-  readonly alpha: number;
-  readonly beta: number;
-  readonly strictness: number;
-  readonly valenceMin: number;
-  readonly valenceMax: number;
-  readonly lateralMode: boolean;
-  readonly hyperfocusBoost: number;
-  readonly label: string;
-  readonly description: string;
-}
-
-/** Mapping of all cognitive profiles to their parameters. */
-export const PROFILE_PARAMS: Record<CognitiveProfile, ProfileParams> = {
-  [CognitiveProfile.BALANCED]: {
-    alpha: 0.6, beta: 0.4, strictness: 1.0,
-    valenceMin: -128, valenceMax: 127,
-    lateralMode: false, hyperfocusBoost: 0,
-    label: 'Balanced', description: 'Equal weight to similarity and importance',
-  },
-  [CognitiveProfile.EXPLORING]: {
-    alpha: 0.8, beta: 0.2, strictness: 1.0,
-    valenceMin: -128, valenceMax: 127,
-    lateralMode: false, hyperfocusBoost: 0,
-    label: 'Exploring', description: 'Similarity-dominated for creative recall',
-  },
-  [CognitiveProfile.DEBUGGING]: {
-    alpha: 0.3, beta: 0.7, strictness: 1.0,
-    valenceMin: -128, valenceMax: -10,
-    lateralMode: false, hyperfocusBoost: 0,
-    label: 'Debugging', description: 'Importance-dominated, negative valence bias',
-  },
-  [CognitiveProfile.RECALLING]: {
-    alpha: 0.4, beta: 0.6, strictness: 1.0,
-    valenceMin: 10, valenceMax: 127,
-    lateralMode: false, hyperfocusBoost: 0,
-    label: 'Recalling', description: 'Importance-dominated, positive valence bias',
-  },
-  [CognitiveProfile.CRITICAL]: {
-    alpha: 0.2, beta: 0.8, strictness: 1.0,
-    valenceMin: -128, valenceMax: 127,
-    lateralMode: false, hyperfocusBoost: 0,
-    label: 'Critical', description: 'Heavily importance-dominated, full range',
-  },
-  [CognitiveProfile.HYPERFOCUS]: {
-    alpha: 1.0, beta: 0.0, strictness: 1.0,
-    valenceMin: -128, valenceMax: 127,
-    lateralMode: false, hyperfocusBoost: 1.5,
-    label: 'Hyperfocus', description: 'Pure similarity, zero time decay',
-  },
-  [CognitiveProfile.SYSTEMATIZER]: {
-    alpha: 0.3, beta: 0.7, strictness: 10.0,
-    valenceMin: -128, valenceMax: 127,
-    lateralMode: false, hyperfocusBoost: 0,
-    label: 'Systematizer', description: 'Lossless consolidation, cliff function',
-  },
-  [CognitiveProfile.DIVERGENT]: {
-    alpha: 0.8, beta: 0.2, strictness: 1.0,
-    valenceMin: -128, valenceMax: 127,
-    lateralMode: true, hyperfocusBoost: 0,
-    label: 'Divergent', description: 'Lateral/orthogonal retrieval enabled',
-  },
-  [CognitiveProfile.PARANOID_SENTINEL]: {
-    alpha: 0.2, beta: 0.8, strictness: 1.0,
-    valenceMin: -128, valenceMax: -1,
-    lateralMode: false, hyperfocusBoost: 0,
-    label: 'Paranoid Sentinel', description: 'Threat detection, negative-only',
-  },
-  [CognitiveProfile.THE_EXECUTOR]: {
-    alpha: 0.3, beta: 0.7, strictness: 10.0,
-    valenceMin: -128, valenceMax: 127,
-    lateralMode: false, hyperfocusBoost: 0,
-    label: 'The Executor', description: 'Strict matching, no lateral exploration',
-  },
-  [CognitiveProfile.HIGHLY_SENSITIVE]: {
-    alpha: 0.7, beta: 0.3, strictness: 1.0,
-    valenceMin: -128, valenceMax: 127,
-    lateralMode: false, hyperfocusBoost: 0,
-    label: 'Highly Sensitive', description: 'Enhanced sensory processing depth',
-  },
-  [CognitiveProfile.DEFAULT_MODE_NETWORK]: {
-    alpha: 0.2, beta: 0.8, strictness: 1.0,
-    valenceMin: -128, valenceMax: 127,
-    lateralMode: false, hyperfocusBoost: 0,
-    label: 'Default Mode Network', description: 'Mind-wandering, deep consolidated knowledge',
-  },
-};
-
-/** Connection status for SSE stream. */
-export type ConnectionStatus = 'connected' | 'disconnected' | 'reconnecting';
-
-/** Pipeline phase for funnel visualization. */
-export interface PipelinePhase {
-  readonly name: string;
-  readonly count: number;
-  readonly filtered: number;
-  readonly filterPercentage: number;
-  readonly color: string;
-}
diff --git a/spector-cortex/src/app/core/services/cortex-state.service.ts b/spector-cortex/src/app/core/services/cortex-state.service.ts
deleted file mode 100644
index b3a2d6b..0000000
--- a/spector-cortex/src/app/core/services/cortex-state.service.ts
+++ /dev/null
@@ -1,190 +0,0 @@
-// ═══════════════════════════════════════════════════════════════════════
-// Spector Cortex — Central State Service
-// ═══════════════════════════════════════════════════════════════════════
-// Signal-based reactive store for all dashboard state.
-// Components read signals; services write to them.
-
-import { Injectable, signal, computed } from '@angular/core';
-import {
-  QueryTraceEvent,
-  SimdLaneEvent,
-  MemoryDiagnosticEvent,
-  GraphPulseEvent,
-  ReflectCycleEvent,
-} from '../models/cortex-events';
-import { CognitiveProfile, ConnectionStatus } from '../models/memory-types';
-
-/** Maximum number of historical query traces to retain. */
-const MAX_QUERY_HISTORY = 50;
-const MAX_GRAPH_PULSES = 100;
-const MAX_METRICS_HISTORY = 120; // 2 min at 1s intervals
-
-/** Time-series data point for metrics chart. */
-export interface MetricsPoint {
-  timestamp: number;
-  recallRate: number;
-  rememberRate: number;
-  reinforceRate: number;
-  forgetRate: number;
-  avgLatencyMs: number;
-}
-
-/** Decay curve data point. */
-export interface DecayPoint {
-  ageDays: number;
-  rawDecay: number;
-  ltpDecay: number;     // with reconsolidation
-}
-
-/** Habituation state for the meter. */
-export interface HabituationState {
-  inhibitionOfReturn: number;   // 0-1, higher = more suppressed
-  semanticSatiation: number;    // 0-1, higher = more saturated
-  habituationPenalty: number;   // 0-1, current average penalty
-  activeSuppressions: number;   // count of suppressed memory IDs
-  satiationCacheSize: number;   // current LRU cache occupancy
-}
-
-/** Graph layer visibility toggles. */
-export interface GraphLayerToggles {
-  hebbian: boolean;
-  temporal: boolean;
-  entity: boolean;
-  particles: boolean;
-}
-
-@Injectable({ providedIn: 'root' })
-export class CortexStateService {
-
-  // ── Connection ─────────────────────────────────────────────────────
-  readonly connectionStatus = signal<ConnectionStatus>('disconnected');
-  readonly selectedNode = signal<string>('local');
-  readonly useMockData = signal<boolean>(true);
-
-  // ── Query Trace ────────────────────────────────────────────────────
-  readonly currentQueryTrace = signal<QueryTraceEvent | null>(null);
-  readonly queryHistory = signal<QueryTraceEvent[]>([]);
-
-  // ── SIMD ───────────────────────────────────────────────────────────
-  readonly simdState = signal<SimdLaneEvent | null>(null);
-
-  // ── Memory Diagnostics ─────────────────────────────────────────────
-  readonly memoryDiag = signal<MemoryDiagnosticEvent | null>(null);
-
-  // ── Graph Pulses ───────────────────────────────────────────────────
-  readonly graphPulses = signal<GraphPulseEvent[]>([]);
-
-  // ── Reflection ─────────────────────────────────────────────────────
-  readonly lastReflect = signal<ReflectCycleEvent | null>(null);
-
-  // ── Cognitive Profile ──────────────────────────────────────────────
-  readonly activeProfile = signal<CognitiveProfile>(CognitiveProfile.BALANCED);
-
-  // ── Graph Layer Toggles ────────────────────────────────────────────
-  readonly graphLayers = signal<GraphLayerToggles>({
-    hebbian: true, temporal: true, entity: true, particles: true,
-  });
-
-  // ── Live Metrics Time-Series ───────────────────────────────────────
-  readonly metricsHistory = signal<MetricsPoint[]>([]);
-
-  // ── Decay Curve ────────────────────────────────────────────────────
-  readonly decayCurve = signal<DecayPoint[]>([]);
-
-  // ── Habituation ────────────────────────────────────────────────────
-  readonly habituation = signal<HabituationState>({
-    inhibitionOfReturn: 0, semanticSatiation: 0, habituationPenalty: 1,
-    activeSuppressions: 0, satiationCacheSize: 0,
-  });
-
-  // ── Zeigarnik ──────────────────────────────────────────────────────
-  readonly unresolvedCount = signal<number>(0);
-  readonly totalTaskCount = signal<number>(0);
-
-  // ── Vector Space ───────────────────────────────────────────────────
-  readonly vectorPoints = signal<Array<{
-    id: string;
-    position: [number, number, number];
-    tier: string;
-    importance: number;
-    label: string;
-  }>>([]);
-  readonly queryVector = signal<[number, number, number] | null>(null);
-
-  // ── Query Input ────────────────────────────────────────────────────
-  readonly isQueryRunning = signal<boolean>(false);
-
-  // ── Computed ───────────────────────────────────────────────────────
-  readonly isConnected = computed(() => this.connectionStatus() === 'connected');
-
-  readonly totalMemoryCount = computed(() => {
-    const diag = this.memoryDiag();
-    if (!diag) return 0;
-    return diag.workingCount + diag.episodicCount + diag.semanticCount + diag.proceduralCount;
-  });
-
-  readonly latestLatencyMs = computed(() => {
-    const trace = this.currentQueryTrace();
-    return trace ? (trace.latencyMicros / 1000).toFixed(2) : '—';
-  });
-
-  readonly zeigarnikPercentage = computed(() => {
-    const total = this.totalTaskCount();
-    const unresolved = this.unresolvedCount();
-    return total > 0 ? Math.round((unresolved / total) * 100) : 0;
-  });
-
-  readonly avgLatency = computed(() => {
-    const history = this.queryHistory();
-    if (history.length === 0) return 0;
-    const sum = history.reduce((a, b) => a + b.latencyMicros, 0);
-    return sum / history.length / 1000;
-  });
-
-  // ── Mutations (called by services, not components) ─────────────────
-
-  pushQueryTrace(event: QueryTraceEvent): void {
-    this.currentQueryTrace.set(event);
-    this.queryHistory.update(history => {
-      const next = [event, ...history];
-      return next.length > MAX_QUERY_HISTORY ? next.slice(0, MAX_QUERY_HISTORY) : next;
-    });
-    // Auto-detect profile from event
-    if (event.cognitiveProfile) {
-      const profile = event.cognitiveProfile as CognitiveProfile;
-      if (Object.values(CognitiveProfile).includes(profile)) {
-        this.activeProfile.set(profile);
-      }
-    }
-  }
-
-  pushSimdEvent(event: SimdLaneEvent): void {
-    this.simdState.set(event);
-  }
-
-  pushMemoryDiag(event: MemoryDiagnosticEvent): void {
-    this.memoryDiag.set(event);
-  }
-
-  pushGraphPulse(event: GraphPulseEvent): void {
-    this.graphPulses.update(pulses => {
-      const next = [event, ...pulses];
-      return next.length > MAX_GRAPH_PULSES ? next.slice(0, MAX_GRAPH_PULSES) : next;
-    });
-  }
-
-  pushReflect(event: ReflectCycleEvent): void {
-    this.lastReflect.set(event);
-  }
-
-  pushMetrics(point: MetricsPoint): void {
-    this.metricsHistory.update(history => {
-      const next = [...history, point];
-      return next.length > MAX_METRICS_HISTORY ? next.slice(-MAX_METRICS_HISTORY) : next;
-    });
-  }
-
-  toggleGraphLayer(layer: keyof GraphLayerToggles): void {
-    this.graphLayers.update(l => ({ ...l, [layer]: !l[layer] }));
-  }
-}
diff --git a/spector-cortex/src/app/core/services/mock-data.service.ts b/spector-cortex/src/app/core/services/mock-data.service.ts
deleted file mode 100644
index 678f12b..0000000
--- a/spector-cortex/src/app/core/services/mock-data.service.ts
+++ /dev/null
@@ -1,360 +0,0 @@
-// ═══════════════════════════════════════════════════════════════════════
-// Spector Cortex — Mock Data Service
-// ═══════════════════════════════════════════════════════════════════════
-// Generates realistic simulated events for standalone development.
-// Mimics the actual Spector recall pipeline behavior.
-
-import { Injectable, inject, OnDestroy } from '@angular/core';
-import { CortexStateService, MetricsPoint, DecayPoint } from './cortex-state.service';
-import {
-  QueryTraceEvent,
-  SimdLaneEvent,
-  MemoryDiagnosticEvent,
-  GraphPulseEvent,
-  ReflectCycleEvent,
-} from '../models/cortex-events';
-import { CognitiveProfile } from '../models/memory-types';
-
-const SAMPLE_QUERIES = [
-  'database connection timeout error',
-  'user authentication flow',
-  'implement caching strategy for API responses',
-  'fix memory leak in event handler',
-  'refactor payment processing module',
-  'design microservice architecture',
-  'optimize SQL query performance',
-  'resolve CORS issue in frontend',
-  'add rate limiting to REST API',
-  'deploy to Kubernetes cluster',
-  'implement WebSocket real-time updates',
-  'debug race condition in async handler',
-];
-
-const PROFILES = Object.values(CognitiveProfile);
-const KERNELS = ['cosine', 'dotProduct', 'euclidean', 'svasq4', 'packedDot'];
-const TIERS = ['WORKING', 'EPISODIC', 'SEMANTIC', 'PROCEDURAL'];
-const LABELS = [
-  'auth-flow', 'db-pool', 'cache-hit', 'user-session', 'api-rate-limit',
-  'jwt-decode', 'cors-policy', 'event-loop', 'gc-pause', 'thread-pool',
-  'ssl-cert', 'dns-resolve', 'retry-logic', 'circuit-breaker', 'load-balance',
-  'schema-migrate', 'queue-drain', 'pub-sub', 'batch-job', 'cron-trigger',
-  'webhook-retry', 'health-check', 'blue-green', 'canary-deploy', 'rollback',
-  'mem-leak-fix', 'cpu-bound', 'io-wait', 'deadlock', 'starvation',
-];
-
-@Injectable({ providedIn: 'root' })
-export class MockDataService implements OnDestroy {
-
-  private readonly state = inject(CortexStateService);
-
-  private queryInterval: ReturnType<typeof setInterval> | null = null;
-  private simdInterval: ReturnType<typeof setInterval> | null = null;
-  private diagInterval: ReturnType<typeof setInterval> | null = null;
-  private graphInterval: ReturnType<typeof setInterval> | null = null;
-  private reflectInterval: ReturnType<typeof setInterval> | null = null;
-  private metricsInterval: ReturnType<typeof setInterval> | null = null;
-  private habituationInterval: ReturnType<typeof setInterval> | null = null;
-  private profileIndex = 0;
-  private queryCounter = 0;
-
-  /** Start emitting mock events at realistic intervals. */
-  start(): void {
-    this.state.connectionStatus.set('connected');
-
-    // Generate initial vector space points
-    this.generateVectorSpace();
-
-    // Generate decay curve (static shape, varies per profile)
-    this.generateDecayCurve();
-
-    // Set initial Zeigarnik counts
-    this.state.unresolvedCount.set(7);
-    this.state.totalTaskCount.set(45);
-
-    // Query traces every 2–4 seconds
-    this.queryInterval = setInterval(() => {
-      this.emitQueryTrace();
-    }, 2000 + Math.random() * 2000);
-
-    // SIMD events every 500ms
-    this.simdInterval = setInterval(() => {
-      this.emitSimdEvent();
-    }, 500);
-
-    // Memory diagnostics every 1s
-    this.diagInterval = setInterval(() => {
-      this.emitMemoryDiag();
-    }, 1000);
-
-    // Graph pulses every 1.5–3s
-    this.graphInterval = setInterval(() => {
-      this.emitGraphPulse();
-    }, 1500 + Math.random() * 1500);
-
-    // Reflect cycles every 10–15s
-    this.reflectInterval = setInterval(() => {
-      this.emitReflect();
-    }, 10000 + Math.random() * 5000);
-
-    // Metrics time-series every 1s
-    this.metricsInterval = setInterval(() => {
-      this.emitMetrics();
-    }, 1000);
-
-    // Habituation updates every 2s
-    this.habituationInterval = setInterval(() => {
-      this.updateHabituation();
-    }, 2000);
-
-    // Emit initial data immediately
-    this.emitMemoryDiag();
-    this.emitSimdEvent();
-    this.emitQueryTrace();
-    this.emitMetrics();
-  }
-
-  /** Stop all mock event emission. */
-  stop(): void {
-    [this.queryInterval, this.simdInterval, this.diagInterval,
-     this.graphInterval, this.reflectInterval, this.metricsInterval,
-     this.habituationInterval].forEach(id => {
-      if (id !== null) clearInterval(id);
-    });
-    this.queryInterval = this.simdInterval = this.diagInterval =
-      this.graphInterval = this.reflectInterval = this.metricsInterval =
-      this.habituationInterval = null;
-    this.state.connectionStatus.set('disconnected');
-  }
-
-  ngOnDestroy(): void {
-    this.stop();
-  }
-
-  // ── Emitters ───────────────────────────────────────────────────────
-
-  private emitQueryTrace(): void {
-    this.queryCounter++;
-    const total = 500_000 + Math.floor(Math.random() * 1_500_000);
-    const afterTombstone = Math.floor(total * (0.990 + Math.random() * 0.008));
-    const afterTagGate = Math.floor(afterTombstone * (0.005 + Math.random() * 0.025));
-    const afterValence = Math.floor(afterTagGate * (0.85 + Math.random() * 0.12));
-    const afterDecay = Math.floor(afterValence * (0.60 + Math.random() * 0.30));
-    const afterVector = afterDecay;
-    const finalTopK = Math.min(10 + Math.floor(Math.random() * 5), afterVector);
-
-    const profile = PROFILES[this.profileIndex % PROFILES.length];
-    this.profileIndex++;
-
-    const event: QueryTraceEvent = {
-      eventType: 'cortex.query.trace',
-      timestamp: Date.now(),
-      nodeId: 'node-1',
-      queryText: SAMPLE_QUERIES[Math.floor(Math.random() * SAMPLE_QUERIES.length)],
-      cognitiveProfile: profile,
-      synapticTagMask: Math.floor(Math.random() * 0xFFFF),
-      totalRecords: total,
-      afterTombstone,
-      afterTagGate,
-      afterValence,
-      afterDecay,
-      afterVectorDistance: afterVector,
-      finalTopK,
-      hebbianActivated: Math.floor(Math.random() * 5),
-      temporalLinked: Math.floor(Math.random() * 4),
-      entityDiscovered: Math.floor(Math.random() * 3),
-      latencyMicros: 800 + Math.floor(Math.random() * 4000),
-    };
-
-    this.state.pushQueryTrace(event);
-
-    // Update query vector in embedding space
-    this.state.queryVector.set([
-      (Math.random() - 0.5) * 40,
-      (Math.random() - 0.5) * 40,
-      (Math.random() - 0.5) * 40,
-    ]);
-
-    // Randomly shift Zeigarnik
-    if (Math.random() > 0.7) {
-      this.state.unresolvedCount.update(v => Math.max(0, v + (Math.random() > 0.5 ? 1 : -1)));
-    }
-    if (Math.random() > 0.9) {
-      this.state.totalTaskCount.update(v => v + 1);
-    }
-  }
-
-  private emitSimdEvent(): void {
-    const is512 = Math.random() > 0.3;
-    const laneCount = is512 ? 16 : 8;
-    const dims = [384, 512, 768, 1024][Math.floor(Math.random() * 4)];
-    const totalIter = Math.ceil(dims / laneCount);
-    const tailLanes = dims % laneCount || laneCount;
-
-    const event: SimdLaneEvent = {
-      eventType: 'cortex.simd.lane',
-      timestamp: Date.now(),
-      nodeId: 'node-1',
-      vectorBitSize: is512 ? 512 : 256,
-      laneCount,
-      totalIterations: totalIter,
-      tailLanesActive: tailLanes,
-      activeKernel: KERNELS[Math.floor(Math.random() * KERNELS.length)],
-      fmaOpsCount: Math.floor(Math.random() * 100_000_000),
-    };
-
-    this.state.pushSimdEvent(event);
-  }
-
-  private emitMemoryDiag(): void {
-    const base = this.state.memoryDiag();
-    const jitter = (v: number, pct: number) =>
-      Math.max(0, Math.floor(v * (1 + (Math.random() - 0.5) * pct)));
-
-    const event: MemoryDiagnosticEvent = {
-      eventType: 'cortex.memory.diagnostic',
-      timestamp: Date.now(),
-      nodeId: 'node-1',
-      offHeapBytes: jitter(base?.offHeapBytes ?? 50_331_648, 0.05),
-      pinnedBytes: jitter(base?.pinnedBytes ?? 16_777_216, 0.03),
-      jvmHeapUsed: jitter(base?.jvmHeapUsed ?? 268_435_456, 0.10),
-      jvmHeapMax: 1_073_741_824,
-      gpuAllocated: jitter(base?.gpuAllocated ?? 12_884_901_888, 0.02),
-      gpuFree: jitter(base?.gpuFree ?? 12_884_901_888, 0.02),
-      softPageFaults: (base?.softPageFaults ?? 12000) + Math.floor(Math.random() * 50),
-      hardPageFaults: (base?.hardPageFaults ?? 3) + (Math.random() > 0.95 ? 1 : 0),
-      workingCount: jitter(base?.workingCount ?? 45, 0.15),
-      episodicCount: jitter(base?.episodicCount ?? 12500, 0.02),
-      semanticCount: jitter(base?.semanticCount ?? 85000, 0.01),
-      proceduralCount: jitter(base?.proceduralCount ?? 3200, 0.03),
-      hebbianEdges: jitter(base?.hebbianEdges ?? 245000, 0.01),
-      temporalLinks: jitter(base?.temporalLinks ?? 98000, 0.02),
-      entityNodes: jitter(base?.entityNodes ?? 15000, 0.01),
-      entityEdges: jitter(base?.entityEdges ?? 42000, 0.02),
-      coActivationPairs: jitter(base?.coActivationPairs ?? 8500, 0.03),
-      stdpEdges: jitter(base?.stdpEdges ?? 3200, 0.04),
-    };
-
-    this.state.pushMemoryDiag(event);
-  }
-
-  private emitGraphPulse(): void {
-    const types = ['hebbian', 'temporal', 'entity'] as const;
-    const graphType = types[Math.floor(Math.random() * types.length)];
-    const source = Math.floor(Math.random() * 1000);
-
-    const edgeCount = graphType === 'hebbian' ? 2 + Math.floor(Math.random() * 4)
-      : graphType === 'temporal' ? 1 + Math.floor(Math.random() * 3)
-      : 1 + Math.floor(Math.random() * 2);
-
-    const edges: Array<[number, number]> = [];
-    for (let i = 0; i < edgeCount; i++) {
-      edges.push([
-        Math.floor(Math.random() * 1000),
-        300 + Math.floor(Math.random() * 700),
-      ]);
-    }
-
-    const event: GraphPulseEvent = {
-      eventType: 'cortex.graph.pulse',
-      timestamp: Date.now(),
-      nodeId: 'node-1',
-      graphType,
-      sourceNode: source,
-      activatedEdges: edges,
-      depth: 1 + Math.floor(Math.random() * 2),
-    };
-
-    this.state.pushGraphPulse(event);
-  }
-
-  private emitReflect(): void {
-    const event: ReflectCycleEvent = {
-      eventType: 'cortex.reflect.cycle',
-      timestamp: Date.now(),
-      nodeId: 'node-1',
-      hebbianEdgesDecayed: 50 + Math.floor(Math.random() * 200),
-      hebbianEdgesRemoved: Math.floor(Math.random() * 20),
-      decayFactor: 0.95 + Math.random() * 0.04,
-      durationMs: 10 + Math.floor(Math.random() * 50),
-    };
-
-    this.state.pushReflect(event);
-  }
-
-  private emitMetrics(): void {
-    const history = this.state.queryHistory();
-    const recentCount = history.filter(h => h.timestamp > Date.now() - 5000).length;
-
-    const point: MetricsPoint = {
-      timestamp: Date.now(),
-      recallRate: recentCount * (0.8 + Math.random() * 0.4),
-      rememberRate: Math.random() * 2,
-      reinforceRate: Math.random() * 1.5,
-      forgetRate: Math.random() * 0.5,
-      avgLatencyMs: 0.8 + Math.random() * 4,
-    };
-
-    this.state.pushMetrics(point);
-  }
-
-  private updateHabituation(): void {
-    const current = this.state.habituation();
-    this.state.habituation.set({
-      inhibitionOfReturn: Math.min(1, Math.max(0, current.inhibitionOfReturn + (Math.random() - 0.45) * 0.1)),
-      semanticSatiation: Math.min(1, Math.max(0, current.semanticSatiation + (Math.random() - 0.48) * 0.08)),
-      habituationPenalty: Math.min(1, Math.max(0, current.habituationPenalty + (Math.random() - 0.5) * 0.05)),
-      activeSuppressions: Math.max(0, Math.floor(current.activeSuppressions + (Math.random() - 0.4) * 3)),
-      satiationCacheSize: Math.max(0, Math.floor(current.satiationCacheSize + (Math.random() - 0.3) * 5)),
-    });
-  }
-
-  private generateVectorSpace(): void {
-    // Generate 300 points in a PCA-projected 3D embedding space with natural clusters
-    const points: Array<{
-      id: string; position: [number, number, number];
-      tier: string; importance: number; label: string;
-    }> = [];
-
-    // Create semantic clusters
-    const clusters = [
-      { center: [20, 10, 5], tier: 'SEMANTIC', spread: 8 },
-      { center: [-15, 20, -10], tier: 'SEMANTIC', spread: 7 },
-      { center: [5, -25, 15], tier: 'EPISODIC', spread: 10 },
-      { center: [-20, -10, -20], tier: 'EPISODIC', spread: 9 },
-      { center: [0, 0, 0], tier: 'WORKING', spread: 5 },
-      { center: [25, -15, -5], tier: 'PROCEDURAL', spread: 6 },
-      { center: [-10, 5, 25], tier: 'PROCEDURAL', spread: 7 },
-    ];
-
-    for (let i = 0; i < 300; i++) {
-      const cluster = clusters[Math.floor(Math.random() * clusters.length)];
-      const gaussian = () => (Math.random() + Math.random() + Math.random() - 1.5) * 2;
-      points.push({
-        id: `mem-${i}`,
-        position: [
-          cluster.center[0] + gaussian() * cluster.spread,
-          cluster.center[1] + gaussian() * cluster.spread,
-          cluster.center[2] + gaussian() * cluster.spread,
-        ] as [number, number, number],
-        tier: cluster.tier,
-        importance: 0.1 + Math.random() * 0.9,
-        label: LABELS[i % LABELS.length],
-      });
-    }
-
-    this.state.vectorPoints.set(points);
-  }
-
-  private generateDecayCurve(): void {
-    const points: DecayPoint[] = [];
-    for (let d = 0; d <= 30; d += 0.5) {
-      const rawDecay = Math.exp(-0.15 * d); // Standard Ebbinghaus
-      // LTP reconsolidation: recall events boost retention
-      const recallEvents = Math.floor(d / 3); // roughly every 3 days
-      const ltpBoost = recallEvents * 0.1;
-      const ltpDecay = Math.min(1, rawDecay + ltpBoost * Math.exp(-0.05 * d));
-      points.push({ ageDays: d, rawDecay, ltpDecay });
-    }
-    this.state.decayCurve.set(points);
-  }
-}
diff --git a/spector-cortex/src/app/core/services/theme.service.ts b/spector-cortex/src/app/core/services/theme.service.ts
deleted file mode 100644
index e964974..0000000
--- a/spector-cortex/src/app/core/services/theme.service.ts
+++ /dev/null
@@ -1,57 +0,0 @@
-// ═══════════════════════════════════════════════════════════════════════
-// Spector Cortex — Theme Service
-// ═══════════════════════════════════════════════════════════════════════
-// Manages M3 dark/light theme toggle with localStorage persistence.
-
-import { Injectable, signal, computed, effect, PLATFORM_ID, inject } from '@angular/core';
-import { isPlatformBrowser } from '@angular/common';
-
-const THEME_KEY = 'cortex-theme';
-
-@Injectable({ providedIn: 'root' })
-export class ThemeService {
-
-  private readonly platformId = inject(PLATFORM_ID);
-  private readonly isBrowser = isPlatformBrowser(this.platformId);
-
-  /** Current dark mode state. */
-  readonly isDark = signal(true);
-
-  /** Theme label for display. */
-  readonly themeLabel = computed(() => this.isDark() ? 'Dark' : 'Light');
-
-  /** Theme icon for toggle button. */
-  readonly themeIcon = computed(() => this.isDark() ? 'dark_mode' : 'light_mode');
-
-  constructor() {
-    if (this.isBrowser) {
-      const saved = localStorage.getItem(THEME_KEY);
-      if (saved !== null) {
-        this.isDark.set(saved === 'dark');
-      }
-    }
-
-    // Sync theme to DOM whenever signal changes
-    effect(() => {
-      if (this.isBrowser) {
-        const theme = this.isDark() ? 'dark' : 'light';
-        document.documentElement.setAttribute('data-theme', theme);
-        localStorage.setItem(THEME_KEY, theme);
-      }
-    });
-  }
-
-  /** Toggle between dark and light themes. */
-  toggle(): void {
-    this.isDark.update(v => !v);
-  }
-
-  /**
-   * Reads a computed CSS variable value from the document root.
-   * Useful for passing M3 colors into Canvas/WebGL contexts.
-   */
-  getCssVariable(name: string): string {
-    if (!this.isBrowser) return '';
-    return getComputedStyle(document.documentElement).getPropertyValue(name).trim();
-  }
-}
diff --git a/spector-cortex/src/app/features/dashboard/dashboard.component.html b/spector-cortex/src/app/features/dashboard/dashboard.component.html
deleted file mode 100644
index f0da932..0000000
--- a/spector-cortex/src/app/features/dashboard/dashboard.component.html
+++ /dev/null
@@ -1,133 +0,0 @@
-<cortex-header />
-
-<!-- Query Input Bar -->
-<section class="query-bar" style="animation: fade-in-up 0.3s ease both">
-  <cortex-query-input />
-</section>
-
-<main class="dashboard-grid">
-  <!-- Row 1: Neural Graph + Vector Space (hero row) -->
-  <mat-card class="panel panel-neural-graph" appearance="outlined" style="animation: fade-in-up 0.4s ease both">
-    <mat-card-header>
-      <mat-icon mat-card-avatar class="panel-icon">hub</mat-icon>
-      <mat-card-title>Neural Graph</mat-card-title>
-      <mat-card-subtitle>3-Layer Cognitive Network</mat-card-subtitle>
-    </mat-card-header>
-    <mat-card-content class="panel-content">
-      <cortex-neural-graph />
-    </mat-card-content>
-  </mat-card>
-
-  <mat-card class="panel panel-vector-space" appearance="outlined" style="animation: fade-in-up 0.45s ease both">
-    <mat-card-header>
-      <mat-icon mat-card-avatar class="panel-icon">scatter_plot</mat-icon>
-      <mat-card-title>Vector Space</mat-card-title>
-      <mat-card-subtitle>Embedding Projection (PCA)</mat-card-subtitle>
-    </mat-card-header>
-    <mat-card-content class="panel-content">
-      <cortex-vector-space />
-    </mat-card-content>
-  </mat-card>
-
-  <!-- Row 2: Pipeline + Metrics + Profile Radar -->
-  <mat-card class="panel" appearance="outlined" style="animation: fade-in-up 0.5s ease both">
-    <mat-card-header>
-      <mat-icon mat-card-avatar class="panel-icon">filter_alt</mat-icon>
-      <mat-card-title>Scoring Pipeline</mat-card-title>
-      <mat-card-subtitle>Cognitive Funnel</mat-card-subtitle>
-    </mat-card-header>
-    <mat-card-content class="panel-content">
-      <cortex-pipeline-funnel />
-    </mat-card-content>
-  </mat-card>
-
-  <mat-card class="panel" appearance="outlined" style="animation: fade-in-up 0.55s ease both">
-    <mat-card-header>
-      <mat-icon mat-card-avatar class="panel-icon">show_chart</mat-icon>
-      <mat-card-title>Live Metrics</mat-card-title>
-      <mat-card-subtitle>Ops/sec Time Series</mat-card-subtitle>
-    </mat-card-header>
-    <mat-card-content class="panel-content">
-      <cortex-metrics-chart />
-    </mat-card-content>
-  </mat-card>
-
-  <mat-card class="panel panel-radar" appearance="outlined" style="animation: fade-in-up 0.6s ease both">
-    <mat-card-header>
-      <mat-icon mat-card-avatar class="panel-icon">psychology</mat-icon>
-      <mat-card-title>Cognitive Profile</mat-card-title>
-      <mat-card-subtitle>Thalamic Modulation</mat-card-subtitle>
-    </mat-card-header>
-    <mat-card-content class="panel-content">
-      <cortex-profile-radar />
-    </mat-card-content>
-  </mat-card>
-
-  <!-- Row 3: SIMD + Memory Heatmap + Decay Curve -->
-  <mat-card class="panel" appearance="outlined" style="animation: fade-in-up 0.65s ease both">
-    <mat-card-header>
-      <mat-icon mat-card-avatar class="panel-icon">memory</mat-icon>
-      <mat-card-title>SIMD &amp; Hardware</mat-card-title>
-      <mat-card-subtitle>Vector Processing Unit</mat-card-subtitle>
-    </mat-card-header>
-    <mat-card-content class="panel-content">
-      <cortex-simd-panel />
-    </mat-card-content>
-  </mat-card>
-
-  <mat-card class="panel" appearance="outlined" style="animation: fade-in-up 0.7s ease both">
-    <mat-card-header>
-      <mat-icon mat-card-avatar class="panel-icon">grid_on</mat-icon>
-      <mat-card-title>Memory Heatmap</mat-card-title>
-      <mat-card-subtitle>Off-Heap Segments</mat-card-subtitle>
-    </mat-card-header>
-    <mat-card-content class="panel-content">
-      <cortex-memory-heatmap />
-    </mat-card-content>
-  </mat-card>
-
-  <mat-card class="panel" appearance="outlined" style="animation: fade-in-up 0.75s ease both">
-    <mat-card-header>
-      <mat-icon mat-card-avatar class="panel-icon">trending_down</mat-icon>
-      <mat-card-title>Decay Curve</mat-card-title>
-      <mat-card-subtitle>Ebbinghaus + LTP</mat-card-subtitle>
-    </mat-card-header>
-    <mat-card-content class="panel-content">
-      <cortex-decay-curve />
-    </mat-card-content>
-  </mat-card>
-
-  <!-- Row 4: Query History + Zeigarnik + Habituation -->
-  <mat-card class="panel" appearance="outlined" style="animation: fade-in-up 0.8s ease both">
-    <mat-card-header>
-      <mat-icon mat-card-avatar class="panel-icon">history</mat-icon>
-      <mat-card-title>Query History</mat-card-title>
-      <mat-card-subtitle>Recent Recall Timeline</mat-card-subtitle>
-    </mat-card-header>
-    <mat-card-content class="panel-content">
-      <cortex-query-history />
-    </mat-card-content>
-  </mat-card>
-
-  <mat-card class="panel" appearance="outlined" style="animation: fade-in-up 0.85s ease both">
-    <mat-card-header>
-      <mat-icon mat-card-avatar class="panel-icon">pending_actions</mat-icon>
-      <mat-card-title>Zeigarnik Effect</mat-card-title>
-      <mat-card-subtitle>Incomplete Tension</mat-card-subtitle>
-    </mat-card-header>
-    <mat-card-content class="panel-content">
-      <cortex-zeigarnik-tracker />
-    </mat-card-content>
-  </mat-card>
-
-  <mat-card class="panel" appearance="outlined" style="animation: fade-in-up 0.9s ease both">
-    <mat-card-header>
-      <mat-icon mat-card-avatar class="panel-icon">do_not_disturb_on</mat-icon>
-      <mat-card-title>Habituation</mat-card-title>
-      <mat-card-subtitle>Anti-Loop Mechanisms</mat-card-subtitle>
-    </mat-card-header>
-    <mat-card-content class="panel-content">
-      <cortex-habituation-meter />
-    </mat-card-content>
-  </mat-card>
-</main>
diff --git a/spector-cortex/src/app/features/dashboard/dashboard.component.scss b/spector-cortex/src/app/features/dashboard/dashboard.component.scss
deleted file mode 100644
index d564290..0000000
--- a/spector-cortex/src/app/features/dashboard/dashboard.component.scss
+++ /dev/null
@@ -1,104 +0,0 @@
-:host {
-  display: flex;
-  flex-direction: column;
-  height: 100vh;
-  width: 100vw;
-  overflow: hidden;
-  background: var(--mat-sys-surface);
-}
-
-// ── Query Bar ────────────────────────────────────────────────────────
-.query-bar {
-  margin: 8px 12px 0;
-  flex-shrink: 0;
-}
-
-// ── Dashboard Grid ───────────────────────────────────────────────────
-.dashboard-grid {
-  flex: 1;
-  display: grid;
-  grid-template-columns: 1fr 1fr 1fr;
-  grid-template-rows: 380px;       // first row (hero) is explicit
-  grid-auto-rows: 280px;           // remaining rows are fixed 280px
-  column-gap: 14px;
-  row-gap: 16px;
-  padding: 12px 14px 20px;
-  overflow-y: auto;
-  overflow-x: hidden;
-  min-height: 0;
-}
-
-// ── Panel (mat-card) ─────────────────────────────────────────────────
-.panel {
-  display: flex;
-  flex-direction: column;
-  overflow: hidden;
-
-  // mat-card-content should fill remaining space
-  .panel-content {
-    flex: 1;
-    display: flex;
-    flex-direction: column;
-    min-height: 0;
-    overflow: hidden;
-    padding: 0 !important; // remove default mat-card-content padding
-  }
-}
-
-.panel-icon {
-  color: var(--mat-sys-primary);
-  font-size: 20px;
-  width: 20px;
-  height: 20px;
-  background: color-mix(in srgb, var(--mat-sys-primary) 12%, transparent);
-  border-radius: 8px;
-  display: flex;
-  align-items: center;
-  justify-content: center;
-  padding: 4px;
-}
-
-// ── Hero row overrides ───────────────────────────────────────────────
-.panel-neural-graph {
-  grid-column: 1 / 3;
-}
-
-.panel-vector-space {
-  grid-column: 3 / 4;
-}
-
-// Radar needs explicit height for canvas sizing
-.panel-radar {}
-
-// ── Responsive ───────────────────────────────────────────────────────
-@media (max-width: 1200px) {
-  .dashboard-grid {
-    grid-template-columns: 1fr 1fr;
-    grid-auto-rows: minmax(260px, auto);
-  }
-
-  .panel-neural-graph {
-    grid-column: 1 / -1;
-    min-height: 300px;
-  }
-
-  .panel-vector-space {
-    grid-column: span 1;
-    min-height: 280px;
-  }
-}
-
-@media (max-width: 768px) {
-  .dashboard-grid {
-    grid-template-columns: 1fr;
-    grid-auto-rows: minmax(240px, auto);
-    gap: 8px;
-    padding: 8px;
-  }
-
-  .panel-neural-graph,
-  .panel-vector-space {
-    grid-column: 1;
-    min-height: 260px;
-  }
-}
diff --git a/spector-cortex/src/app/features/dashboard/dashboard.component.ts b/spector-cortex/src/app/features/dashboard/dashboard.component.ts
deleted file mode 100644
index 7bf543d..0000000
--- a/spector-cortex/src/app/features/dashboard/dashboard.component.ts
+++ /dev/null
@@ -1,55 +0,0 @@
-import { Component, inject, OnInit, OnDestroy } from '@angular/core';
-import { MatCardModule } from '@angular/material/card';
-import { MatIconModule } from '@angular/material/icon';
-import { HeaderComponent } from '../header/header.component';
-import { NeuralGraphComponent } from '../neural-graph/neural-graph.component';
-import { VectorSpaceComponent } from '../vector-space/vector-space.component';
-import { PipelineFunnelComponent } from '../pipeline-funnel/pipeline-funnel.component';
-import { SimdPanelComponent } from '../simd-panel/simd-panel.component';
-import { MemoryHeatmapComponent } from '../memory-heatmap/memory-heatmap.component';
-import { ProfileRadarComponent } from '../profile-radar/profile-radar.component';
-import { QueryInputComponent } from '../query-input/query-input.component';
-import { QueryHistoryComponent } from '../query-history/query-history.component';
-import { MetricsChartComponent } from '../metrics-chart/metrics-chart.component';
-import { DecayCurveComponent } from '../decay-curve/decay-curve.component';
-import { ZeigarnikTrackerComponent } from '../zeigarnik-tracker/zeigarnik-tracker.component';
-import { HabituationMeterComponent } from '../habituation-meter/habituation-meter.component';
-import { MockDataService } from '../../core/services/mock-data.service';
-import { CortexStateService } from '../../core/services/cortex-state.service';
-
-@Component({
-  selector: 'cortex-dashboard',
-  imports: [
-    MatCardModule,
-    MatIconModule,
-    HeaderComponent,
-    NeuralGraphComponent,
-    VectorSpaceComponent,
-    PipelineFunnelComponent,
-    SimdPanelComponent,
-    MemoryHeatmapComponent,
-    ProfileRadarComponent,
-    QueryInputComponent,
-    QueryHistoryComponent,
-    MetricsChartComponent,
-    DecayCurveComponent,
-    ZeigarnikTrackerComponent,
-    HabituationMeterComponent,
-  ],
-  templateUrl: './dashboard.component.html',
-  styleUrl: './dashboard.component.scss',
-})
-export class DashboardComponent implements OnInit, OnDestroy {
-  private readonly mockData = inject(MockDataService);
-  private readonly state = inject(CortexStateService);
-
-  ngOnInit(): void {
-    if (this.state.useMockData()) {
-      this.mockData.start();
-    }
-  }
-
-  ngOnDestroy(): void {
-    this.mockData.stop();
-  }
-}
diff --git a/spector-cortex/src/app/features/decay-curve/decay-curve.component.html b/spector-cortex/src/app/features/decay-curve/decay-curve.component.html
deleted file mode 100644
index 4bb7963..0000000
--- a/spector-cortex/src/app/features/decay-curve/decay-curve.component.html
+++ /dev/null
@@ -1 +0,0 @@
-<div class="decay-wrapper"><canvas #decayCanvas></canvas></div>
diff --git a/spector-cortex/src/app/features/decay-curve/decay-curve.component.scss b/spector-cortex/src/app/features/decay-curve/decay-curve.component.scss
deleted file mode 100644
index f8926f1..0000000
--- a/spector-cortex/src/app/features/decay-curve/decay-curve.component.scss
+++ /dev/null
@@ -1,5 +0,0 @@
-:host { display: block; flex: 1; min-height: 0; }
-.decay-wrapper {
-  width: 100%; height: 100%; padding: 4px 8px;
-  canvas { display: block; width: 100%; height: 100%; }
-}
diff --git a/spector-cortex/src/app/features/decay-curve/decay-curve.component.ts b/spector-cortex/src/app/features/decay-curve/decay-curve.component.ts
deleted file mode 100644
index d195ea7..0000000
--- a/spector-cortex/src/app/features/decay-curve/decay-curve.component.ts
+++ /dev/null
@@ -1,134 +0,0 @@
-import {
-  Component, ElementRef, ViewChild, AfterViewInit, OnDestroy, inject, effect, PLATFORM_ID,
-} from '@angular/core';
-import { isPlatformBrowser } from '@angular/common';
-import { CortexStateService } from '../../core/services/cortex-state.service';
-import { ThemeService } from '../../core/services/theme.service';
-
-@Component({
-  selector: 'cortex-decay-curve',
-  templateUrl: './decay-curve.component.html',
-  styleUrl: './decay-curve.component.scss',
-})
-export class DecayCurveComponent implements AfterViewInit, OnDestroy {
-
-  @ViewChild('decayCanvas', { static: true })
-  private canvasRef!: ElementRef<HTMLCanvasElement>;
-
-  private readonly state = inject(CortexStateService);
-  private readonly themeService = inject(ThemeService);
-  private readonly platformId = inject(PLATFORM_ID);
-
-  private ctx!: CanvasRenderingContext2D;
-  private animationId = 0;
-
-  ngAfterViewInit(): void {
-    if (!isPlatformBrowser(this.platformId)) return;
-    this.ctx = this.canvasRef.nativeElement.getContext('2d')!;
-    const observer = new ResizeObserver(() => this.resizeCanvas());
-    observer.observe(this.canvasRef.nativeElement.parentElement!);
-    this.resizeCanvas();
-    this.draw();
-
-    effect(() => { this.state.decayCurve(); });
-  }
-
-  ngOnDestroy(): void { cancelAnimationFrame(this.animationId); }
-
-  private resizeCanvas(): void {
-    const parent = this.canvasRef.nativeElement.parentElement!;
-    this.canvasRef.nativeElement.width = parent.clientWidth;
-    this.canvasRef.nativeElement.height = parent.clientHeight;
-  }
-
-  private draw(): void {
-    this.animationId = requestAnimationFrame(() => this.draw());
-
-    const canvas = this.canvasRef.nativeElement;
-    const ctx = this.ctx;
-    const w = canvas.width;
-    const h = canvas.height;
-    ctx.clearRect(0, 0, w, h);
-
-    const curve = this.state.decayCurve();
-    if (curve.length < 2) return;
-
-    const error = this.themeService.getCssVariable('--mat-sys-error') || '#f44336';
-    const primary = this.themeService.getCssVariable('--mat-sys-primary') || '#bb86fc';
-    const outline = this.themeService.getCssVariable('--mat-sys-outline-variant') || '#555';
-    const onSurface = this.themeService.getCssVariable('--mat-sys-on-surface-variant') || '#aaa';
-
-    const pad = { top: 10, right: 10, bottom: 24, left: 35 };
-    const cw = w - pad.left - pad.right;
-    const ch = h - pad.top - pad.bottom;
-
-    // Grid
-    ctx.strokeStyle = outline;
-    ctx.lineWidth = 0.5;
-    for (let i = 0; i <= 4; i++) {
-      const y = pad.top + (ch / 4) * i;
-      ctx.beginPath(); ctx.moveTo(pad.left, y); ctx.lineTo(w - pad.right, y); ctx.stroke();
-      ctx.fillStyle = onSurface;
-      ctx.font = '9px "JetBrains Mono", monospace';
-      ctx.textAlign = 'right';
-      ctx.fillText(((100 * (4 - i)) / 4).toFixed(0) + '%', pad.left - 4, y + 3);
-    }
-
-    // X-axis labels
-    ctx.fillStyle = onSurface;
-    ctx.font = '9px Inter, sans-serif';
-    ctx.textAlign = 'center';
-    for (let d = 0; d <= 30; d += 5) {
-      const x = pad.left + (d / 30) * cw;
-      ctx.fillText(d + 'd', x, h - 4);
-    }
-
-    // Raw Ebbinghaus curve (red, dashed)
-    ctx.beginPath();
-    ctx.setLineDash([4, 3]);
-    ctx.strokeStyle = error;
-    ctx.lineWidth = 1.5;
-    ctx.globalAlpha = 0.6;
-    for (let i = 0; i < curve.length; i++) {
-      const x = pad.left + (curve[i].ageDays / 30) * cw;
-      const y = pad.top + ch - curve[i].rawDecay * ch;
-      if (i === 0) ctx.moveTo(x, y); else ctx.lineTo(x, y);
-    }
-    ctx.stroke();
-    ctx.setLineDash([]);
-    ctx.globalAlpha = 1;
-
-    // LTP reconsolidation curve (primary, solid)
-    ctx.beginPath();
-    ctx.strokeStyle = primary;
-    ctx.lineWidth = 2;
-    for (let i = 0; i < curve.length; i++) {
-      const x = pad.left + (curve[i].ageDays / 30) * cw;
-      const y = pad.top + ch - curve[i].ltpDecay * ch;
-      if (i === 0) ctx.moveTo(x, y); else ctx.lineTo(x, y);
-    }
-    ctx.stroke();
-
-    // Fill under LTP curve
-    ctx.lineTo(pad.left + cw, pad.top + ch);
-    ctx.lineTo(pad.left, pad.top + ch);
-    ctx.closePath();
-    ctx.fillStyle = primary;
-    ctx.globalAlpha = 0.08;
-    ctx.fill();
-    ctx.globalAlpha = 1;
-
-    // Legend
-    ctx.setLineDash([4, 3]);
-    ctx.strokeStyle = error; ctx.lineWidth = 1.5; ctx.globalAlpha = 0.6;
-    ctx.beginPath(); ctx.moveTo(pad.left, h - 8); ctx.lineTo(pad.left + 15, h - 8); ctx.stroke();
-    ctx.setLineDash([]);
-    ctx.globalAlpha = 1;
-    ctx.fillStyle = onSurface; ctx.font = '9px Inter, sans-serif'; ctx.textAlign = 'left';
-    ctx.fillText('Ebbinghaus', pad.left + 18, h - 5);
-
-    ctx.strokeStyle = primary; ctx.lineWidth = 2;
-    ctx.beginPath(); ctx.moveTo(pad.left + 80, h - 8); ctx.lineTo(pad.left + 95, h - 8); ctx.stroke();
-    ctx.fillText('+ LTP Reconsolidation', pad.left + 98, h - 5);
-  }
-}
diff --git a/spector-cortex/src/app/features/habituation-meter/habituation-meter.component.html b/spector-cortex/src/app/features/habituation-meter/habituation-meter.component.html
deleted file mode 100644
index bca35ef..0000000
--- a/spector-cortex/src/app/features/habituation-meter/habituation-meter.component.html
+++ /dev/null
@@ -1,44 +0,0 @@
-<div class="habituation-container">
-  @if (state.habituation(); as hab) {
-    <!-- Gauges -->
-    <div class="gauge-row">
-      <div class="gauge" matTooltip="Inhibition of Return — suppresses recently recalled memories">
-        <div class="gauge-label">IoR</div>
-        <div class="gauge-bar-track">
-          <div class="gauge-bar ior-bar" [style.width.%]="hab.inhibitionOfReturn * 100"></div>
-        </div>
-        <span class="gauge-value cortex-mono">{{ (hab.inhibitionOfReturn * 100) | number:'1.0-0' }}%</span>
-      </div>
-
-      <div class="gauge" matTooltip="Semantic Satiation — repeated recall reduces salience">
-        <div class="gauge-label">Satiation</div>
-        <div class="gauge-bar-track">
-          <div class="gauge-bar satiation-bar" [style.width.%]="hab.semanticSatiation * 100"></div>
-        </div>
-        <span class="gauge-value cortex-mono">{{ (hab.semanticSatiation * 100) | number:'1.0-0' }}%</span>
-      </div>
-
-      <div class="gauge" matTooltip="Average habituation penalty applied to scores">
-        <div class="gauge-label">Penalty</div>
-        <div class="gauge-bar-track">
-          <div class="gauge-bar penalty-bar" [style.width.%]="hab.habituationPenalty * 100"></div>
-        </div>
-        <span class="gauge-value cortex-mono">{{ (hab.habituationPenalty * 100) | number:'1.0-0' }}%</span>
-      </div>
-    </div>
-
-    <!-- Stats -->
-    <div class="stats-row">
-      <div class="stat">
-        <mat-icon class="stat-icon">block</mat-icon>
-        <span class="stat-value cortex-mono">{{ hab.activeSuppressions }}</span>
-        <span class="stat-label">Suppressed</span>
-      </div>
-      <div class="stat">
-        <mat-icon class="stat-icon">cached</mat-icon>
-        <span class="stat-value cortex-mono">{{ hab.satiationCacheSize }}</span>
-        <span class="stat-label">Cache</span>
-      </div>
-    </div>
-  }
-</div>
diff --git a/spector-cortex/src/app/features/habituation-meter/habituation-meter.component.scss b/spector-cortex/src/app/features/habituation-meter/habituation-meter.component.scss
deleted file mode 100644
index 3d7ef40..0000000
--- a/spector-cortex/src/app/features/habituation-meter/habituation-meter.component.scss
+++ /dev/null
@@ -1,28 +0,0 @@
-:host { display: block; flex: 1; min-height: 0; }
-.habituation-container { padding: 12px 16px; display: flex; flex-direction: column; gap: 10px; }
-.gauge-row { display: flex; flex-direction: column; gap: 6px; }
-.gauge {
-  display: grid; grid-template-columns: 60px 1fr 40px; align-items: center; gap: 8px;
-}
-.gauge-label {
-  font-size: 10px; font-weight: 500; color: var(--mat-sys-on-surface-variant); text-transform: uppercase; letter-spacing: 0.04em;
-}
-.gauge-bar-track {
-  height: 10px; border-radius: 5px; background: var(--mat-sys-surface-container-highest); overflow: hidden;
-}
-.gauge-bar {
-  height: 100%; border-radius: 5px; transition: width 0.6s cubic-bezier(0.4, 0, 0.2, 1);
-}
-.ior-bar { background: var(--mat-sys-tertiary); }
-.satiation-bar { background: var(--mat-sys-secondary); }
-.penalty-bar { background: var(--mat-sys-error); }
-.gauge-value { font-size: 10px; font-weight: 600; color: var(--mat-sys-on-surface); text-align: right; }
-.stats-row {
-  display: flex; gap: 16px; padding-top: 6px; border-top: 1px solid var(--mat-sys-outline-variant);
-}
-.stat {
-  display: flex; align-items: center; gap: 4px;
-}
-.stat-icon { font-size: 14px; width: 14px; height: 14px; color: var(--mat-sys-on-surface-variant); }
-.stat-value { font-size: 13px; font-weight: 700; color: var(--mat-sys-on-surface); }
-.stat-label { font-size: 9px; color: var(--mat-sys-on-surface-variant); text-transform: uppercase; letter-spacing: 0.04em; }
diff --git a/spector-cortex/src/app/features/habituation-meter/habituation-meter.component.ts b/spector-cortex/src/app/features/habituation-meter/habituation-meter.component.ts
deleted file mode 100644
index b2f4598..0000000
--- a/spector-cortex/src/app/features/habituation-meter/habituation-meter.component.ts
+++ /dev/null
@@ -1,15 +0,0 @@
-import { Component, inject } from '@angular/core';
-import { DecimalPipe } from '@angular/common';
-import { MatIconModule } from '@angular/material/icon';
-import { MatTooltipModule } from '@angular/material/tooltip';
-import { CortexStateService } from '../../core/services/cortex-state.service';
-
-@Component({
-  selector: 'cortex-habituation-meter',
-  imports: [DecimalPipe, MatIconModule, MatTooltipModule],
-  templateUrl: './habituation-meter.component.html',
-  styleUrl: './habituation-meter.component.scss',
-})
-export class HabituationMeterComponent {
-  protected readonly state = inject(CortexStateService);
-}
diff --git a/spector-cortex/src/app/features/header/header.component.html b/spector-cortex/src/app/features/header/header.component.html
deleted file mode 100644
index 8df8179..0000000
--- a/spector-cortex/src/app/features/header/header.component.html
+++ /dev/null
@@ -1,61 +0,0 @@
-<mat-toolbar class="cortex-toolbar">
-  <!-- Brand -->
-  <div class="brand">
-    <mat-icon class="brand-icon">hub</mat-icon>
-    <span class="brand-name">Spector Cortex</span>
-    <span class="brand-badge">Neural Dashboard</span>
-  </div>
-
-  <div class="spacer"></div>
-
-  <!-- Connection Status -->
-  <div class="status-group">
-    <div class="status-indicator"
-         [class.connected]="state.connectionStatus() === 'connected'"
-         [class.reconnecting]="state.connectionStatus() === 'reconnecting'"
-         [class.disconnected]="state.connectionStatus() === 'disconnected'"
-         [matTooltip]="'Status: ' + state.connectionStatus()">
-      <span class="status-dot"></span>
-      <span class="status-ring"></span>
-    </div>
-    <span class="status-label">{{ state.connectionStatus() }}</span>
-  </div>
-
-  <!-- Active Profile -->
-  @if (state.activeProfile(); as profile) {
-    <mat-chip-set class="profile-chip-set">
-      <mat-chip class="profile-chip" highlighted
-                [matTooltip]="profileParams[profile].description">
-        <mat-icon matChipAvatar>psychology</mat-icon>
-        {{ profileParams[profile].label }}
-      </mat-chip>
-    </mat-chip-set>
-  }
-
-  <!-- Latency -->
-  @if (state.currentQueryTrace(); as trace) {
-    <div class="metric-badge" matTooltip="Last query latency">
-      <mat-icon>speed</mat-icon>
-      <span class="metric-value cortex-mono">{{ state.latestLatencyMs() }}ms</span>
-    </div>
-  }
-
-  <!-- Node Selector -->
-  <mat-form-field appearance="outline" class="node-select">
-    <mat-select [value]="state.selectedNode()"
-                (selectionChange)="state.selectedNode.set($event.value)">
-      <mat-option value="local">Local Node</mat-option>
-      <mat-option value="cluster">Cluster View</mat-option>
-      <mat-option value="node-1">node-1</mat-option>
-      <mat-option value="node-2">node-2</mat-option>
-      <mat-option value="node-3">node-3</mat-option>
-    </mat-select>
-  </mat-form-field>
-
-  <!-- Theme Toggle -->
-  <button mat-icon-button
-          (click)="theme.toggle()"
-          [matTooltip]="'Switch to ' + (theme.isDark() ? 'light' : 'dark') + ' theme'">
-    <mat-icon>{{ theme.themeIcon() }}</mat-icon>
-  </button>
-</mat-toolbar>
diff --git a/spector-cortex/src/app/features/header/header.component.scss b/spector-cortex/src/app/features/header/header.component.scss
deleted file mode 100644
index b6919cd..0000000
--- a/spector-cortex/src/app/features/header/header.component.scss
+++ /dev/null
@@ -1,166 +0,0 @@
-:host {
-  display: block;
-}
-
-.cortex-toolbar {
-  background: var(--mat-sys-surface-container);
-  border-bottom: 1px solid var(--mat-sys-outline-variant);
-  padding: 0 16px;
-  gap: 12px;
-  height: 56px;
-}
-
-// ── Brand ────────────────────────────────────────────────────────────
-.brand {
-  display: flex;
-  align-items: center;
-  gap: 8px;
-}
-
-.brand-icon {
-  color: var(--mat-sys-primary);
-  font-size: 28px;
-  width: 28px;
-  height: 28px;
-}
-
-.brand-name {
-  font-size: 18px;
-  font-weight: 600;
-  color: var(--mat-sys-on-surface);
-  letter-spacing: -0.02em;
-}
-
-.brand-badge {
-  font-size: 10px;
-  font-weight: 500;
-  text-transform: uppercase;
-  letter-spacing: 0.08em;
-  color: var(--mat-sys-on-tertiary-container);
-  background: var(--mat-sys-tertiary-container);
-  padding: 2px 8px;
-  border-radius: 9999px;
-}
-
-.spacer {
-  flex: 1;
-}
-
-// ── Connection Status ────────────────────────────────────────────────
-.status-group {
-  display: flex;
-  align-items: center;
-  gap: 6px;
-}
-
-.status-indicator {
-  position: relative;
-  width: 12px;
-  height: 12px;
-}
-
-.status-dot {
-  position: absolute;
-  inset: 2px;
-  border-radius: 50%;
-  transition: background-color 0.3s ease;
-}
-
-.status-ring {
-  position: absolute;
-  inset: 0;
-  border-radius: 50%;
-  border: 1.5px solid transparent;
-}
-
-.status-indicator.connected {
-  .status-dot {
-    background-color: #4caf50;
-  }
-  .status-ring {
-    border-color: #4caf50;
-    animation: pulse-ring 2s ease-out infinite;
-  }
-}
-
-.status-indicator.reconnecting {
-  .status-dot {
-    background-color: #ff9800;
-    animation: pulse-glow 1s ease-in-out infinite;
-  }
-  .status-ring {
-    border-color: #ff9800;
-  }
-}
-
-.status-indicator.disconnected {
-  .status-dot {
-    background-color: var(--mat-sys-error);
-  }
-  .status-ring {
-    border-color: var(--mat-sys-error);
-  }
-}
-
-.status-label {
-  font-size: 11px;
-  font-weight: 500;
-  text-transform: uppercase;
-  letter-spacing: 0.05em;
-  color: var(--mat-sys-on-surface-variant);
-}
-
-// ── Profile Chip ─────────────────────────────────────────────────────
-.profile-chip-set {
-  .profile-chip {
-    font-size: 12px;
-    font-weight: 500;
-  }
-}
-
-// ── Metric Badge ─────────────────────────────────────────────────────
-.metric-badge {
-  display: flex;
-  align-items: center;
-  gap: 4px;
-  padding: 4px 10px;
-  border-radius: 9999px;
-  background: var(--mat-sys-surface-container-high);
-  border: 1px solid var(--mat-sys-outline-variant);
-
-  mat-icon {
-    font-size: 16px;
-    width: 16px;
-    height: 16px;
-    color: var(--mat-sys-tertiary);
-  }
-
-  .metric-value {
-    font-size: 12px;
-    font-weight: 600;
-    color: var(--mat-sys-on-surface);
-  }
-}
-
-// ── Node Select ──────────────────────────────────────────────────────
-.node-select {
-  width: 140px;
-  margin: 0;
-
-  ::ng-deep {
-    .mat-mdc-form-field-subscript-wrapper {
-      display: none;
-    }
-    .mdc-text-field--outlined {
-      --mdc-outlined-text-field-container-shape: 9999px;
-    }
-    .mdc-notched-outline__leading,
-    .mdc-notched-outline__notch,
-    .mdc-notched-outline__trailing {
-      border: none !important;
-    }
-    .mat-mdc-select-value-text {
-      font-size: 12px;
-    }
-  }
-}
diff --git a/spector-cortex/src/app/features/header/header.component.ts b/spector-cortex/src/app/features/header/header.component.ts
deleted file mode 100644
index 303d621..0000000
--- a/spector-cortex/src/app/features/header/header.component.ts
+++ /dev/null
@@ -1,32 +0,0 @@
-import { Component, inject } from '@angular/core';
-import { MatToolbarModule } from '@angular/material/toolbar';
-import { MatButtonModule } from '@angular/material/button';
-import { MatIconModule } from '@angular/material/icon';
-import { MatSlideToggleModule } from '@angular/material/slide-toggle';
-import { MatSelectModule } from '@angular/material/select';
-import { MatChipsModule } from '@angular/material/chips';
-import { MatTooltipModule } from '@angular/material/tooltip';
-
-import { ThemeService } from '../../core/services/theme.service';
-import { CortexStateService } from '../../core/services/cortex-state.service';
-import { PROFILE_PARAMS } from '../../core/models/memory-types';
-
-@Component({
-  selector: 'cortex-header',
-  imports: [
-    MatToolbarModule,
-    MatButtonModule,
-    MatIconModule,
-    MatSlideToggleModule,
-    MatSelectModule,
-    MatChipsModule,
-    MatTooltipModule,
-  ],
-  templateUrl: './header.component.html',
-  styleUrl: './header.component.scss',
-})
-export class HeaderComponent {
-  protected readonly theme = inject(ThemeService);
-  protected readonly state = inject(CortexStateService);
-  protected readonly profileParams = PROFILE_PARAMS;
-}
diff --git a/spector-cortex/src/app/features/memory-heatmap/memory-heatmap.component.html b/spector-cortex/src/app/features/memory-heatmap/memory-heatmap.component.html
deleted file mode 100644
index bf8f311..0000000
--- a/spector-cortex/src/app/features/memory-heatmap/memory-heatmap.component.html
+++ /dev/null
@@ -1,53 +0,0 @@
-<div class="heatmap-container">
-  <!-- Segment Rows -->
-  <div class="segments">
-    @for (seg of segments(); track seg.name; let i = $index) {
-      <div class="segment-row" [style.animation-delay]="(i * 60) + 'ms'">
-        <div class="seg-info">
-          <span class="seg-name">{{ seg.name }}</span>
-          <span class="seg-count cortex-mono">{{ seg.count | number }}</span>
-        </div>
-        <div class="seg-bar-track">
-          <div class="seg-bar"
-               [style.width.%]="seg.intensity * 100"
-               [style.background]="getHeatColor(seg.intensity)">
-          </div>
-        </div>
-        <span class="seg-size cortex-mono">{{ seg.sizeLabel }}</span>
-      </div>
-    }
-  </div>
-
-  <!-- JVM Metrics Footer -->
-  @if (jvmMetrics(); as jvm) {
-    <div class="jvm-footer">
-      <div class="jvm-metric">
-        <span class="jvm-label">Heap</span>
-        <div class="jvm-bar-track">
-          <div class="jvm-bar" [style.width.%]="jvm.heapPct"></div>
-        </div>
-        <span class="jvm-value cortex-mono">{{ jvm.heapUsed }} / {{ jvm.heapMax }}</span>
-      </div>
-      <div class="jvm-stats">
-        <span class="jvm-stat">
-          <span class="jvm-stat-label">Off-heap</span>
-          <span class="jvm-stat-value cortex-mono">{{ jvm.offHeap }}</span>
-        </span>
-        <span class="jvm-stat">
-          <span class="jvm-stat-label">Pinned</span>
-          <span class="jvm-stat-value cortex-mono">{{ jvm.pinned }}</span>
-        </span>
-        <span class="jvm-stat">
-          <span class="jvm-stat-label">Soft PF</span>
-          <span class="jvm-stat-value cortex-mono">{{ jvm.softFaults | number }}</span>
-        </span>
-        <span class="jvm-stat">
-          <span class="jvm-stat-label">Hard PF</span>
-          <span class="jvm-stat-value cortex-mono" [class.danger]="jvm.hardFaults > 10">
-            {{ jvm.hardFaults }}
-          </span>
-        </span>
-      </div>
-    </div>
-  }
-</div>
diff --git a/spector-cortex/src/app/features/memory-heatmap/memory-heatmap.component.scss b/spector-cortex/src/app/features/memory-heatmap/memory-heatmap.component.scss
deleted file mode 100644
index c0ff40f..0000000
--- a/spector-cortex/src/app/features/memory-heatmap/memory-heatmap.component.scss
+++ /dev/null
@@ -1,144 +0,0 @@
-:host {
-  display: block;
-  flex: 1;
-  min-height: 0;
-  overflow: auto;
-}
-
-.heatmap-container {
-  padding: 8px 12px;
-  display: flex;
-  flex-direction: column;
-  gap: 4px;
-  height: 100%;
-}
-
-// ── Segment Rows ─────────────────────────────────────────────────────
-.segments {
-  flex: 1;
-  display: flex;
-  flex-direction: column;
-  gap: 3px;
-}
-
-.segment-row {
-  display: grid;
-  grid-template-columns: 130px 1fr 70px;
-  align-items: center;
-  gap: 8px;
-  animation: fade-in-up 0.3s ease both;
-}
-
-.seg-info {
-  display: flex;
-  justify-content: space-between;
-  gap: 4px;
-}
-
-.seg-name {
-  font-size: 10px;
-  color: var(--mat-sys-on-surface-variant);
-  white-space: nowrap;
-  overflow: hidden;
-  text-overflow: ellipsis;
-}
-
-.seg-count {
-  font-size: 10px;
-  font-weight: 600;
-  color: var(--mat-sys-on-surface);
-}
-
-.seg-bar-track {
-  height: 14px;
-  border-radius: 3px;
-  background: var(--mat-sys-surface-container-highest);
-  overflow: hidden;
-}
-
-.seg-bar {
-  height: 100%;
-  border-radius: 3px;
-  transition: width 0.8s cubic-bezier(0.4, 0, 0.2, 1),
-              background 0.8s ease;
-  min-width: 2px;
-}
-
-.seg-size {
-  font-size: 9px;
-  color: var(--mat-sys-on-surface-variant);
-  text-align: right;
-}
-
-// ── JVM Footer ───────────────────────────────────────────────────────
-.jvm-footer {
-  padding-top: 6px;
-  border-top: 1px solid var(--mat-sys-outline-variant);
-  display: flex;
-  flex-direction: column;
-  gap: 6px;
-}
-
-.jvm-metric {
-  display: grid;
-  grid-template-columns: 40px 1fr auto;
-  align-items: center;
-  gap: 8px;
-}
-
-.jvm-label {
-  font-size: 9px;
-  font-weight: 600;
-  text-transform: uppercase;
-  letter-spacing: 0.06em;
-  color: var(--mat-sys-on-surface-variant);
-}
-
-.jvm-bar-track {
-  height: 6px;
-  border-radius: 3px;
-  background: var(--mat-sys-surface-container-highest);
-  overflow: hidden;
-}
-
-.jvm-bar {
-  height: 100%;
-  border-radius: 3px;
-  background: var(--mat-sys-primary);
-  transition: width 0.6s ease;
-}
-
-.jvm-value {
-  font-size: 10px;
-  color: var(--mat-sys-on-surface-variant);
-}
-
-.jvm-stats {
-  display: flex;
-  gap: 12px;
-  flex-wrap: wrap;
-}
-
-.jvm-stat {
-  display: flex;
-  flex-direction: column;
-  gap: 1px;
-}
-
-.jvm-stat-label {
-  font-size: 8px;
-  font-weight: 500;
-  text-transform: uppercase;
-  letter-spacing: 0.06em;
-  color: var(--mat-sys-on-surface-variant);
-}
-
-.jvm-stat-value {
-  font-size: 11px;
-  font-weight: 600;
-  color: var(--mat-sys-on-surface);
-
-  &.danger {
-    color: var(--mat-sys-error);
-  }
-}
diff --git a/spector-cortex/src/app/features/memory-heatmap/memory-heatmap.component.ts b/spector-cortex/src/app/features/memory-heatmap/memory-heatmap.component.ts
deleted file mode 100644
index aa98392..0000000
--- a/spector-cortex/src/app/features/memory-heatmap/memory-heatmap.component.ts
+++ /dev/null
@@ -1,116 +0,0 @@
-import { Component, inject, computed } from '@angular/core';
-import { DecimalPipe } from '@angular/common';
-import { CortexStateService } from '../../core/services/cortex-state.service';
-
-interface SegmentRow {
-  name: string;
-  tier: string;
-  count: number;
-  sizeLabel: string;
-  intensity: number; // 0-1 heat
-}
-
-@Component({
-  selector: 'cortex-memory-heatmap',
-  imports: [DecimalPipe],
-  templateUrl: './memory-heatmap.component.html',
-  styleUrl: './memory-heatmap.component.scss',
-})
-export class MemoryHeatmapComponent {
-
-  protected readonly state = inject(CortexStateService);
-
-  protected readonly segments = computed<SegmentRow[]>(() => {
-    const diag = this.state.memoryDiag();
-    if (!diag) return [];
-
-    const maxCount = Math.max(
-      diag.workingCount, diag.episodicCount, diag.semanticCount,
-      diag.proceduralCount, 1,
-    );
-
-    return [
-      {
-        name: 'Working Memory', tier: 'WORKING',
-        count: diag.workingCount,
-        sizeLabel: this.formatBytes(diag.workingCount * 164),
-        intensity: Math.min(1, diag.workingCount / 100), // Working is always hot
-      },
-      {
-        name: 'Episodic Memory', tier: 'EPISODIC',
-        count: diag.episodicCount,
-        sizeLabel: this.formatBytes(diag.episodicCount * 164),
-        intensity: diag.episodicCount / maxCount * 0.7,
-      },
-      {
-        name: 'Semantic Memory', tier: 'SEMANTIC',
-        count: diag.semanticCount,
-        sizeLabel: this.formatBytes(diag.semanticCount * 36), // header slab only
-        intensity: diag.semanticCount / maxCount * 0.5,
-      },
-      {
-        name: 'Procedural Memory', tier: 'PROCEDURAL',
-        count: diag.proceduralCount,
-        sizeLabel: this.formatBytes(diag.proceduralCount * 164),
-        intensity: diag.proceduralCount / maxCount * 0.4,
-      },
-      {
-        name: 'Hebbian Graph', tier: 'GRAPH',
-        count: diag.hebbianEdges,
-        sizeLabel: this.formatBytes(diag.hebbianEdges / 20 * 164), // 164B per node
-        intensity: 0.6 + Math.random() * 0.2,
-      },
-      {
-        name: 'Temporal Chain', tier: 'GRAPH',
-        count: diag.temporalLinks,
-        sizeLabel: this.formatBytes(diag.temporalLinks * 16),
-        intensity: 0.3 + Math.random() * 0.2,
-      },
-      {
-        name: 'Entity Graph', tier: 'GRAPH',
-        count: diag.entityNodes,
-        sizeLabel: this.formatBytes(diag.entityNodes * 64 + diag.entityEdges * 12),
-        intensity: 0.4 + Math.random() * 0.2,
-      },
-      {
-        name: 'CoActivation Pairs', tier: 'STDP',
-        count: diag.coActivationPairs,
-        sizeLabel: this.formatBytes(diag.coActivationPairs * 32),
-        intensity: 0.2 + Math.random() * 0.15,
-      },
-      {
-        name: 'STDP Edges', tier: 'STDP',
-        count: diag.stdpEdges,
-        sizeLabel: this.formatBytes(diag.stdpEdges * 40),
-        intensity: 0.15 + Math.random() * 0.15,
-      },
-    ];
-  });
-
-  protected readonly jvmMetrics = computed(() => {
-    const diag = this.state.memoryDiag();
-    if (!diag) return null;
-    return {
-      heapUsed: this.formatBytes(diag.jvmHeapUsed),
-      heapMax: this.formatBytes(diag.jvmHeapMax),
-      heapPct: ((diag.jvmHeapUsed / diag.jvmHeapMax) * 100).toFixed(1),
-      offHeap: this.formatBytes(diag.offHeapBytes),
-      pinned: this.formatBytes(diag.pinnedBytes),
-      softFaults: diag.softPageFaults,
-      hardFaults: diag.hardPageFaults,
-    };
-  });
-
-  protected getHeatColor(intensity: number): string {
-    // Interpolate from cool (surface) to hot (primary)
-    const pct = Math.round(Math.max(0, Math.min(1, intensity)) * 100);
-    return `color-mix(in srgb, var(--mat-sys-primary) ${pct}%, var(--mat-sys-surface-container-highest))`;
-  }
-
-  private formatBytes(bytes: number): string {
-    if (bytes >= 1_073_741_824) return (bytes / 1_073_741_824).toFixed(1) + ' GB';
-    if (bytes >= 1_048_576) return (bytes / 1_048_576).toFixed(1) + ' MB';
-    if (bytes >= 1024) return (bytes / 1024).toFixed(1) + ' KB';
-    return bytes + ' B';
-  }
-}
diff --git a/spector-cortex/src/app/features/metrics-chart/metrics-chart.component.html b/spector-cortex/src/app/features/metrics-chart/metrics-chart.component.html
deleted file mode 100644
index 868acf6..0000000
--- a/spector-cortex/src/app/features/metrics-chart/metrics-chart.component.html
+++ /dev/null
@@ -1 +0,0 @@
-<div class="chart-wrapper"><canvas #chartCanvas></canvas></div>
diff --git a/spector-cortex/src/app/features/metrics-chart/metrics-chart.component.scss b/spector-cortex/src/app/features/metrics-chart/metrics-chart.component.scss
deleted file mode 100644
index 149796a..0000000
--- a/spector-cortex/src/app/features/metrics-chart/metrics-chart.component.scss
+++ /dev/null
@@ -1,5 +0,0 @@
-:host { display: block; flex: 1; min-height: 0; }
-.chart-wrapper {
-  width: 100%; height: 100%; padding: 4px 8px;
-  canvas { display: block; width: 100%; height: 100%; }
-}
diff --git a/spector-cortex/src/app/features/metrics-chart/metrics-chart.component.ts b/spector-cortex/src/app/features/metrics-chart/metrics-chart.component.ts
deleted file mode 100644
index a844eed..0000000
--- a/spector-cortex/src/app/features/metrics-chart/metrics-chart.component.ts
+++ /dev/null
@@ -1,133 +0,0 @@
-import {
-  Component, ElementRef, ViewChild, AfterViewInit, OnDestroy, inject, effect, PLATFORM_ID,
-} from '@angular/core';
-import { isPlatformBrowser } from '@angular/common';
-import { CortexStateService } from '../../core/services/cortex-state.service';
-import { ThemeService } from '../../core/services/theme.service';
-
-@Component({
-  selector: 'cortex-metrics-chart',
-  templateUrl: './metrics-chart.component.html',
-  styleUrl: './metrics-chart.component.scss',
-})
-export class MetricsChartComponent implements AfterViewInit, OnDestroy {
-
-  @ViewChild('chartCanvas', { static: true })
-  private canvasRef!: ElementRef<HTMLCanvasElement>;
-
-  private readonly state = inject(CortexStateService);
-  private readonly themeService = inject(ThemeService);
-  private readonly platformId = inject(PLATFORM_ID);
-
-  private ctx!: CanvasRenderingContext2D;
-  private animationId = 0;
-
-  ngAfterViewInit(): void {
-    if (!isPlatformBrowser(this.platformId)) return;
-    this.ctx = this.canvasRef.nativeElement.getContext('2d')!;
-    const observer = new ResizeObserver(() => this.resizeCanvas());
-    observer.observe(this.canvasRef.nativeElement.parentElement!);
-    this.resizeCanvas();
-    this.draw();
-
-    effect(() => {
-      this.state.metricsHistory();
-      // Redraw on new metrics data
-    });
-  }
-
-  ngOnDestroy(): void {
-    cancelAnimationFrame(this.animationId);
-  }
-
-  private resizeCanvas(): void {
-    const parent = this.canvasRef.nativeElement.parentElement!;
-    this.canvasRef.nativeElement.width = parent.clientWidth;
-    this.canvasRef.nativeElement.height = parent.clientHeight;
-  }
-
-  private draw(): void {
-    this.animationId = requestAnimationFrame(() => this.draw());
-
-    const canvas = this.canvasRef.nativeElement;
-    const ctx = this.ctx;
-    const w = canvas.width;
-    const h = canvas.height;
-    ctx.clearRect(0, 0, w, h);
-
-    const history = this.state.metricsHistory();
-    if (history.length < 2) return;
-
-    const primary = this.themeService.getCssVariable('--mat-sys-primary') || '#bb86fc';
-    const tertiary = this.themeService.getCssVariable('--mat-sys-tertiary') || '#03dac6';
-    const secondary = this.themeService.getCssVariable('--mat-sys-secondary') || '#c4b5fd';
-    const error = this.themeService.getCssVariable('--mat-sys-error') || '#f44336';
-    const outline = this.themeService.getCssVariable('--mat-sys-outline-variant') || '#555';
-    const onSurface = this.themeService.getCssVariable('--mat-sys-on-surface-variant') || '#aaa';
-
-    const padding = { top: 10, right: 10, bottom: 20, left: 35 };
-    const chartW = w - padding.left - padding.right;
-    const chartH = h - padding.top - padding.bottom;
-
-    // Find max across all series
-    let maxVal = 1;
-    for (const p of history) {
-      maxVal = Math.max(maxVal, p.recallRate, p.rememberRate, p.reinforceRate, p.forgetRate);
-    }
-    maxVal *= 1.1;
-
-    // Grid lines
-    ctx.strokeStyle = outline;
-    ctx.lineWidth = 0.5;
-    for (let i = 0; i <= 4; i++) {
-      const y = padding.top + (chartH / 4) * i;
-      ctx.beginPath();
-      ctx.moveTo(padding.left, y);
-      ctx.lineTo(w - padding.right, y);
-      ctx.stroke();
-
-      ctx.fillStyle = onSurface;
-      ctx.font = '9px "JetBrains Mono", monospace';
-      ctx.textAlign = 'right';
-      ctx.fillText(((maxVal * (4 - i)) / 4).toFixed(1), padding.left - 4, y + 3);
-    }
-
-    // Draw series
-    const series = [
-      { key: 'recallRate' as const, color: primary, label: 'Recall' },
-      { key: 'rememberRate' as const, color: tertiary, label: 'Remember' },
-      { key: 'reinforceRate' as const, color: secondary, label: 'Reinforce' },
-      { key: 'forgetRate' as const, color: error, label: 'Forget' },
-    ];
-
-    for (const s of series) {
-      ctx.beginPath();
-      ctx.strokeStyle = s.color;
-      ctx.lineWidth = 1.5;
-      ctx.globalAlpha = 0.8;
-
-      for (let i = 0; i < history.length; i++) {
-        const x = padding.left + (i / (history.length - 1)) * chartW;
-        const y = padding.top + chartH - (history[i][s.key] / maxVal) * chartH;
-        if (i === 0) ctx.moveTo(x, y);
-        else ctx.lineTo(x, y);
-      }
-      ctx.stroke();
-      ctx.globalAlpha = 1;
-    }
-
-    // Legend
-    let legendX = padding.left;
-    for (const s of series) {
-      ctx.fillStyle = s.color;
-      ctx.beginPath();
-      ctx.arc(legendX + 4, h - 6, 3, 0, Math.PI * 2);
-      ctx.fill();
-      ctx.fillStyle = onSurface;
-      ctx.font = '9px Inter, sans-serif';
-      ctx.textAlign = 'left';
-      ctx.fillText(s.label, legendX + 10, h - 3);
-      legendX += ctx.measureText(s.label).width + 20;
-    }
-  }
-}
diff --git a/spector-cortex/src/app/features/neural-graph/neural-graph.component.html b/spector-cortex/src/app/features/neural-graph/neural-graph.component.html
deleted file mode 100644
index 69019cb..0000000
--- a/spector-cortex/src/app/features/neural-graph/neural-graph.component.html
+++ /dev/null
@@ -1,50 +0,0 @@
-<div class="graph-wrapper">
-  <div #canvasContainer
-       class="graph-canvas"
-       (mousemove)="onMouseMove($event)">
-  </div>
-
-  <!-- Layer Toggle Controls -->
-  <div class="layer-controls">
-    <label class="layer-toggle">
-      <mat-checkbox
-        [checked]="state.graphLayers().hebbian"
-        (change)="state.toggleGraphLayer('hebbian')"
-        color="primary">
-      </mat-checkbox>
-      <span class="layer-label hebbian-label">Hebbian</span>
-    </label>
-    <label class="layer-toggle">
-      <mat-checkbox
-        [checked]="state.graphLayers().temporal"
-        (change)="state.toggleGraphLayer('temporal')"
-        color="primary">
-      </mat-checkbox>
-      <span class="layer-label temporal-label">Temporal</span>
-    </label>
-    <label class="layer-toggle">
-      <mat-checkbox
-        [checked]="state.graphLayers().entity"
-        (change)="state.toggleGraphLayer('entity')"
-        color="primary">
-      </mat-checkbox>
-      <span class="layer-label entity-label">Entity</span>
-    </label>
-    <label class="layer-toggle">
-      <mat-checkbox
-        [checked]="state.graphLayers().particles"
-        (change)="state.toggleGraphLayer('particles')"
-        color="primary">
-      </mat-checkbox>
-      <span class="layer-label">Particles</span>
-    </label>
-  </div>
-
-  <!-- Legend -->
-  <div class="legend">
-    <div class="legend-item"><span class="legend-dot" style="background: #ffb74d"></span>Working</div>
-    <div class="legend-item"><span class="legend-dot" style="background: #66bb6a"></span>Episodic</div>
-    <div class="legend-item"><span class="legend-dot" style="background: #42a5f5"></span>Semantic</div>
-    <div class="legend-item"><span class="legend-dot" style="background: #ab47bc"></span>Procedural</div>
-  </div>
-</div>
diff --git a/spector-cortex/src/app/features/neural-graph/neural-graph.component.scss b/spector-cortex/src/app/features/neural-graph/neural-graph.component.scss
deleted file mode 100644
index 2983f81..0000000
--- a/spector-cortex/src/app/features/neural-graph/neural-graph.component.scss
+++ /dev/null
@@ -1,83 +0,0 @@
-:host {
-  display: block;
-  flex: 1;
-  min-height: 0;
-}
-
-.graph-wrapper {
-  position: relative;
-  width: 100%;
-  height: 100%;
-}
-
-.graph-canvas {
-  width: 100%;
-  height: 100%;
-  min-height: 200px;
-  cursor: crosshair;
-
-  canvas {
-    display: block;
-    border-radius: 0 0 16px 16px;
-  }
-}
-
-// ── Layer Controls ───────────────────────────────────────────────────
-.layer-controls {
-  position: absolute;
-  top: 8px;
-  left: 8px;
-  display: flex;
-  flex-direction: column;
-  gap: 2px;
-  padding: 6px 8px;
-  border-radius: 8px;
-  background: color-mix(in srgb, var(--mat-sys-surface-container) 85%, transparent);
-  backdrop-filter: blur(8px);
-  border: 1px solid var(--mat-sys-outline-variant);
-}
-
-.layer-toggle {
-  display: flex;
-  align-items: center;
-  gap: 4px;
-  cursor: pointer;
-}
-
-.layer-label {
-  font-size: 10px;
-  font-weight: 500;
-  color: var(--mat-sys-on-surface-variant);
-
-  &.hebbian-label { color: #fff; }
-  &.temporal-label { color: #00bcd4; }
-  &.entity-label { color: #ffc107; }
-}
-
-// ── Legend ────────────────────────────────────────────────────────────
-.legend {
-  position: absolute;
-  bottom: 8px;
-  right: 8px;
-  display: flex;
-  gap: 10px;
-  padding: 4px 10px;
-  border-radius: 8px;
-  background: color-mix(in srgb, var(--mat-sys-surface-container) 85%, transparent);
-  backdrop-filter: blur(8px);
-  border: 1px solid var(--mat-sys-outline-variant);
-}
-
-.legend-item {
-  display: flex;
-  align-items: center;
-  gap: 4px;
-  font-size: 10px;
-  color: var(--mat-sys-on-surface-variant);
-}
-
-.legend-dot {
-  width: 8px;
-  height: 8px;
-  border-radius: 50%;
-}
diff --git a/spector-cortex/src/app/features/neural-graph/neural-graph.component.ts b/spector-cortex/src/app/features/neural-graph/neural-graph.component.ts
deleted file mode 100644
index a044880..0000000
--- a/spector-cortex/src/app/features/neural-graph/neural-graph.component.ts
+++ /dev/null
@@ -1,517 +0,0 @@
-import {
-  Component, ElementRef, ViewChild, AfterViewInit, OnDestroy, inject, effect, PLATFORM_ID,
-} from '@angular/core';
-import { isPlatformBrowser } from '@angular/common';
-import { MatCheckboxModule } from '@angular/material/checkbox';
-import { MatTooltipModule } from '@angular/material/tooltip';
-import { FormsModule } from '@angular/forms';
-import { CortexStateService } from '../../core/services/cortex-state.service';
-import { ThemeService } from '../../core/services/theme.service';
-import { PROFILE_PARAMS, CognitiveProfile } from '../../core/models/memory-types';
-import * as THREE from 'three';
-
-const MAX_NODES = 200;
-const TIER_COLORS: Record<string, number> = {
-  WORKING: 0xffb74d,
-  EPISODIC: 0x66bb6a,
-  SEMANTIC: 0x42a5f5,
-  PROCEDURAL: 0xab47bc,
-};
-
-const EDGE_COLORS = {
-  hebbian: 0xffffff,
-  temporal: 0x00bcd4,
-  entity: 0xffc107,
-};
-
-interface GraphNode {
-  position: THREE.Vector3;
-  velocity: THREE.Vector3;
-  tier: string;
-  activation: number;
-  targetActivation: number;
-  mesh: THREE.Mesh;
-  glowMesh: THREE.Mesh;
-  label: string;
-}
-
-interface GraphEdge {
-  line: THREE.Line;
-  type: 'hebbian' | 'temporal' | 'entity';
-  from: number;
-  to: number;
-  activation: number;
-}
-
-interface Particle {
-  mesh: THREE.Mesh;
-  trailMesh: THREE.Mesh | null;
-  edgeIndex: number;
-  progress: number;
-  speed: number;
-  alive: boolean;
-  color: number;
-}
-
-@Component({
-  selector: 'cortex-neural-graph',
-  imports: [MatCheckboxModule, MatTooltipModule, FormsModule],
-  templateUrl: './neural-graph.component.html',
-  styleUrl: './neural-graph.component.scss',
-})
-export class NeuralGraphComponent implements AfterViewInit, OnDestroy {
-
-  @ViewChild('canvasContainer', { static: true })
-  private canvasContainer!: ElementRef<HTMLDivElement>;
-
-  protected readonly state = inject(CortexStateService);
-  private readonly themeService = inject(ThemeService);
-  private readonly platformId = inject(PLATFORM_ID);
-
-  private scene!: THREE.Scene;
-  private camera!: THREE.PerspectiveCamera;
-  private renderer!: THREE.WebGLRenderer;
-  private nodes: GraphNode[] = [];
-  private graphEdges: GraphEdge[] = [];
-  private particles: Particle[] = [];
-  private queryTrailMesh: THREE.Mesh | null = null;
-  private queryTrailTarget: THREE.Vector3 | null = null;
-  private ambientParticleTimer = 0;
-  private animationId = 0;
-  private mouseX = 0;
-  private mouseY = 0;
-  private clock = new THREE.Clock();
-
-  // Profile color tint
-  private profileHue = 0;
-
-  ngAfterViewInit(): void {
-    if (!isPlatformBrowser(this.platformId)) return;
-    this.initScene();
-    this.generateNodes();
-    this.generateEdges();
-    this.createQueryTrail();
-    this.animate();
-
-    // React to query traces — pulse nodes + launch traversal particle
-    effect(() => {
-      const trace = this.state.currentQueryTrace();
-      if (trace) {
-        this.pulseRandomNodes(trace.finalTopK + trace.hebbianActivated);
-        this.launchTraversalParticles(trace.hebbianActivated + trace.temporalLinked + trace.entityDiscovered);
-      }
-    });
-
-    // React to graph pulses — pulse edges by type
-    effect(() => {
-      const pulses = this.state.graphPulses();
-      if (pulses.length > 0) {
-        const latest = pulses[0];
-        this.pulseEdgesByType(latest.graphType);
-      }
-    });
-
-    // React to reflect cycles — dim all edges (consolidation)
-    effect(() => {
-      const reflect = this.state.lastReflect();
-      if (reflect) {
-        this.consolidationAnimation(reflect.hebbianEdgesRemoved);
-      }
-    });
-
-    // React to profile changes — shift color tint
-    effect(() => {
-      const profile = this.state.activeProfile();
-      this.applyProfileVisuals(profile);
-    });
-  }
-
-  ngOnDestroy(): void {
-    cancelAnimationFrame(this.animationId);
-    this.renderer?.dispose();
-  }
-
-  onMouseMove(event: MouseEvent): void {
-    const rect = this.canvasContainer.nativeElement.getBoundingClientRect();
-    this.mouseX = ((event.clientX - rect.left) / rect.width) * 2 - 1;
-    this.mouseY = -((event.clientY - rect.top) / rect.height) * 2 + 1;
-  }
-
-  private initScene(): void {
-    const container = this.canvasContainer.nativeElement;
-    const width = container.clientWidth;
-    const height = container.clientHeight;
-
-    this.scene = new THREE.Scene();
-
-    this.camera = new THREE.PerspectiveCamera(60, width / height, 0.1, 1000);
-    this.camera.position.z = 80;
-
-    this.renderer = new THREE.WebGLRenderer({ antialias: true, alpha: true });
-    this.renderer.setSize(width, height);
-    this.renderer.setPixelRatio(Math.min(window.devicePixelRatio, 2));
-    this.renderer.setClearColor(0x000000, 0);
-    // Enable tone mapping for bloom-like glow
-    this.renderer.toneMapping = THREE.ACESFilmicToneMapping;
-    this.renderer.toneMappingExposure = 1.2;
-    container.appendChild(this.renderer.domElement);
-
-    this.scene.add(new THREE.AmbientLight(0xffffff, 0.4));
-    const pointLight = new THREE.PointLight(0xffffff, 0.8, 200);
-    pointLight.position.copy(this.camera.position);
-    this.scene.add(pointLight);
-
-    const observer = new ResizeObserver(() => {
-      const w = container.clientWidth;
-      const h = container.clientHeight;
-      this.camera.aspect = w / h;
-      this.camera.updateProjectionMatrix();
-      this.renderer.setSize(w, h);
-    });
-    observer.observe(container);
-  }
-
-  private generateNodes(): void {
-    const tiers = Object.keys(TIER_COLORS);
-    const tierWeights = [0.05, 0.35, 0.45, 0.15];
-
-    for (let i = 0; i < MAX_NODES; i++) {
-      let rand = Math.random();
-      let tierIdx = 0;
-      for (let t = 0; t < tierWeights.length; t++) {
-        rand -= tierWeights[t];
-        if (rand <= 0) { tierIdx = t; break; }
-      }
-      const tier = tiers[tierIdx];
-      const color = TIER_COLORS[tier];
-
-      const radius = 15 + tierIdx * 12 + Math.random() * 8;
-      const theta = Math.random() * Math.PI * 2;
-      const phi = Math.acos(2 * Math.random() - 1);
-      const pos = new THREE.Vector3(
-        radius * Math.sin(phi) * Math.cos(theta),
-        radius * Math.sin(phi) * Math.sin(theta),
-        radius * Math.cos(phi),
-      );
-
-      const geometry = new THREE.SphereGeometry(0.4 + Math.random() * 0.3, 12, 12);
-      const material = new THREE.MeshPhongMaterial({
-        color, emissive: color, emissiveIntensity: 0.1,
-        transparent: true, opacity: 0.85,
-      });
-      const mesh = new THREE.Mesh(geometry, material);
-      mesh.position.copy(pos);
-      this.scene.add(mesh);
-
-      const glowGeometry = new THREE.SphereGeometry(1.5, 8, 8);
-      const glowMaterial = new THREE.MeshBasicMaterial({
-        color, transparent: true, opacity: 0,
-      });
-      const glowMesh = new THREE.Mesh(glowGeometry, glowMaterial);
-      glowMesh.position.copy(pos);
-      this.scene.add(glowMesh);
-
-      this.nodes.push({
-        position: pos, velocity: new THREE.Vector3(
-          (Math.random() - 0.5) * 0.015, (Math.random() - 0.5) * 0.015, (Math.random() - 0.5) * 0.015,
-        ),
-        tier, activation: 0, targetActivation: 0, mesh, glowMesh,
-        label: `${tier.toLowerCase()}-${i}`,
-      });
-    }
-  }
-
-  private generateEdges(): void {
-    const types: Array<'hebbian' | 'temporal' | 'entity'> = ['hebbian', 'temporal', 'entity'];
-
-    for (let i = 0; i < this.nodes.length; i++) {
-      let connections = 0;
-      for (let j = i + 1; j < this.nodes.length && connections < 3; j++) {
-        const dist = this.nodes[i].position.distanceTo(this.nodes[j].position);
-        if (dist < 20 && Math.random() > 0.55) {
-          const type = types[Math.floor(Math.random() * types.length)];
-          const color = EDGE_COLORS[type];
-
-          const material = new THREE.LineBasicMaterial({
-            color, transparent: true, opacity: type === 'hebbian' ? 0.08 : 0.06,
-          });
-
-          // For temporal edges, use dashed lines
-          let line: THREE.Line;
-          if (type === 'temporal') {
-            const dashMat = new THREE.LineDashedMaterial({
-              color, transparent: true, opacity: 0.06,
-              dashSize: 1, gapSize: 0.5,
-            });
-            const geometry = new THREE.BufferGeometry().setFromPoints([
-              this.nodes[i].position, this.nodes[j].position,
-            ]);
-            line = new THREE.Line(geometry, dashMat);
-            line.computeLineDistances();
-          } else {
-            const geometry = new THREE.BufferGeometry().setFromPoints([
-              this.nodes[i].position, this.nodes[j].position,
-            ]);
-            line = new THREE.Line(geometry, material);
-          }
-
-          this.scene.add(line);
-          this.graphEdges.push({ line, type, from: i, to: j, activation: 0 });
-          connections++;
-        }
-      }
-    }
-  }
-
-  private createQueryTrail(): void {
-    const geometry = new THREE.SphereGeometry(1.8, 20, 20);
-    const material = new THREE.MeshBasicMaterial({
-      color: 0xbb86fc, transparent: true, opacity: 0,
-    });
-    this.queryTrailMesh = new THREE.Mesh(geometry, material);
-    this.scene.add(this.queryTrailMesh);
-  }
-
-  private pulseRandomNodes(count: number): void {
-    for (const node of this.nodes) {
-      node.targetActivation *= 0.3;
-    }
-    const indices = new Set<number>();
-    while (indices.size < Math.min(count, this.nodes.length)) {
-      indices.add(Math.floor(Math.random() * this.nodes.length));
-    }
-    for (const idx of indices) {
-      this.nodes[idx].targetActivation = 0.7 + Math.random() * 0.3;
-    }
-
-    // Activate query trail at the first activated node
-    if (this.queryTrailMesh && indices.size > 0) {
-      const firstIdx = indices.values().next().value;
-      if (firstIdx !== undefined) {
-        this.queryTrailTarget = this.nodes[firstIdx].position.clone();
-        const mat = this.queryTrailMesh.material as THREE.MeshBasicMaterial;
-        mat.opacity = 0.9;
-        this.queryTrailMesh.scale.setScalar(1);
-        this.queryTrailMesh.position.copy(this.queryTrailTarget);
-      }
-    }
-  }
-
-  private launchTraversalParticles(count: number): void {
-    // Launch a burst of 20-40 particles across random edges
-    const burstSize = Math.max(20, count * 5);
-    for (let i = 0; i < burstSize; i++) {
-      this.spawnParticle(Math.random() * 0.3); // stagger start progress
-    }
-  }
-
-  private spawnParticle(startProgress = 0): void {
-    if (this.graphEdges.length === 0) return;
-    const edgeIndex = Math.floor(Math.random() * this.graphEdges.length);
-    const edge = this.graphEdges[edgeIndex];
-    const color = EDGE_COLORS[edge.type];
-
-    // Main particle sphere — larger and brighter
-    const geometry = new THREE.SphereGeometry(0.8, 8, 8);
-    const material = new THREE.MeshBasicMaterial({
-      color, transparent: true, opacity: 0.95,
-    });
-    const mesh = new THREE.Mesh(geometry, material);
-    this.scene.add(mesh);
-
-    // Trail glow (larger, dimmer sphere behind)
-    const trailGeometry = new THREE.SphereGeometry(2.0, 6, 6);
-    const trailMaterial = new THREE.MeshBasicMaterial({
-      color, transparent: true, opacity: 0.25,
-    });
-    const trailMesh = new THREE.Mesh(trailGeometry, trailMaterial);
-    this.scene.add(trailMesh);
-
-    this.particles.push({
-      mesh, trailMesh, edgeIndex, progress: startProgress,
-      speed: 0.02 + Math.random() * 0.03, alive: true, color,
-    });
-  }
-
-  private pulseEdgesByType(type: 'hebbian' | 'temporal' | 'entity'): void {
-    const layers = this.state.graphLayers();
-    if ((type === 'hebbian' && !layers.hebbian) ||
-        (type === 'temporal' && !layers.temporal) ||
-        (type === 'entity' && !layers.entity)) return;
-
-    for (const edge of this.graphEdges) {
-      if (edge.type === type) {
-        edge.activation = 0.8;
-      }
-    }
-  }
-
-  private consolidationAnimation(removedCount: number): void {
-    // Dim random edges to simulate pruning
-    const toRemove = Math.min(removedCount, Math.floor(this.graphEdges.length * 0.05));
-    for (let i = 0; i < toRemove; i++) {
-      const edge = this.graphEdges[Math.floor(Math.random() * this.graphEdges.length)];
-      const mat = edge.line.material as THREE.LineBasicMaterial;
-      mat.opacity = 0.01; // Nearly invisible — "pruned"
-    }
-  }
-
-  private applyProfileVisuals(profile: CognitiveProfile): void {
-    const params = PROFILE_PARAMS[profile];
-
-    if (profile === CognitiveProfile.HYPERFOCUS) {
-      // Tunnel vision: suppress all but high-activation nodes
-      for (const node of this.nodes) {
-        const mat = node.mesh.material as THREE.MeshPhongMaterial;
-        mat.opacity = node.activation > 0.3 ? 0.95 : 0.15;
-      }
-    } else if (profile === CognitiveProfile.PARANOID_SENTINEL) {
-      // Red shift
-      for (const node of this.nodes) {
-        const mat = node.mesh.material as THREE.MeshPhongMaterial;
-        mat.emissive.setHex(0xff4444);
-      }
-    } else if (profile === CognitiveProfile.DIVERGENT) {
-      // Rainbow shimmer — handled in animate loop via hue shift
-      this.profileHue = 0;
-    } else {
-      // Reset to normal
-      for (const node of this.nodes) {
-        const mat = node.mesh.material as THREE.MeshPhongMaterial;
-        mat.emissive.setHex(TIER_COLORS[node.tier]);
-        mat.opacity = 0.85;
-      }
-    }
-  }
-
-  private animate(): void {
-    this.animationId = requestAnimationFrame(() => this.animate());
-    const delta = this.clock.getDelta();
-    const time = this.clock.getElapsedTime();
-    const layers = this.state.graphLayers();
-
-    // Camera orbit
-    this.camera.position.x = 80 * Math.sin(time * 0.04) + this.mouseX * 15;
-    this.camera.position.y = 25 * Math.sin(time * 0.025) + this.mouseY * 15;
-    this.camera.lookAt(0, 0, 0);
-
-    // Divergent rainbow hue shift
-    const isDivergent = this.state.activeProfile() === CognitiveProfile.DIVERGENT;
-    if (isDivergent) this.profileHue = (this.profileHue + delta * 30) % 360;
-
-    // Animate nodes
-    for (const node of this.nodes) {
-      node.position.add(node.velocity);
-      node.mesh.position.copy(node.position);
-      node.glowMesh.position.copy(node.position);
-
-      if (node.position.length() > 55) {
-        node.velocity.multiplyScalar(-1);
-      }
-
-      node.activation += (node.targetActivation - node.activation) * delta * 3;
-      node.targetActivation *= 0.995;
-
-      const mat = node.mesh.material as THREE.MeshPhongMaterial;
-      mat.emissiveIntensity = 0.1 + node.activation * 1.2;
-
-      if (isDivergent && node.activation > 0.2) {
-        const hue = (this.profileHue + node.position.x * 3) % 360;
-        mat.emissive.setHSL(hue / 360, 0.8, 0.5);
-      }
-
-      const glowMat = node.glowMesh.material as THREE.MeshBasicMaterial;
-      glowMat.opacity = node.activation * 0.35;
-      node.glowMesh.scale.setScalar(1 + node.activation * 2.5);
-    }
-
-    // Animate edges with layer visibility
-    for (const edge of this.graphEdges) {
-      const visible = (edge.type === 'hebbian' && layers.hebbian) ||
-                      (edge.type === 'temporal' && layers.temporal) ||
-                      (edge.type === 'entity' && layers.entity);
-
-      edge.line.visible = visible;
-
-      if (visible) {
-        const mat = edge.line.material as THREE.LineBasicMaterial;
-        const baseOpacity = edge.type === 'hebbian' ? 0.08 : 0.06;
-
-        if (edge.activation > 0) {
-          mat.opacity = baseOpacity + edge.activation * 0.5;
-          edge.activation *= 0.96;
-        } else if (mat.opacity > baseOpacity) {
-          mat.opacity *= 0.98;
-        }
-
-        // Update edge geometry to follow node positions
-        const positions = edge.line.geometry.attributes['position'] as THREE.BufferAttribute;
-        const fromNode = this.nodes[edge.from];
-        const toNode = this.nodes[edge.to];
-        positions.setXYZ(0, fromNode.position.x, fromNode.position.y, fromNode.position.z);
-        positions.setXYZ(1, toNode.position.x, toNode.position.y, toNode.position.z);
-        positions.needsUpdate = true;
-      }
-    }
-
-    // Ambient continuous particle stream — spawn 1-2 particles every few frames
-    if (layers.particles) {
-      this.ambientParticleTimer += delta;
-      if (this.ambientParticleTimer > 0.15 && this.particles.length < 60) {
-        this.ambientParticleTimer = 0;
-        this.spawnParticle();
-      }
-    }
-
-    // Animate particles along edges
-    if (layers.particles) {
-      for (const particle of this.particles) {
-        if (!particle.alive) continue;
-
-        particle.progress += particle.speed;
-        if (particle.progress >= 1) {
-          particle.alive = false;
-          this.scene.remove(particle.mesh);
-          if (particle.trailMesh) this.scene.remove(particle.trailMesh);
-          continue;
-        }
-
-        const edge = this.graphEdges[particle.edgeIndex];
-        const fromNode = this.nodes[edge.from];
-        const toNode = this.nodes[edge.to];
-        const pos = new THREE.Vector3();
-        pos.lerpVectors(fromNode.position, toNode.position, particle.progress);
-        particle.mesh.position.copy(pos);
-
-        // Trail follows slightly behind
-        if (particle.trailMesh) {
-          const trailProgress = Math.max(0, particle.progress - 0.08);
-          particle.trailMesh.position.lerpVectors(fromNode.position, toNode.position, trailProgress);
-          const trailMat = particle.trailMesh.material as THREE.MeshBasicMaterial;
-          trailMat.opacity = Math.sin(particle.progress * Math.PI) * 0.25;
-        }
-
-        // Particle fades in/out along its path
-        const mat = particle.mesh.material as THREE.MeshBasicMaterial;
-        mat.opacity = Math.sin(particle.progress * Math.PI) * 0.95;
-        // Pulse scale slightly
-        particle.mesh.scale.setScalar(0.8 + Math.sin(particle.progress * Math.PI) * 0.5);
-      }
-
-      // Clean up dead particles
-      this.particles = this.particles.filter(p => p.alive);
-    }
-
-    // Query trail expanding glow ring
-    if (this.queryTrailMesh) {
-      const mat = this.queryTrailMesh.material as THREE.MeshBasicMaterial;
-      if (mat.opacity > 0.01) {
-        mat.opacity *= 0.96;
-        const scale = 1 + (1 - mat.opacity) * 5;
-        this.queryTrailMesh.scale.setScalar(scale);
-      }
-    }
-
-    this.renderer.render(this.scene, this.camera);
-  }
-}
diff --git a/spector-cortex/src/app/features/pipeline-funnel/pipeline-funnel.component.html b/spector-cortex/src/app/features/pipeline-funnel/pipeline-funnel.component.html
deleted file mode 100644
index 8b370b1..0000000
--- a/spector-cortex/src/app/features/pipeline-funnel/pipeline-funnel.component.html
+++ /dev/null
@@ -1,50 +0,0 @@
-<div class="funnel-container">
-  <!-- Query Text -->
-  <div class="query-banner cortex-mono">
-    <span class="query-icon">⟩</span>
-    <span class="query-text">{{ queryText() }}</span>
-  </div>
-
-  <!-- Funnel Phases -->
-  @for (phase of phases(); track phase.label; let i = $index) {
-    <div class="funnel-row" [style.animation-delay]="(i * 80) + 'ms'">
-      <div class="phase-label">
-        <span class="phase-name">{{ phase.label }}</span>
-        <span class="phase-count cortex-mono">{{ formatCount(phase.count) }}</span>
-      </div>
-      <div class="phase-bar-track">
-        <div class="phase-bar"
-             [style.width.%]="phase.barWidth"
-             [class.phase-highlight]="i === 0"
-             [class.phase-gate]="i === 2"
-             [class.phase-final]="i === phases().length - 1">
-        </div>
-      </div>
-      @if (i > 0 && phase.filtered > 0) {
-        <span class="filter-badge">
-          −{{ phase.percentage | number:'1.1-1' }}%
-        </span>
-      }
-    </div>
-  }
-
-  <!-- Graph Augmentation -->
-  @if (augmentation(); as aug) {
-    @if (aug.total > 0) {
-      <div class="augmentation-section">
-        <div class="aug-title">Graph Augmentation</div>
-        <div class="aug-chips">
-          @if (aug.hebbian > 0) {
-            <span class="aug-chip hebbian">+{{ aug.hebbian }} Hebbian</span>
-          }
-          @if (aug.temporal > 0) {
-            <span class="aug-chip temporal">+{{ aug.temporal }} Temporal</span>
-          }
-          @if (aug.entity > 0) {
-            <span class="aug-chip entity">+{{ aug.entity }} Entity</span>
-          }
-        </div>
-      </div>
-    }
-  }
-</div>
diff --git a/spector-cortex/src/app/features/pipeline-funnel/pipeline-funnel.component.scss b/spector-cortex/src/app/features/pipeline-funnel/pipeline-funnel.component.scss
deleted file mode 100644
index 56392be..0000000
--- a/spector-cortex/src/app/features/pipeline-funnel/pipeline-funnel.component.scss
+++ /dev/null
@@ -1,153 +0,0 @@
-:host {
-  display: block;
-  flex: 1;
-  min-height: 0;
-  overflow: auto;
-}
-
-.funnel-container {
-  padding: 12px 16px;
-  display: flex;
-  flex-direction: column;
-  gap: 6px;
-}
-
-// ── Query Banner ─────────────────────────────────────────────────────
-.query-banner {
-  display: flex;
-  align-items: center;
-  gap: 6px;
-  padding: 6px 10px;
-  border-radius: 8px;
-  background: var(--mat-sys-surface-container-high);
-  margin-bottom: 4px;
-  font-size: 11px;
-  color: var(--mat-sys-on-surface-variant);
-  overflow: hidden;
-}
-
-.query-icon {
-  color: var(--mat-sys-primary);
-  font-weight: bold;
-}
-
-.query-text {
-  overflow: hidden;
-  text-overflow: ellipsis;
-  white-space: nowrap;
-}
-
-// ── Funnel Row ───────────────────────────────────────────────────────
-.funnel-row {
-  display: grid;
-  grid-template-columns: 140px 1fr auto;
-  align-items: center;
-  gap: 8px;
-  animation: fade-in-up 0.4s ease both;
-}
-
-.phase-label {
-  display: flex;
-  justify-content: space-between;
-  align-items: center;
-  gap: 4px;
-}
-
-.phase-name {
-  font-size: 11px;
-  color: var(--mat-sys-on-surface-variant);
-  white-space: nowrap;
-}
-
-.phase-count {
-  font-size: 11px;
-  font-weight: 600;
-  color: var(--mat-sys-on-surface);
-}
-
-// ── Phase Bar ────────────────────────────────────────────────────────
-.phase-bar-track {
-  height: 16px;
-  border-radius: 4px;
-  background: var(--mat-sys-surface-container-highest);
-  overflow: hidden;
-}
-
-.phase-bar {
-  height: 100%;
-  border-radius: 4px;
-  transition: width 0.6s cubic-bezier(0.4, 0, 0.2, 1);
-  background: var(--mat-sys-primary);
-  opacity: 0.7;
-  position: relative;
-
-  &.phase-highlight {
-    opacity: 1;
-    background: linear-gradient(90deg, var(--mat-sys-primary), var(--mat-sys-tertiary));
-  }
-
-  &.phase-gate {
-    background: var(--mat-sys-tertiary);
-    animation: neuron-fire 2s ease-in-out infinite;
-  }
-
-  &.phase-final {
-    background: linear-gradient(90deg, var(--mat-sys-tertiary), var(--mat-sys-primary));
-    opacity: 1;
-  }
-}
-
-// ── Filter Badge ─────────────────────────────────────────────────────
-.filter-badge {
-  font-size: 10px;
-  font-weight: 600;
-  color: var(--mat-sys-error);
-  white-space: nowrap;
-  min-width: 48px;
-  text-align: right;
-}
-
-// ── Augmentation ─────────────────────────────────────────────────────
-.augmentation-section {
-  margin-top: 8px;
-  padding-top: 8px;
-  border-top: 1px dashed var(--mat-sys-outline-variant);
-}
-
-.aug-title {
-  font-size: 10px;
-  font-weight: 600;
-  text-transform: uppercase;
-  letter-spacing: 0.08em;
-  color: var(--mat-sys-on-surface-variant);
-  margin-bottom: 6px;
-}
-
-.aug-chips {
-  display: flex;
-  gap: 6px;
-  flex-wrap: wrap;
-}
-
-.aug-chip {
-  font-size: 10px;
-  font-weight: 600;
-  padding: 2px 8px;
-  border-radius: 9999px;
-  animation: slide-in-right 0.3s ease both;
-
-  &.hebbian {
-    background: color-mix(in srgb, var(--mat-sys-primary) 20%, transparent);
-    color: var(--mat-sys-primary);
-  }
-
-  &.temporal {
-    background: color-mix(in srgb, var(--mat-sys-tertiary) 20%, transparent);
-    color: var(--mat-sys-tertiary);
-  }
-
-  &.entity {
-    background: color-mix(in srgb, var(--mat-sys-secondary) 20%, transparent);
-    color: var(--mat-sys-secondary);
-  }
-}
diff --git a/spector-cortex/src/app/features/pipeline-funnel/pipeline-funnel.component.ts b/spector-cortex/src/app/features/pipeline-funnel/pipeline-funnel.component.ts
deleted file mode 100644
index c862002..0000000
--- a/spector-cortex/src/app/features/pipeline-funnel/pipeline-funnel.component.ts
+++ /dev/null
@@ -1,69 +0,0 @@
-import { Component, inject, computed } from '@angular/core';
-import { DecimalPipe } from '@angular/common';
-import { CortexStateService } from '../../core/services/cortex-state.service';
-
-interface FunnelPhase {
-  label: string;
-  count: number;
-  filtered: number;
-  percentage: number;
-  barWidth: number;
-}
-
-@Component({
-  selector: 'cortex-pipeline-funnel',
-  imports: [DecimalPipe],
-  templateUrl: './pipeline-funnel.component.html',
-  styleUrl: './pipeline-funnel.component.scss',
-})
-export class PipelineFunnelComponent {
-
-  protected readonly state = inject(CortexStateService);
-
-  protected readonly phases = computed<FunnelPhase[]>(() => {
-    const trace = this.state.currentQueryTrace();
-    if (!trace) return [];
-
-    const steps = [
-      { label: 'Total Records', count: trace.totalRecords },
-      { label: 'After Tombstone', count: trace.afterTombstone },
-      { label: 'After Tag Gate', count: trace.afterTagGate },
-      { label: 'After Valence', count: trace.afterValence },
-      { label: 'After Decay', count: trace.afterDecay },
-      { label: 'Vector Distance', count: trace.afterVectorDistance },
-      { label: 'Final Top-K', count: trace.finalTopK },
-    ];
-
-    const max = steps[0].count || 1;
-
-    return steps.map((step, i) => {
-      const prev = i > 0 ? steps[i - 1].count : step.count;
-      const filtered = prev - step.count;
-      const percentage = prev > 0 ? (filtered / prev) * 100 : 0;
-      const barWidth = Math.max(2, (step.count / max) * 100);
-
-      return { ...step, filtered, percentage, barWidth };
-    });
-  });
-
-  protected readonly augmentation = computed(() => {
-    const trace = this.state.currentQueryTrace();
-    if (!trace) return null;
-    return {
-      hebbian: trace.hebbianActivated,
-      temporal: trace.temporalLinked,
-      entity: trace.entityDiscovered,
-      total: trace.hebbianActivated + trace.temporalLinked + trace.entityDiscovered,
-    };
-  });
-
-  protected readonly queryText = computed(() => {
-    return this.state.currentQueryTrace()?.queryText ?? '—';
-  });
-
-  protected formatCount(n: number): string {
-    if (n >= 1_000_000) return (n / 1_000_000).toFixed(1) + 'M';
-    if (n >= 1_000) return (n / 1_000).toFixed(1) + 'K';
-    return n.toString();
-  }
-}
diff --git a/spector-cortex/src/app/features/profile-radar/profile-radar.component.html b/spector-cortex/src/app/features/profile-radar/profile-radar.component.html
deleted file mode 100644
index c0d1b18..0000000
--- a/spector-cortex/src/app/features/profile-radar/profile-radar.component.html
+++ /dev/null
@@ -1,12 +0,0 @@
-<div class="radar-container">
-  <div class="canvas-wrapper">
-    <canvas #radarCanvas></canvas>
-  </div>
-
-  <!-- Profile Info -->
-  @if (state.activeProfile(); as profile) {
-    <div class="profile-info">
-      <span class="profile-badge cortex-mono">{{ profile }}</span>
-    </div>
-  }
-</div>
diff --git a/spector-cortex/src/app/features/profile-radar/profile-radar.component.scss b/spector-cortex/src/app/features/profile-radar/profile-radar.component.scss
deleted file mode 100644
index 30d35de..0000000
--- a/spector-cortex/src/app/features/profile-radar/profile-radar.component.scss
+++ /dev/null
@@ -1,45 +0,0 @@
-:host {
-  display: block;
-  flex: 1;
-  min-height: 0;
-}
-
-.radar-container {
-  display: flex;
-  flex-direction: column;
-  align-items: center;
-  height: 100%;
-  padding: 8px;
-  gap: 6px;
-}
-
-.canvas-wrapper {
-  flex: 1;
-  display: flex;
-  align-items: center;
-  justify-content: center;
-  min-height: 0;
-  width: 100%;
-
-  canvas {
-    display: block;
-    max-width: 100%;
-    max-height: 100%;
-  }
-}
-
-.profile-info {
-  display: flex;
-  align-items: center;
-  gap: 8px;
-}
-
-.profile-badge {
-  font-size: 10px;
-  font-weight: 600;
-  padding: 3px 10px;
-  border-radius: 9999px;
-  background: color-mix(in srgb, var(--mat-sys-primary) 15%, transparent);
-  color: var(--mat-sys-primary);
-  letter-spacing: 0.04em;
-}
diff --git a/spector-cortex/src/app/features/profile-radar/profile-radar.component.ts b/spector-cortex/src/app/features/profile-radar/profile-radar.component.ts
deleted file mode 100644
index 1d7633a..0000000
--- a/spector-cortex/src/app/features/profile-radar/profile-radar.component.ts
+++ /dev/null
@@ -1,211 +0,0 @@
-import {
-  Component, ElementRef, ViewChild, AfterViewInit, OnDestroy, inject, effect, PLATFORM_ID,
-} from '@angular/core';
-import { isPlatformBrowser } from '@angular/common';
-import { CortexStateService } from '../../core/services/cortex-state.service';
-import { ThemeService } from '../../core/services/theme.service';
-import { PROFILE_PARAMS, CognitiveProfile } from '../../core/models/memory-types';
-
-/** Radar chart axes. */
-const AXES = [
-  { key: 'alpha', label: 'α Similarity', max: 1.0 },
-  { key: 'beta', label: 'β Importance', max: 1.0 },
-  { key: 'strictness', label: 'Strictness', max: 10.0 },
-  { key: 'hyperfocusBoost', label: 'Hyperfocus', max: 2.0 },
-  { key: 'lateralMode', label: 'Lateral', max: 1.0 },
-  { key: 'valenceRange', label: 'Valence Range', max: 255 },
-];
-
-@Component({
-  selector: 'cortex-profile-radar',
-  templateUrl: './profile-radar.component.html',
-  styleUrl: './profile-radar.component.scss',
-})
-export class ProfileRadarComponent implements AfterViewInit, OnDestroy {
-
-  @ViewChild('radarCanvas', { static: true })
-  private canvasRef!: ElementRef<HTMLCanvasElement>;
-
-  protected readonly state = inject(CortexStateService);
-  private readonly themeService = inject(ThemeService);
-  private readonly platformId = inject(PLATFORM_ID);
-
-  private ctx!: CanvasRenderingContext2D;
-  private animationId = 0;
-  private currentValues: number[] = new Array(AXES.length).fill(0);
-  private targetValues: number[] = new Array(AXES.length).fill(0);
-
-  ngAfterViewInit(): void {
-    if (!isPlatformBrowser(this.platformId)) return;
-
-    const canvas = this.canvasRef.nativeElement;
-    this.ctx = canvas.getContext('2d')!;
-    this.resizeCanvas();
-    this.animate();
-
-    const observer = new ResizeObserver(() => this.resizeCanvas());
-    observer.observe(canvas.parentElement!);
-
-    // React to profile changes
-    effect(() => {
-      const profile = this.state.activeProfile();
-      this.updateTargets(profile);
-    });
-  }
-
-  ngOnDestroy(): void {
-    cancelAnimationFrame(this.animationId);
-  }
-
-  private resizeCanvas(): void {
-    const parent = this.canvasRef.nativeElement.parentElement!;
-    const canvas = this.canvasRef.nativeElement;
-    const w = parent.clientWidth || 250;
-    const h = parent.clientHeight || 250;
-    const size = Math.min(w, h, 400);
-    if (size < 10) return; // Skip if not yet laid out
-    canvas.width = size;
-    canvas.height = size;
-  }
-
-  private updateTargets(profile: CognitiveProfile): void {
-    const params = PROFILE_PARAMS[profile];
-    this.targetValues = [
-      params.alpha / 1.0,
-      params.beta / 1.0,
-      params.strictness / 10.0,
-      params.hyperfocusBoost / 2.0,
-      params.lateralMode ? 1.0 : 0.0,
-      (params.valenceMax - params.valenceMin) / 255,
-    ];
-  }
-
-  private animate(): void {
-    this.animationId = requestAnimationFrame(() => this.animate());
-
-    const canvas = this.canvasRef.nativeElement;
-    const ctx = this.ctx;
-    const w = canvas.width;
-    const h = canvas.height;
-    const cx = w / 2;
-    const cy = h / 2;
-    const radius = Math.min(cx, cy) - 40;
-
-    ctx.clearRect(0, 0, w, h);
-
-    // Lerp values
-    for (let i = 0; i < AXES.length; i++) {
-      this.currentValues[i] += (this.targetValues[i] - this.currentValues[i]) * 0.08;
-    }
-
-    const primary = this.themeService.getCssVariable('--mat-sys-primary') || '#bb86fc';
-    const tertiary = this.themeService.getCssVariable('--mat-sys-tertiary') || '#03dac6';
-    const outline = this.themeService.getCssVariable('--mat-sys-outline-variant') || '#555';
-    const onSurface = this.themeService.getCssVariable('--mat-sys-on-surface-variant') || '#aaa';
-    const surfaceHigh = this.themeService.getCssVariable('--mat-sys-surface-container-high') || '#333';
-
-    const n = AXES.length;
-    const angleStep = (Math.PI * 2) / n;
-
-    // Draw concentric rings
-    for (let ring = 1; ring <= 4; ring++) {
-      const r = (radius * ring) / 4;
-      ctx.beginPath();
-      for (let i = 0; i <= n; i++) {
-        const angle = i * angleStep - Math.PI / 2;
-        const x = cx + r * Math.cos(angle);
-        const y = cy + r * Math.sin(angle);
-        if (i === 0) ctx.moveTo(x, y);
-        else ctx.lineTo(x, y);
-      }
-      ctx.closePath();
-      ctx.strokeStyle = outline;
-      ctx.lineWidth = 0.5;
-      ctx.stroke();
-    }
-
-    // Draw axis lines and labels
-    for (let i = 0; i < n; i++) {
-      const angle = i * angleStep - Math.PI / 2;
-      const x = cx + radius * Math.cos(angle);
-      const y = cy + radius * Math.sin(angle);
-
-      ctx.beginPath();
-      ctx.moveTo(cx, cy);
-      ctx.lineTo(x, y);
-      ctx.strokeStyle = outline;
-      ctx.lineWidth = 0.5;
-      ctx.stroke();
-
-      // Label
-      const labelX = cx + (radius + 20) * Math.cos(angle);
-      const labelY = cy + (radius + 20) * Math.sin(angle);
-      ctx.fillStyle = onSurface;
-      ctx.font = '10px Inter, sans-serif';
-      ctx.textAlign = 'center';
-      ctx.textBaseline = 'middle';
-      ctx.fillText(AXES[i].label, labelX, labelY);
-    }
-
-    // Draw data polygon
-    ctx.beginPath();
-    for (let i = 0; i <= n; i++) {
-      const idx = i % n;
-      const angle = idx * angleStep - Math.PI / 2;
-      const val = Math.max(0, Math.min(1, this.currentValues[idx]));
-      const r = radius * val;
-      const x = cx + r * Math.cos(angle);
-      const y = cy + r * Math.sin(angle);
-      if (i === 0) ctx.moveTo(x, y);
-      else ctx.lineTo(x, y);
-    }
-    ctx.closePath();
-
-    // Fill
-    ctx.fillStyle = primary;
-    ctx.globalAlpha = 0.15;
-    ctx.fill();
-    ctx.globalAlpha = 1;
-
-    // Stroke
-    ctx.strokeStyle = primary;
-    ctx.lineWidth = 2;
-    ctx.stroke();
-
-    // Draw data points
-    for (let i = 0; i < n; i++) {
-      const angle = i * angleStep - Math.PI / 2;
-      const val = Math.max(0, Math.min(1, this.currentValues[i]));
-      const r = radius * val;
-      const x = cx + r * Math.cos(angle);
-      const y = cy + r * Math.sin(angle);
-
-      // Glow
-      ctx.beginPath();
-      ctx.arc(x, y, 6, 0, Math.PI * 2);
-      ctx.fillStyle = primary;
-      ctx.globalAlpha = 0.3;
-      ctx.fill();
-      ctx.globalAlpha = 1;
-
-      // Point
-      ctx.beginPath();
-      ctx.arc(x, y, 3, 0, Math.PI * 2);
-      ctx.fillStyle = primary;
-      ctx.fill();
-    }
-
-    // Center label
-    const profile = this.state.activeProfile();
-    const params = PROFILE_PARAMS[profile];
-    ctx.fillStyle = this.themeService.getCssVariable('--mat-sys-on-surface') || '#fff';
-    ctx.font = 'bold 13px Inter, sans-serif';
-    ctx.textAlign = 'center';
-    ctx.textBaseline = 'middle';
-    ctx.fillText(params.label, cx, cy - 6);
-
-    ctx.fillStyle = onSurface;
-    ctx.font = '9px Inter, sans-serif';
-    ctx.fillText(params.description.substring(0, 35), cx, cy + 10);
-  }
-}
diff --git a/spector-cortex/src/app/features/query-history/query-history.component.html b/spector-cortex/src/app/features/query-history/query-history.component.html
deleted file mode 100644
index 6f41880..0000000
--- a/spector-cortex/src/app/features/query-history/query-history.component.html
+++ /dev/null
@@ -1,24 +0,0 @@
-<div class="history-container">
-  @for (item of history(); track item.timestamp; let i = $index) {
-    <div class="history-item" [style.animation-delay]="(i * 50) + 'ms'">
-      <div class="item-time cortex-mono">{{ formatTime(item.timestamp) }}</div>
-      <div class="item-body">
-        <div class="item-query">{{ item.text }}</div>
-        <div class="item-meta">
-          <span class="meta-chip profile-chip">{{ item.profile }}</span>
-          <span class="meta-chip latency-chip cortex-mono">{{ item.latencyMs }}ms</span>
-          <span class="meta-chip results-chip cortex-mono">{{ item.topK }}
-            @if (item.augmented > 0) {
-              <span class="aug-badge">+{{ item.augmented }}</span>
-            }
-          </span>
-        </div>
-      </div>
-    </div>
-  } @empty {
-    <div class="empty-state">
-      <mat-icon>history</mat-icon>
-      <span>No queries yet</span>
-    </div>
-  }
-</div>
diff --git a/spector-cortex/src/app/features/query-history/query-history.component.scss b/spector-cortex/src/app/features/query-history/query-history.component.scss
deleted file mode 100644
index 649cec3..0000000
--- a/spector-cortex/src/app/features/query-history/query-history.component.scss
+++ /dev/null
@@ -1,43 +0,0 @@
-:host { display: block; flex: 1; min-height: 0; overflow: auto; }
-.history-container { padding: 8px 12px; display: flex; flex-direction: column; gap: 4px; }
-.history-item {
-  display: flex; gap: 8px; padding: 6px 8px; border-radius: 8px;
-  background: var(--mat-sys-surface-container-high);
-  animation: fade-in-up 0.3s ease both;
-  transition: background 0.2s ease;
-  &:hover { background: var(--mat-sys-surface-container-highest); }
-}
-.item-time {
-  font-size: 10px; color: var(--mat-sys-on-surface-variant);
-  white-space: nowrap; padding-top: 2px; min-width: 56px;
-}
-.item-body { flex: 1; min-width: 0; }
-.item-query {
-  font-size: 11px; color: var(--mat-sys-on-surface);
-  overflow: hidden; text-overflow: ellipsis; white-space: nowrap;
-}
-.item-meta { display: flex; gap: 4px; margin-top: 3px; flex-wrap: wrap; }
-.meta-chip {
-  font-size: 9px; font-weight: 600; padding: 1px 6px; border-radius: 9999px;
-}
-.profile-chip {
-  background: color-mix(in srgb, var(--mat-sys-primary) 15%, transparent);
-  color: var(--mat-sys-primary);
-}
-.latency-chip {
-  background: color-mix(in srgb, var(--mat-sys-tertiary) 15%, transparent);
-  color: var(--mat-sys-tertiary);
-}
-.results-chip {
-  background: color-mix(in srgb, var(--mat-sys-secondary) 15%, transparent);
-  color: var(--mat-sys-secondary);
-}
-.aug-badge {
-  color: var(--mat-sys-tertiary); font-weight: 700;
-}
-.empty-state {
-  display: flex; flex-direction: column; align-items: center; gap: 8px;
-  padding: 24px; color: var(--mat-sys-on-surface-variant);
-  mat-icon { font-size: 32px; width: 32px; height: 32px; opacity: 0.3; }
-  span { font-size: 12px; }
-}
diff --git a/spector-cortex/src/app/features/query-history/query-history.component.ts b/spector-cortex/src/app/features/query-history/query-history.component.ts
deleted file mode 100644
index 59311d4..0000000
--- a/spector-cortex/src/app/features/query-history/query-history.component.ts
+++ /dev/null
@@ -1,34 +0,0 @@
-import { Component, inject, computed } from '@angular/core';
-import { MatIconModule } from '@angular/material/icon';
-import { MatTooltipModule } from '@angular/material/tooltip';
-import { CortexStateService } from '../../core/services/cortex-state.service';
-import { PROFILE_PARAMS, CognitiveProfile } from '../../core/models/memory-types';
-
-@Component({
-  selector: 'cortex-query-history',
-  imports: [MatIconModule, MatTooltipModule],
-  templateUrl: './query-history.component.html',
-  styleUrl: './query-history.component.scss',
-})
-export class QueryHistoryComponent {
-
-  protected readonly state = inject(CortexStateService);
-  protected readonly profileParams = PROFILE_PARAMS;
-
-  protected readonly history = computed(() => {
-    return this.state.queryHistory().map(trace => ({
-      text: trace.queryText,
-      profile: this.profileParams[trace.cognitiveProfile as CognitiveProfile]?.label ?? trace.cognitiveProfile,
-      latencyMs: (trace.latencyMicros / 1000).toFixed(1),
-      topK: trace.finalTopK,
-      augmented: trace.hebbianActivated + trace.temporalLinked + trace.entityDiscovered,
-      timestamp: trace.timestamp,
-      totalRecords: trace.totalRecords,
-    }));
-  });
-
-  protected formatTime(ts: number): string {
-    const d = new Date(ts);
-    return d.toLocaleTimeString('en-US', { hour12: false, hour: '2-digit', minute: '2-digit', second: '2-digit' });
-  }
-}
diff --git a/spector-cortex/src/app/features/query-input/query-input.component.html b/spector-cortex/src/app/features/query-input/query-input.component.html
deleted file mode 100644
index 4e8346c..0000000
--- a/spector-cortex/src/app/features/query-input/query-input.component.html
+++ /dev/null
@@ -1,18 +0,0 @@
-<div class="query-input-container">
-  <div class="search-bar" [class.running]="state.isQueryRunning()">
-    <mat-icon class="search-icon">search</mat-icon>
-    <input class="search-input"
-           [(ngModel)]="queryText"
-           placeholder="Query memory — type to see the pipeline execute..."
-           (keydown.enter)="submitQuery()"
-           [disabled]="state.isQueryRunning()" />
-    <button class="send-button"
-            (click)="submitQuery()"
-            [disabled]="state.isQueryRunning() || !queryText.trim()">
-      <mat-icon>{{ state.isQueryRunning() ? 'hourglass_top' : 'arrow_upward' }}</mat-icon>
-    </button>
-  </div>
-  @if (state.isQueryRunning()) {
-    <div class="running-bar"></div>
-  }
-</div>
diff --git a/spector-cortex/src/app/features/query-input/query-input.component.scss b/spector-cortex/src/app/features/query-input/query-input.component.scss
deleted file mode 100644
index 6052143..0000000
--- a/spector-cortex/src/app/features/query-input/query-input.component.scss
+++ /dev/null
@@ -1,98 +0,0 @@
-:host { display: block; }
-
-.query-input-container {
-  position: relative;
-}
-
-.search-bar {
-  display: flex;
-  align-items: center;
-  gap: 8px;
-  padding: 6px 6px 6px 14px;
-  border-radius: 14px;
-  background: var(--mat-sys-surface-container-high);
-  border: 1px solid var(--mat-sys-outline-variant);
-  transition: border-color 0.2s ease, box-shadow 0.2s ease;
-
-  &:focus-within {
-    border-color: var(--mat-sys-primary);
-    box-shadow: 0 0 0 2px color-mix(in srgb, var(--mat-sys-primary) 20%, transparent);
-  }
-
-  &.running {
-    border-color: var(--mat-sys-tertiary);
-  }
-}
-
-.search-icon {
-  color: var(--mat-sys-on-surface-variant);
-  font-size: 20px;
-  width: 20px;
-  height: 20px;
-  flex-shrink: 0;
-}
-
-.search-input {
-  flex: 1;
-  border: none;
-  outline: none;
-  background: transparent;
-  font-family: 'Inter', sans-serif;
-  font-size: 13px;
-  color: var(--mat-sys-on-surface);
-  min-width: 0;
-
-  &::placeholder {
-    color: var(--mat-sys-on-surface-variant);
-    opacity: 0.6;
-  }
-
-  &:disabled {
-    opacity: 0.5;
-  }
-}
-
-.send-button {
-  display: flex;
-  align-items: center;
-  justify-content: center;
-  width: 32px;
-  height: 32px;
-  border-radius: 10px;
-  border: none;
-  cursor: pointer;
-  background: var(--mat-sys-primary);
-  color: var(--mat-sys-on-primary);
-  flex-shrink: 0;
-  transition: background 0.2s ease, opacity 0.2s ease, transform 0.15s ease;
-
-  mat-icon {
-    font-size: 18px;
-    width: 18px;
-    height: 18px;
-  }
-
-  &:hover:not(:disabled) {
-    background: var(--mat-sys-primary);
-    opacity: 0.85;
-    transform: scale(1.05);
-  }
-
-  &:disabled {
-    background: var(--mat-sys-surface-container-highest);
-    color: var(--mat-sys-on-surface-variant);
-    cursor: default;
-    opacity: 0.4;
-  }
-}
-
-.running-bar {
-  position: absolute;
-  bottom: -2px;
-  left: 14px;
-  right: 14px;
-  height: 2px;
-  border-radius: 1px;
-  background: var(--mat-sys-tertiary);
-  animation: shimmer 1.2s ease-in-out infinite;
-}
diff --git a/spector-cortex/src/app/features/query-input/query-input.component.ts b/spector-cortex/src/app/features/query-input/query-input.component.ts
deleted file mode 100644
index c0fd671..0000000
--- a/spector-cortex/src/app/features/query-input/query-input.component.ts
+++ /dev/null
@@ -1,28 +0,0 @@
-import { Component, inject } from '@angular/core';
-import { FormsModule } from '@angular/forms';
-import { MatIconModule } from '@angular/material/icon';
-import { CortexStateService } from '../../core/services/cortex-state.service';
-
-@Component({
-  selector: 'cortex-query-input',
-  imports: [FormsModule, MatIconModule],
-  templateUrl: './query-input.component.html',
-  styleUrl: './query-input.component.scss',
-})
-export class QueryInputComponent {
-
-  protected readonly state = inject(CortexStateService);
-  protected queryText = '';
-
-  protected submitQuery(): void {
-    if (!this.queryText.trim()) return;
-    this.state.isQueryRunning.set(true);
-
-    // Simulate query execution with mock trace
-    setTimeout(() => {
-      this.state.isQueryRunning.set(false);
-    }, 800 + Math.random() * 1500);
-
-    this.queryText = '';
-  }
-}
diff --git a/spector-cortex/src/app/features/simd-panel/simd-panel.component.html b/spector-cortex/src/app/features/simd-panel/simd-panel.component.html
deleted file mode 100644
index 635e7a1..0000000
--- a/spector-cortex/src/app/features/simd-panel/simd-panel.component.html
+++ /dev/null
@@ -1,36 +0,0 @@
-<div class="simd-container">
-  <!-- Register Grid Canvas -->
-  <div class="canvas-wrapper">
-    <canvas #simdCanvas></canvas>
-  </div>
-
-  <!-- Stats Bar -->
-  @if (state.simdState(); as simd) {
-    <div class="stats-bar">
-      <div class="stat">
-        <span class="stat-label">ISA</span>
-        <span class="stat-value cortex-mono">AVX-{{ simd.vectorBitSize }}</span>
-      </div>
-      <div class="stat">
-        <span class="stat-label">Lanes</span>
-        <span class="stat-value cortex-mono">{{ simd.laneCount }}</span>
-      </div>
-      <div class="stat">
-        <span class="stat-label">Iterations</span>
-        <span class="stat-value cortex-mono">{{ simd.totalIterations }}</span>
-      </div>
-      <div class="stat">
-        <span class="stat-label">Tail</span>
-        <span class="stat-value cortex-mono">{{ simd.tailLanesActive }}/{{ simd.laneCount }}</span>
-      </div>
-      <div class="stat">
-        <span class="stat-label">Kernel</span>
-        <span class="stat-value cortex-mono kernel-badge">{{ simd.activeKernel }}</span>
-      </div>
-    </div>
-  } @else {
-    <div class="stats-bar placeholder">
-      <span class="stat-label">Awaiting SIMD events...</span>
-    </div>
-  }
-</div>
diff --git a/spector-cortex/src/app/features/simd-panel/simd-panel.component.scss b/spector-cortex/src/app/features/simd-panel/simd-panel.component.scss
deleted file mode 100644
index afbc21c..0000000
--- a/spector-cortex/src/app/features/simd-panel/simd-panel.component.scss
+++ /dev/null
@@ -1,68 +0,0 @@
-:host {
-  display: block;
-  flex: 1;
-  min-height: 0;
-}
-
-.simd-container {
-  display: flex;
-  flex-direction: column;
-  height: 100%;
-  padding: 8px 12px;
-  gap: 8px;
-}
-
-.canvas-wrapper {
-  flex: 1;
-  min-height: 100px;
-
-  canvas {
-    display: block;
-    width: 100%;
-    height: 100%;
-  }
-}
-
-// ── Stats Bar ────────────────────────────────────────────────────────
-.stats-bar {
-  display: flex;
-  gap: 12px;
-  flex-wrap: wrap;
-  padding: 8px 10px;
-  border-radius: 8px;
-  background: var(--mat-sys-surface-container-high);
-
-  &.placeholder {
-    justify-content: center;
-    padding: 12px;
-  }
-}
-
-.stat {
-  display: flex;
-  flex-direction: column;
-  gap: 2px;
-  min-width: 60px;
-}
-
-.stat-label {
-  font-size: 9px;
-  font-weight: 500;
-  text-transform: uppercase;
-  letter-spacing: 0.08em;
-  color: var(--mat-sys-on-surface-variant);
-}
-
-.stat-value {
-  font-size: 12px;
-  font-weight: 600;
-  color: var(--mat-sys-on-surface);
-}
-
-.kernel-badge {
-  padding: 1px 6px;
-  border-radius: 4px;
-  background: color-mix(in srgb, var(--mat-sys-tertiary) 15%, transparent);
-  color: var(--mat-sys-tertiary);
-  font-size: 10px;
-}
diff --git a/spector-cortex/src/app/features/simd-panel/simd-panel.component.ts b/spector-cortex/src/app/features/simd-panel/simd-panel.component.ts
deleted file mode 100644
index c21085b..0000000
--- a/spector-cortex/src/app/features/simd-panel/simd-panel.component.ts
+++ /dev/null
@@ -1,159 +0,0 @@
-import {
-  Component, ElementRef, ViewChild, AfterViewInit, OnDestroy, inject, effect, PLATFORM_ID,
-} from '@angular/core';
-import { isPlatformBrowser } from '@angular/common';
-import { CortexStateService } from '../../core/services/cortex-state.service';
-import { ThemeService } from '../../core/services/theme.service';
-
-@Component({
-  selector: 'cortex-simd-panel',
-  templateUrl: './simd-panel.component.html',
-  styleUrl: './simd-panel.component.scss',
-})
-export class SimdPanelComponent implements AfterViewInit, OnDestroy {
-
-  @ViewChild('simdCanvas', { static: true })
-  private canvasRef!: ElementRef<HTMLCanvasElement>;
-
-  protected readonly state = inject(CortexStateService);
-  private readonly themeService = inject(ThemeService);
-  private readonly platformId = inject(PLATFORM_ID);
-
-  private ctx!: CanvasRenderingContext2D;
-  private animationId = 0;
-  private laneIntensities: number[] = new Array(16).fill(0);
-  private targetIntensities: number[] = new Array(16).fill(0);
-
-  ngAfterViewInit(): void {
-    if (!isPlatformBrowser(this.platformId)) return;
-
-    const canvas = this.canvasRef.nativeElement;
-    this.ctx = canvas.getContext('2d')!;
-
-    this.resizeCanvas();
-    this.animate();
-
-    const observer = new ResizeObserver(() => this.resizeCanvas());
-    observer.observe(canvas.parentElement!);
-
-    // React to SIMD events
-    effect(() => {
-      const simd = this.state.simdState();
-      if (simd) {
-        this.updateLanes(simd.laneCount, simd.tailLanesActive, simd.totalIterations);
-      }
-    });
-  }
-
-  ngOnDestroy(): void {
-    cancelAnimationFrame(this.animationId);
-  }
-
-  private resizeCanvas(): void {
-    const parent = this.canvasRef.nativeElement.parentElement!;
-    const canvas = this.canvasRef.nativeElement;
-    canvas.width = parent.clientWidth;
-    canvas.height = Math.min(parent.clientHeight, 160);
-  }
-
-  private updateLanes(laneCount: number, tailActive: number, iterations: number): void {
-    // Main loop: all lanes full
-    for (let i = 0; i < laneCount; i++) {
-      this.targetIntensities[i] = 1.0;
-    }
-    // Tail: partial
-    for (let i = tailActive; i < laneCount; i++) {
-      this.targetIntensities[i] = 0.15;
-    }
-    // Clear unused lanes
-    for (let i = laneCount; i < 16; i++) {
-      this.targetIntensities[i] = 0;
-    }
-  }
-
-  private animate(): void {
-    this.animationId = requestAnimationFrame(() => this.animate());
-
-    const canvas = this.canvasRef.nativeElement;
-    const ctx = this.ctx;
-    const w = canvas.width;
-    const h = canvas.height;
-
-    ctx.clearRect(0, 0, w, h);
-
-    // Get M3 colors
-    const primary = this.themeService.getCssVariable('--mat-sys-primary') || '#bb86fc';
-    const surface = this.themeService.getCssVariable('--mat-sys-surface-container-highest') || '#333';
-    const outline = this.themeService.getCssVariable('--mat-sys-outline-variant') || '#555';
-    const tertiary = this.themeService.getCssVariable('--mat-sys-tertiary') || '#03dac6';
-
-    const laneCount = this.state.simdState()?.laneCount ?? 16;
-    const laneWidth = Math.floor((w - 32) / laneCount) - 4;
-    const laneHeight = h - 40;
-    const startX = (w - (laneWidth + 4) * laneCount) / 2;
-
-    for (let i = 0; i < laneCount; i++) {
-      // Lerp intensity
-      this.laneIntensities[i] += (this.targetIntensities[i] - this.laneIntensities[i]) * 0.15;
-      const intensity = this.laneIntensities[i];
-
-      const x = startX + i * (laneWidth + 4);
-      const y = 20;
-
-      // Background
-      ctx.fillStyle = surface;
-      ctx.beginPath();
-      ctx.roundRect(x, y, laneWidth, laneHeight, 4);
-      ctx.fill();
-
-      // Active fill
-      if (intensity > 0) {
-        const fillHeight = laneHeight * intensity;
-        const fillY = y + laneHeight - fillHeight;
-
-        // Gradient
-        const gradient = ctx.createLinearGradient(x, fillY, x, y + laneHeight);
-        gradient.addColorStop(0, primary);
-        gradient.addColorStop(1, tertiary);
-
-        ctx.fillStyle = gradient;
-        ctx.globalAlpha = 0.3 + intensity * 0.7;
-        ctx.beginPath();
-        ctx.roundRect(x, fillY, laneWidth, fillHeight, [0, 0, 4, 4]);
-        ctx.fill();
-
-        // Glow
-        if (intensity > 0.5) {
-          ctx.shadowColor = primary;
-          ctx.shadowBlur = 8 * intensity;
-          ctx.fillStyle = primary;
-          ctx.globalAlpha = intensity * 0.2;
-          ctx.beginPath();
-          ctx.roundRect(x, fillY, laneWidth, fillHeight, [0, 0, 4, 4]);
-          ctx.fill();
-          ctx.shadowBlur = 0;
-        }
-
-        ctx.globalAlpha = 1;
-      }
-
-      // Border
-      ctx.strokeStyle = outline;
-      ctx.lineWidth = 1;
-      ctx.beginPath();
-      ctx.roundRect(x, y, laneWidth, laneHeight, 4);
-      ctx.stroke();
-
-      // Lane label
-      ctx.fillStyle = this.themeService.getCssVariable('--mat-sys-on-surface-variant') || '#aaa';
-      ctx.font = '9px "JetBrains Mono", monospace';
-      ctx.textAlign = 'center';
-      ctx.fillText(`L${i}`, x + laneWidth / 2, y + laneHeight + 14);
-    }
-
-    // Slowly decay targets
-    for (let i = 0; i < 16; i++) {
-      this.targetIntensities[i] *= 0.992;
-    }
-  }
-}
diff --git a/spector-cortex/src/app/features/vector-space/vector-space.component.html b/spector-cortex/src/app/features/vector-space/vector-space.component.html
deleted file mode 100644
index 43d7fcd..0000000
--- a/spector-cortex/src/app/features/vector-space/vector-space.component.html
+++ /dev/null
@@ -1 +0,0 @@
-<div #canvasContainer class="vector-canvas" (mousemove)="onMouseMove($event)"></div>
diff --git a/spector-cortex/src/app/features/vector-space/vector-space.component.scss b/spector-cortex/src/app/features/vector-space/vector-space.component.scss
deleted file mode 100644
index ec49e36..0000000
--- a/spector-cortex/src/app/features/vector-space/vector-space.component.scss
+++ /dev/null
@@ -1,5 +0,0 @@
-:host { display: block; flex: 1; min-height: 0; }
-.vector-canvas {
-  width: 100%; height: 100%; min-height: 200px; cursor: crosshair;
-  canvas { display: block; border-radius: 0 0 16px 16px; }
-}
diff --git a/spector-cortex/src/app/features/vector-space/vector-space.component.ts b/spector-cortex/src/app/features/vector-space/vector-space.component.ts
deleted file mode 100644
index f5c89e5..0000000
--- a/spector-cortex/src/app/features/vector-space/vector-space.component.ts
+++ /dev/null
@@ -1,213 +0,0 @@
-import {
-  Component, ElementRef, ViewChild, AfterViewInit, OnDestroy, inject, effect, PLATFORM_ID,
-} from '@angular/core';
-import { isPlatformBrowser } from '@angular/common';
-import { CortexStateService } from '../../core/services/cortex-state.service';
-import { ThemeService } from '../../core/services/theme.service';
-import * as THREE from 'three';
-
-const TIER_COLORS: Record<string, number> = {
-  WORKING: 0xffb74d,
-  EPISODIC: 0x66bb6a,
-  SEMANTIC: 0x42a5f5,
-  PROCEDURAL: 0xab47bc,
-};
-
-@Component({
-  selector: 'cortex-vector-space',
-  templateUrl: './vector-space.component.html',
-  styleUrl: './vector-space.component.scss',
-})
-export class VectorSpaceComponent implements AfterViewInit, OnDestroy {
-
-  @ViewChild('canvasContainer', { static: true })
-  private canvasContainer!: ElementRef<HTMLDivElement>;
-
-  private readonly state = inject(CortexStateService);
-  private readonly themeService = inject(ThemeService);
-  private readonly platformId = inject(PLATFORM_ID);
-
-  private scene!: THREE.Scene;
-  private camera!: THREE.PerspectiveCamera;
-  private renderer!: THREE.WebGLRenderer;
-  private pointsMesh!: THREE.Points;
-  private queryDot: THREE.Mesh | null = null;
-  private nearestLines: THREE.Line[] = [];
-  private animationId = 0;
-  private mouseX = 0;
-  private mouseY = 0;
-  private clock = new THREE.Clock();
-
-  ngAfterViewInit(): void {
-    if (!isPlatformBrowser(this.platformId)) return;
-    this.initScene();
-    this.buildPointCloud();
-    this.createQueryDot();
-    this.animate();
-
-    effect(() => {
-      const qv = this.state.queryVector();
-      if (qv && this.queryDot) {
-        this.queryDot.position.set(qv[0], qv[1], qv[2]);
-        (this.queryDot.material as THREE.MeshBasicMaterial).opacity = 1;
-        this.updateNearestNeighborLines(qv);
-      }
-    });
-
-    effect(() => {
-      const points = this.state.vectorPoints();
-      if (points.length > 0) this.buildPointCloud();
-    });
-  }
-
-  ngOnDestroy(): void {
-    cancelAnimationFrame(this.animationId);
-    this.renderer?.dispose();
-  }
-
-  onMouseMove(event: MouseEvent): void {
-    const rect = this.canvasContainer.nativeElement.getBoundingClientRect();
-    this.mouseX = ((event.clientX - rect.left) / rect.width) * 2 - 1;
-    this.mouseY = -((event.clientY - rect.top) / rect.height) * 2 + 1;
-  }
-
-  private initScene(): void {
-    const container = this.canvasContainer.nativeElement;
-    const width = container.clientWidth;
-    const height = container.clientHeight;
-
-    this.scene = new THREE.Scene();
-    this.camera = new THREE.PerspectiveCamera(55, width / height, 0.1, 500);
-    this.camera.position.z = 70;
-
-    this.renderer = new THREE.WebGLRenderer({ antialias: true, alpha: true });
-    this.renderer.setSize(width, height);
-    this.renderer.setPixelRatio(Math.min(window.devicePixelRatio, 2));
-    this.renderer.setClearColor(0x000000, 0);
-    container.appendChild(this.renderer.domElement);
-
-    const observer = new ResizeObserver(() => {
-      const w = container.clientWidth;
-      const h = container.clientHeight;
-      this.camera.aspect = w / h;
-      this.camera.updateProjectionMatrix();
-      this.renderer.setSize(w, h);
-    });
-    observer.observe(container);
-  }
-
-  private buildPointCloud(): void {
-    if (this.pointsMesh) this.scene.remove(this.pointsMesh);
-
-    const points = this.state.vectorPoints();
-    if (points.length === 0) return;
-
-    const positions = new Float32Array(points.length * 3);
-    const colors = new Float32Array(points.length * 3);
-    const sizes = new Float32Array(points.length);
-
-    for (let i = 0; i < points.length; i++) {
-      const p = points[i];
-      positions[i * 3] = p.position[0];
-      positions[i * 3 + 1] = p.position[1];
-      positions[i * 3 + 2] = p.position[2];
-
-      const color = new THREE.Color(TIER_COLORS[p.tier] || 0xffffff);
-      colors[i * 3] = color.r;
-      colors[i * 3 + 1] = color.g;
-      colors[i * 3 + 2] = color.b;
-
-      sizes[i] = 1.5 + p.importance * 3;
-    }
-
-    const geometry = new THREE.BufferGeometry();
-    geometry.setAttribute('position', new THREE.BufferAttribute(positions, 3));
-    geometry.setAttribute('color', new THREE.BufferAttribute(colors, 3));
-    geometry.setAttribute('size', new THREE.BufferAttribute(sizes, 1));
-
-    const material = new THREE.PointsMaterial({
-      size: 2,
-      vertexColors: true,
-      transparent: true,
-      opacity: 0.7,
-      sizeAttenuation: true,
-    });
-
-    this.pointsMesh = new THREE.Points(geometry, material);
-    this.scene.add(this.pointsMesh);
-  }
-
-  private createQueryDot(): void {
-    const geometry = new THREE.SphereGeometry(1.2, 16, 16);
-    const material = new THREE.MeshBasicMaterial({
-      color: 0xffffff, transparent: true, opacity: 0,
-    });
-    this.queryDot = new THREE.Mesh(geometry, material);
-    this.scene.add(this.queryDot);
-
-    // Outer ring
-    const ringGeometry = new THREE.RingGeometry(1.8, 2.2, 32);
-    const ringMaterial = new THREE.MeshBasicMaterial({
-      color: 0xffffff, transparent: true, opacity: 0, side: THREE.DoubleSide,
-    });
-    const ring = new THREE.Mesh(ringGeometry, ringMaterial);
-    this.queryDot.add(ring);
-  }
-
-  private updateNearestNeighborLines(queryPos: [number, number, number]): void {
-    this.nearestLines.forEach(l => this.scene.remove(l));
-    this.nearestLines = [];
-
-    const points = this.state.vectorPoints();
-    const qVec = new THREE.Vector3(queryPos[0], queryPos[1], queryPos[2]);
-
-    // Find 5 nearest
-    const sorted = points
-      .map((p, i) => ({
-        index: i,
-        dist: qVec.distanceTo(new THREE.Vector3(p.position[0], p.position[1], p.position[2])),
-      }))
-      .sort((a, b) => a.dist - b.dist)
-      .slice(0, 5);
-
-    for (const nearest of sorted) {
-      const p = points[nearest.index];
-      const material = new THREE.LineBasicMaterial({
-        color: 0xffffff, transparent: true, opacity: 0.4,
-      });
-      const geometry = new THREE.BufferGeometry().setFromPoints([
-        qVec,
-        new THREE.Vector3(p.position[0], p.position[1], p.position[2]),
-      ]);
-      const line = new THREE.Line(geometry, material);
-      this.scene.add(line);
-      this.nearestLines.push(line);
-    }
-  }
-
-  private animate(): void {
-    this.animationId = requestAnimationFrame(() => this.animate());
-    const time = this.clock.getElapsedTime();
-
-    this.camera.position.x = 70 * Math.sin(time * 0.03) + this.mouseX * 10;
-    this.camera.position.y = 30 * Math.sin(time * 0.02) + this.mouseY * 10;
-    this.camera.lookAt(0, 0, 0);
-
-    // Pulse query dot
-    if (this.queryDot) {
-      const mat = this.queryDot.material as THREE.MeshBasicMaterial;
-      if (mat.opacity > 0.01) {
-        mat.opacity *= 0.998;
-      }
-      this.queryDot.scale.setScalar(1 + Math.sin(time * 3) * 0.1);
-    }
-
-    // Fade nearest lines
-    for (const line of this.nearestLines) {
-      const mat = line.material as THREE.LineBasicMaterial;
-      if (mat.opacity > 0.05) mat.opacity *= 0.999;
-    }
-
-    this.renderer.render(this.scene, this.camera);
-  }
-}
diff --git a/spector-cortex/src/app/features/zeigarnik-tracker/zeigarnik-tracker.component.html b/spector-cortex/src/app/features/zeigarnik-tracker/zeigarnik-tracker.component.html
deleted file mode 100644
index 030c7ab..0000000
--- a/spector-cortex/src/app/features/zeigarnik-tracker/zeigarnik-tracker.component.html
+++ /dev/null
@@ -1,33 +0,0 @@
-<div class="tracker-container">
-  <div class="tracker-header">
-    <mat-icon class="tracker-icon pulse-icon">pending_actions</mat-icon>
-    <span class="tracker-title">Zeigarnik Effect</span>
-  </div>
-
-  <div class="tracker-body">
-    <div class="big-number" [class.warning]="state.zeigarnikPercentage() > 25">
-      <span class="number cortex-mono">{{ state.unresolvedCount() }}</span>
-      <span class="label">Unresolved</span>
-    </div>
-    <div class="tracker-divider"></div>
-    <div class="big-number">
-      <span class="number cortex-mono">{{ state.totalTaskCount() }}</span>
-      <span class="label">Total</span>
-    </div>
-    <div class="tracker-divider"></div>
-    <div class="big-number" [class.warning]="state.zeigarnikPercentage() > 25">
-      <span class="number cortex-mono">{{ state.zeigarnikPercentage() }}%</span>
-      <span class="label">Open Rate</span>
-    </div>
-  </div>
-
-  <div class="tension-bar-track">
-    <div class="tension-bar"
-         [style.width.%]="state.zeigarnikPercentage()"
-         [class.tension-high]="state.zeigarnikPercentage() > 25">
-    </div>
-  </div>
-  <div class="tension-label" matTooltip="Unresolved memories create cognitive tension that biases recall">
-    Cognitive Tension
-  </div>
-</div>
diff --git a/spector-cortex/src/app/features/zeigarnik-tracker/zeigarnik-tracker.component.scss b/spector-cortex/src/app/features/zeigarnik-tracker/zeigarnik-tracker.component.scss
deleted file mode 100644
index eacd126..0000000
--- a/spector-cortex/src/app/features/zeigarnik-tracker/zeigarnik-tracker.component.scss
+++ /dev/null
@@ -1,25 +0,0 @@
-:host { display: block; flex: 1; min-height: 0; }
-.tracker-container { padding: 12px 16px; display: flex; flex-direction: column; gap: 10px; }
-.tracker-header {
-  display: flex; align-items: center; gap: 6px;
-}
-.tracker-icon { color: var(--mat-sys-tertiary); font-size: 18px; width: 18px; height: 18px; }
-.pulse-icon { animation: pulse-glow 2s ease-in-out infinite; }
-.tracker-title { font-size: 11px; font-weight: 600; color: var(--mat-sys-on-surface-variant); text-transform: uppercase; letter-spacing: 0.06em; }
-.tracker-body { display: flex; align-items: center; justify-content: space-around; gap: 8px; }
-.tracker-divider { width: 1px; height: 32px; background: var(--mat-sys-outline-variant); }
-.big-number {
-  display: flex; flex-direction: column; align-items: center; gap: 2px;
-  .number { font-size: 22px; font-weight: 700; color: var(--mat-sys-on-surface); transition: color 0.3s ease; }
-  .label { font-size: 9px; font-weight: 500; color: var(--mat-sys-on-surface-variant); text-transform: uppercase; letter-spacing: 0.06em; }
-  &.warning .number { color: var(--mat-sys-error); }
-}
-.tension-bar-track {
-  height: 4px; border-radius: 2px; background: var(--mat-sys-surface-container-highest); overflow: hidden;
-}
-.tension-bar {
-  height: 100%; border-radius: 2px; background: var(--mat-sys-tertiary);
-  transition: width 0.6s cubic-bezier(0.4, 0, 0.2, 1), background 0.3s ease;
-  &.tension-high { background: var(--mat-sys-error); animation: pulse-glow 1.5s ease-in-out infinite; }
-}
-.tension-label { font-size: 9px; color: var(--mat-sys-on-surface-variant); text-align: center; cursor: help; }
diff --git a/spector-cortex/src/app/features/zeigarnik-tracker/zeigarnik-tracker.component.ts b/spector-cortex/src/app/features/zeigarnik-tracker/zeigarnik-tracker.component.ts
deleted file mode 100644
index 62f0f4b..0000000
--- a/spector-cortex/src/app/features/zeigarnik-tracker/zeigarnik-tracker.component.ts
+++ /dev/null
@@ -1,14 +0,0 @@
-import { Component, inject } from '@angular/core';
-import { MatIconModule } from '@angular/material/icon';
-import { MatTooltipModule } from '@angular/material/tooltip';
-import { CortexStateService } from '../../core/services/cortex-state.service';
-
-@Component({
-  selector: 'cortex-zeigarnik-tracker',
-  imports: [MatIconModule, MatTooltipModule],
-  templateUrl: './zeigarnik-tracker.component.html',
-  styleUrl: './zeigarnik-tracker.component.scss',
-})
-export class ZeigarnikTrackerComponent {
-  protected readonly state = inject(CortexStateService);
-}
diff --git a/spector-cortex/src/index.html b/spector-cortex/src/index.html
deleted file mode 100644
index d7bb2a2..0000000
--- a/spector-cortex/src/index.html
+++ /dev/null
@@ -1,18 +0,0 @@
-<!DOCTYPE html>
-<html lang="en" data-theme="dark">
-<head>
-  <meta charset="utf-8" />
-  <title>Spector Cortex — Neural Visualization Dashboard</title>
-  <meta name="description" content="Real-time neural visualization dashboard for Spector Memory — SIMD lanes, vector spaces, Hebbian graphs, and cognitive scoring pipelines." />
-  <meta name="viewport" content="width=device-width, initial-scale=1" />
-  <base href="/" />
-  <link rel="icon" type="image/x-icon" href="favicon.ico" />
-  <link rel="preconnect" href="https://fonts.googleapis.com" />
-  <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
-  <link href="https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700&family=JetBrains+Mono:wght@400;500;600&display=swap" rel="stylesheet" />
-  <link href="https://fonts.googleapis.com/icon?family=Material+Icons" rel="stylesheet" />
-</head>
-<body>
-  <cortex-root></cortex-root>
-</body>
-</html>
diff --git a/spector-cortex/src/main.ts b/spector-cortex/src/main.ts
deleted file mode 100644
index 5df75f9..0000000
--- a/spector-cortex/src/main.ts
+++ /dev/null
@@ -1,6 +0,0 @@
-import { bootstrapApplication } from '@angular/platform-browser';
-import { appConfig } from './app/app.config';
-import { App } from './app/app';
-
-bootstrapApplication(App, appConfig)
-  .catch((err) => console.error(err));
diff --git a/spector-cortex/src/styles.scss b/spector-cortex/src/styles.scss
deleted file mode 100644
index 2d5a0ba..0000000
--- a/spector-cortex/src/styles.scss
+++ /dev/null
@@ -1,169 +0,0 @@
-// ═══════════════════════════════════════════════════════════════════════
-// Spector Cortex — Global Styles & M3 Theme
-// ═══════════════════════════════════════════════════════════════════════
-@use '@angular/material' as mat;
-
-// ── M3 Theme Definition ────────────────────────────────────────────────
-// Deep purple seed for neural/brain aesthetic
-html {
-  @include mat.theme((
-    color: (
-      primary: mat.$violet-palette,
-      tertiary: mat.$cyan-palette,
-      theme-type: dark,
-    ),
-    typography: (
-      brand-family: 'Inter, system-ui, -apple-system, sans-serif',
-      plain-family: 'Inter, system-ui, -apple-system, sans-serif',
-    ),
-    density: 0,
-  ));
-
-  color-scheme: dark;
-}
-
-// ── Light Theme Override ───────────────────────────────────────────────
-html[data-theme='light'] {
-  @include mat.theme((
-    color: (
-      primary: mat.$violet-palette,
-      tertiary: mat.$cyan-palette,
-      theme-type: light,
-    ),
-    typography: (
-      brand-family: 'Inter, system-ui, -apple-system, sans-serif',
-      plain-family: 'Inter, system-ui, -apple-system, sans-serif',
-    ),
-    density: 0,
-  ));
-
-  color-scheme: light;
-}
-
-// ── Google Fonts ───────────────────────────────────────────────────────
-// Fonts loaded via <link> tags in index.html (Inter + JetBrains Mono)
-
-// ── CSS Reset & Base ───────────────────────────────────────────────────
-*,
-*::before,
-*::after {
-  box-sizing: border-box;
-  margin: 0;
-  padding: 0;
-}
-
-html, body {
-  height: 100%;
-  width: 100%;
-  overflow: hidden;
-  font-family: var(--mat-sys-body-medium-font);
-  background-color: var(--mat-sys-surface);
-  color: var(--mat-sys-on-surface);
-  -webkit-font-smoothing: antialiased;
-  -moz-osx-font-smoothing: grayscale;
-}
-
-// ── Scrollbar Styling ──────────────────────────────────────────────────
-::-webkit-scrollbar {
-  width: 6px;
-  height: 6px;
-}
-
-::-webkit-scrollbar-track {
-  background: transparent;
-}
-
-::-webkit-scrollbar-thumb {
-  background: var(--mat-sys-outline-variant);
-  border-radius: 3px;
-
-  &:hover {
-    background: var(--mat-sys-outline);
-  }
-}
-
-// ── Global Keyframe Animations ─────────────────────────────────────────
-@keyframes pulse-glow {
-  0%, 100% { opacity: 0.4; }
-  50% { opacity: 1; }
-}
-
-@keyframes pulse-ring {
-  0% {
-    transform: scale(1);
-    opacity: 0.6;
-  }
-  100% {
-    transform: scale(1.8);
-    opacity: 0;
-  }
-}
-
-@keyframes fade-in-up {
-  from {
-    opacity: 0;
-    transform: translateY(12px);
-  }
-  to {
-    opacity: 1;
-    transform: translateY(0);
-  }
-}
-
-@keyframes shimmer {
-  0% { background-position: -200% 0; }
-  100% { background-position: 200% 0; }
-}
-
-@keyframes breathe {
-  0%, 100% { transform: scale(1); }
-  50% { transform: scale(1.02); }
-}
-
-@keyframes slide-in-right {
-  from {
-    opacity: 0;
-    transform: translateX(20px);
-  }
-  to {
-    opacity: 1;
-    transform: translateX(0);
-  }
-}
-
-@keyframes neuron-fire {
-  0% {
-    box-shadow: 0 0 4px var(--mat-sys-primary);
-  }
-  50% {
-    box-shadow: 0 0 24px var(--mat-sys-primary), 0 0 48px var(--mat-sys-primary);
-  }
-  100% {
-    box-shadow: 0 0 4px var(--mat-sys-primary);
-  }
-}
-
-// ── Utility Classes ────────────────────────────────────────────────────
-.cortex-glass {
-  background: color-mix(in srgb, var(--mat-sys-surface-container) 80%, transparent);
-  backdrop-filter: blur(12px);
-  -webkit-backdrop-filter: blur(12px);
-  border: 1px solid var(--mat-sys-outline-variant);
-}
-
-.cortex-card {
-  background: var(--mat-sys-surface-container);
-  border: 1px solid var(--mat-sys-outline-variant);
-  border-radius: 16px;
-  overflow: hidden;
-  transition: border-color 0.3s ease, box-shadow 0.3s ease;
-
-  &:hover {
-    border-color: var(--mat-sys-primary);
-    box-shadow: 0 0 20px color-mix(in srgb, var(--mat-sys-primary) 15%, transparent);
-  }
-}
-
-.cortex-mono {
-  font-family: 'JetBrains Mono', 'Fira Code', monospace;
-}
diff --git a/spector-cortex/tsconfig.app.json b/spector-cortex/tsconfig.app.json
deleted file mode 100644
index 264f459..0000000
--- a/spector-cortex/tsconfig.app.json
+++ /dev/null
@@ -1,15 +0,0 @@
-/* To learn more about Typescript configuration file: https://www.typescriptlang.org/docs/handbook/tsconfig-json.html. */
-/* To learn more about Angular compiler options: https://angular.dev/reference/configs/angular-compiler-options. */
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "outDir": "./out-tsc/app",
-    "types": []
-  },
-  "include": [
-    "src/**/*.ts"
-  ],
-  "exclude": [
-    "src/**/*.spec.ts"
-  ]
-}
diff --git a/spector-cortex/tsconfig.json b/spector-cortex/tsconfig.json
deleted file mode 100644
index ad457fa..0000000
--- a/spector-cortex/tsconfig.json
+++ /dev/null
@@ -1,30 +0,0 @@
-/* To learn more about Typescript configuration file: https://www.typescriptlang.org/docs/handbook/tsconfig-json.html. */
-/* To learn more about Angular compiler options: https://angular.dev/reference/configs/angular-compiler-options. */
-{
-  "compileOnSave": false,
-  "compilerOptions": {
-    "strict": true,
-    "noImplicitOverride": true,
-    "noPropertyAccessFromIndexSignature": true,
-    "noImplicitReturns": true,
-    "noFallthroughCasesInSwitch": true,
-    "skipLibCheck": true,
-    "isolatedModules": true,
-    "experimentalDecorators": true,
-    "importHelpers": true,
-    "target": "ES2022",
-    "module": "preserve"
-  },
-  "angularCompilerOptions": {
-    "enableI18nLegacyMessageIdFormat": false,
-    "strictInjectionParameters": true,
-    "strictInputAccessModifiers": true,
-    "strictTemplates": true
-  },
-  "files": [],
-  "references": [
-    {
-      "path": "./tsconfig.app.json"
-    }
-  ]
-}
diff --git a/spector-cortex/tsconfig.spec.json b/spector-cortex/tsconfig.spec.json
deleted file mode 100644
index d383706..0000000
--- a/spector-cortex/tsconfig.spec.json
+++ /dev/null
@@ -1,15 +0,0 @@
-/* To learn more about Typescript configuration file: https://www.typescriptlang.org/docs/handbook/tsconfig-json.html. */
-/* To learn more about Angular compiler options: https://angular.dev/reference/configs/angular-compiler-options. */
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "outDir": "./out-tsc/spec",
-    "types": [
-      "vitest/globals"
-    ]
-  },
-  "include": [
-    "src/**/*.d.ts",
-    "src/**/*.spec.ts"
-  ]
-}
diff --git a/spector-dist/README.md b/spector-dist/README.md
deleted file mode 100644
index 3a5d9cc..0000000
--- a/spector-dist/README.md
+++ /dev/null
@@ -1,72 +0,0 @@
-# spector-dist 📦
-
-> **Single fat JAR distribution — all Spector modules in one deployable artifact.**
-
-`spector-dist` uses the Maven Shade Plugin to produce a single executable JAR that includes the MCP server, CLI, runtime, engine, memory, and all dependencies.
-
----
-
-## 🏗️ What's Included
-
-```mermaid
-graph TD
-    DIST["spector-dist<br/><i>Fat JAR</i>"]
-    DIST --> MCP["spector-mcp<br/><i>MCP Server (stdio)</i>"]
-    DIST --> CLI["spector-cli<br/><i>spectorctl</i>"]
-    DIST --> RUNTIME["spector-runtime<br/><i>engine + memory</i>"]
-    DIST --> NODE["spector-node<br/><i>Armeria server</i>"]
-
-    RUNTIME --> ENGINE["spector-engine"]
-    RUNTIME --> MEMORY["spector-memory"]
-    RUNTIME --> INGESTION["spector-ingestion"]
-```
-
----
-
-## 🚀 Building
-
-```bash
-# Build the fat JAR (skip tests for speed)
-mvn package -pl spector-dist -am -DskipTests
-```
-
-Output: `spector-dist/target/spector.jar`
-
-## 🚀 Running
-
-```bash
-# Start the MCP server (for AI agents — Claude, Cursor, etc.)
-java --add-modules jdk.incubator.vector \
-  --enable-native-access=ALL-UNNAMED --enable-preview \
-  -jar spector-dist/target/spector.jar \
-  --config spector.yml
-
-# Start the Armeria node (REST + gRPC + SSE)
-java --add-modules jdk.incubator.vector \
-  --enable-native-access=ALL-UNNAMED --enable-preview \
-  -cp spector-dist/target/spector.jar \
-  com.spectrayan.spector.node.SpectorNode
-
-# Start the file ingestion pipeline
-java --add-modules jdk.incubator.vector \
-  --enable-native-access=ALL-UNNAMED --enable-preview \
-  -cp spector-dist/target/spector.jar \
-  com.spectrayan.spector.ingestion.FileIngestionMain \
-  --config spector.yml --root .
-```
-
----
-
-## 📊 JAR Contents
-
-The shaded JAR contains all transitive dependencies:
-
-| Component | Modules |
-|-----------|---------|
-| **Core** | spector-core, spector-commons, spector-config, spector-storage |
-| **Search** | spector-index, spector-query, spector-gpu |
-| **Intelligence** | spector-embed-api, spector-embed-ollama, spector-rag |
-| **Engine** | spector-engine, spector-ingestion, spector-memory |
-| **Runtime** | spector-runtime, spector-metrics |
-| **Interfaces** | spector-mcp, spector-node, spector-cli, spector-client |
-| **Integration** | spector-spring |
diff --git a/spector-dist/pom.xml b/spector-dist/pom.xml
deleted file mode 100644
index 4604c43..0000000
--- a/spector-dist/pom.xml
+++ /dev/null
@@ -1,94 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0"
-         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
-    <modelVersion>4.0.0</modelVersion>
-
-    <parent>
-        <groupId>com.spectrayan</groupId>
-        <artifactId>spector</artifactId>
-        <version>0.1.0-SNAPSHOT</version>
-    </parent>
-
-    <artifactId>spector-dist</artifactId>
-    <name>Spector Distribution</name>
-    <description>
-        Single fat JAR containing all Spector modules.
-        Default main class: SpectorMcpMain (MCP server).
-        Use -cp with the appropriate main class to run different tools:
-          - MCP Server:  com.spectrayan.spector.mcp.SpectorMcpMain
-          - CLI:         com.spectrayan.spector.cli.SpectorCtl
-    </description>
-
-    <dependencies>
-        <!-- ── MCP server (transitively pulls engine, commons, storage, index, etc.) ── -->
-        <dependency>
-            <groupId>com.spectrayan</groupId>
-            <artifactId>spector-mcp</artifactId>
-            <version>${project.version}</version>
-        </dependency>
-
-        <!-- ── Ingestion pipeline (FileIngestionService, FileIngestionMain) ── -->
-        <dependency>
-            <groupId>com.spectrayan</groupId>
-            <artifactId>spector-ingestion</artifactId>
-            <version>${project.version}</version>
-        </dependency>
-
-        <!-- ── Spector Runtime (engine + memory) ── -->
-        <dependency>
-            <groupId>com.spectrayan</groupId>
-            <artifactId>spector-runtime</artifactId>
-            <version>${project.version}</version>
-        </dependency>
-
-        <!-- ── CLI (spectorctl — ingest, search, status commands) ── -->
-        <dependency>
-            <groupId>com.spectrayan</groupId>
-            <artifactId>spector-cli</artifactId>
-            <version>${project.version}</version>
-        </dependency>
-
-        <!-- ── Runtime: Ollama embedding provider ── -->
-        <dependency>
-            <groupId>com.spectrayan</groupId>
-            <artifactId>spector-embed-ollama</artifactId>
-            <scope>runtime</scope>
-        </dependency>
-
-        <!-- ── Logging runtime ── -->
-        <dependency>
-            <groupId>ch.qos.logback</groupId>
-            <artifactId>logback-classic</artifactId>
-            <scope>runtime</scope>
-        </dependency>
-    </dependencies>
-
-    <build>
-        <plugins>
-            <!-- Single fat JAR with all modules -->
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-shade-plugin</artifactId>
-                <executions>
-                    <execution>
-                        <phase>package</phase>
-                        <goals>
-                            <goal>shade</goal>
-                        </goals>
-                        <configuration>
-                            <transformers>
-                                <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
-                                    <mainClass>com.spectrayan.spector.mcp.SpectorMcpMain</mainClass>
-                                </transformer>
-                                <transformer implementation="org.apache.maven.plugins.shade.resource.ServicesResourceTransformer"/>
-                            </transformers>
-                            <finalName>spector</finalName>
-                        </configuration>
-                    </execution>
-                </executions>
-            </plugin>
-        </plugins>
-    </build>
-
-</project>
diff --git a/spector-embed-api/README.md b/spector-embed-api/README.md
deleted file mode 100644
index e54634b..0000000
--- a/spector-embed-api/README.md
+++ /dev/null
@@ -1,33 +0,0 @@
-# spector-embed-api 🧬
-
-> **The pluggable Embedding Provider Service Provider Interface (SPI) contract for Spector.**
-
-`spector-embed-api` defines the public SPI contract that allows developers to plug custom text embedding generators into the Spector ingestion and query pipelines. This ensures that Spector remains completely independent of any specific LLM provider or hosting environment.
-
----
-
-## 🏗️ Core Architecture & Contract
-
-### 1. `EmbeddingProvider`
-The core SPI interface that all embedding connectors must implement:
-```java
-public interface EmbeddingProvider extends AutoCloseable {
-    /** Generates a single float32 embedding vector for the text. */
-    float[] embed(String text) throws Exception;
-
-    /** Batch generates embeddings in parallel for a collection of texts. */
-    float[][] embedBatch(List<String> texts) throws Exception;
-
-    /** Returns the dimensionality of the generated vectors. */
-    int dimensions();
-
-    /** Returns the model identifier. */
-    String modelName();
-}
-```
-
----
-
-## 🚀 Usage
-
-To register a custom provider, implement `EmbeddingProvider` and register it using standard Java `ServiceLoader` declarations or wire it directly to the Spector Config builder during engine startup.
diff --git a/spector-embed-api/pom.xml b/spector-embed-api/pom.xml
index 16a8dd2..9678842 100644
--- a/spector-embed-api/pom.xml
+++ b/spector-embed-api/pom.xml
@@ -6,7 +6,7 @@
 
     <parent>
         <groupId>com.spectrayan</groupId>
-        <artifactId>spector</artifactId>
+        <artifactId>spector-search</artifactId>
         <version>0.1.0-SNAPSHOT</version>
     </parent>
 
@@ -14,11 +14,6 @@
     <name>Spector Embedding API</name>
     <description>SPI interface for embedding providers. Zero dependencies — implement this to plug in any embedding model.</description>
 
-    <dependencies>
-        <dependency>
-            <groupId>com.spectrayan</groupId>
-            <artifactId>spector-commons</artifactId>
-        </dependency>
-    </dependencies>
+    <!-- No internal dependencies — this is a pure SPI module -->
 
 </project>
diff --git a/spector-embed-api/src/main/java/com/spectrayan/spector/embed/EmbedConfig.java b/spector-embed-api/src/main/java/com/spectrayan/spector/embed/EmbedConfig.java
index 9cf1577..9acf607 100644
--- a/spector-embed-api/src/main/java/com/spectrayan/spector/embed/EmbedConfig.java
+++ b/spector-embed-api/src/main/java/com/spectrayan/spector/embed/EmbedConfig.java
@@ -1,23 +1,5 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.embed;
 
-import com.spectrayan.spector.commons.error.ErrorCode;
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-
 /**
  * Configuration for the parallel embedding pipeline.
  *
@@ -31,10 +13,10 @@ public record EmbedConfig(int batchSize, int maxRetries) {
 
     public EmbedConfig {
         if (batchSize <= 0) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_OUT_OF_RANGE, "batchSize", 1, Integer.MAX_VALUE, batchSize);
+            throw new IllegalArgumentException("batchSize must be > 0, got: " + batchSize);
         }
         if (maxRetries < 0) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_NEGATIVE, "maxRetries", maxRetries);
+            throw new IllegalArgumentException("maxRetries must be >= 0, got: " + maxRetries);
         }
     }
 }
diff --git a/spector-embed-api/src/main/java/com/spectrayan/spector/embed/EmbeddingConfig.java b/spector-embed-api/src/main/java/com/spectrayan/spector/embed/EmbeddingConfig.java
index 50e8750..3655b7a 100644
--- a/spector-embed-api/src/main/java/com/spectrayan/spector/embed/EmbeddingConfig.java
+++ b/spector-embed-api/src/main/java/com/spectrayan/spector/embed/EmbeddingConfig.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.embed;
 
 import java.time.Duration;
diff --git a/spector-embed-api/src/main/java/com/spectrayan/spector/embed/EmbeddingException.java b/spector-embed-api/src/main/java/com/spectrayan/spector/embed/EmbeddingException.java
new file mode 100644
index 0000000..c73fe0e
--- /dev/null
+++ b/spector-embed-api/src/main/java/com/spectrayan/spector/embed/EmbeddingException.java
@@ -0,0 +1,18 @@
+package com.spectrayan.spector.embed;
+
+/**
+ * Exception thrown when an embedding operation fails.
+ *
+ * <p>Wraps transport errors, model errors, and timeout failures
+ * from any {@link EmbeddingProvider} implementation.</p>
+ */
+public class EmbeddingException extends RuntimeException {
+
+    public EmbeddingException(String message) {
+        super(message);
+    }
+
+    public EmbeddingException(String message, Throwable cause) {
+        super(message, cause);
+    }
+}
diff --git a/spector-embed-api/src/main/java/com/spectrayan/spector/embed/EmbeddingProvider.java b/spector-embed-api/src/main/java/com/spectrayan/spector/embed/EmbeddingProvider.java
index 75dc9d3..93ab829 100644
--- a/spector-embed-api/src/main/java/com/spectrayan/spector/embed/EmbeddingProvider.java
+++ b/spector-embed-api/src/main/java/com/spectrayan/spector/embed/EmbeddingProvider.java
@@ -1,22 +1,5 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.embed;
 
-import com.spectrayan.spector.commons.error.SpectorEmbeddingException;
-
 import java.util.List;
 
 /**
@@ -57,7 +40,7 @@ public interface EmbeddingProvider extends AutoCloseable {
      *
      * @param text the input text
      * @return embedding result containing the vector
-     * @throws SpectorEmbeddingException if embedding fails
+     * @throws EmbeddingException if embedding fails
      */
     EmbeddingResult embed(String text);
 
@@ -69,7 +52,7 @@ public interface EmbeddingProvider extends AutoCloseable {
      *
      * @param texts list of input texts
      * @return list of embedding results (same order as input)
-     * @throws SpectorEmbeddingException if embedding fails
+     * @throws EmbeddingException if embedding fails
      */
     default List<EmbeddingResult> embedBatch(List<String> texts) {
         return texts.stream().map(this::embed).toList();
diff --git a/spector-embed-api/src/main/java/com/spectrayan/spector/embed/EmbeddingResult.java b/spector-embed-api/src/main/java/com/spectrayan/spector/embed/EmbeddingResult.java
index cf00602..ed1c28f 100644
--- a/spector-embed-api/src/main/java/com/spectrayan/spector/embed/EmbeddingResult.java
+++ b/spector-embed-api/src/main/java/com/spectrayan/spector/embed/EmbeddingResult.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.embed;
 
 /**
diff --git a/spector-embed-api/src/main/java/com/spectrayan/spector/embed/GenerationOptions.java b/spector-embed-api/src/main/java/com/spectrayan/spector/embed/GenerationOptions.java
deleted file mode 100644
index 2dbec0e..0000000
--- a/spector-embed-api/src/main/java/com/spectrayan/spector/embed/GenerationOptions.java
+++ /dev/null
@@ -1,61 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.embed;
-
-/**
- * Configuration options for text generation.
- *
- * @param temperature  sampling temperature (0.0 = deterministic, 1.0 = creative)
- * @param maxTokens    maximum tokens to generate
- * @param topP         nucleus sampling threshold
- * @param stopSequences stop generation at any of these sequences
- */
-public record GenerationOptions(
-        float temperature,
-        int maxTokens,
-        float topP,
-        String[] stopSequences
-) {
-
-    /** Default options: deterministic, 512 max tokens. */
-    public static final GenerationOptions DEFAULT = new GenerationOptions(0.1f, 512, 0.9f, new String[0]);
-
-    /** Creative options: higher temperature for synthesis. */
-    public static final GenerationOptions CREATIVE = new GenerationOptions(0.7f, 1024, 0.95f, new String[0]);
-
-    /** Concise options: short, factual output for reflection. */
-    public static final GenerationOptions CONCISE = new GenerationOptions(0.1f, 256, 0.9f, new String[0]);
-
-    public static Builder builder() {
-        return new Builder();
-    }
-
-    public static final class Builder {
-        private float temperature = 0.1f;
-        private int maxTokens = 512;
-        private float topP = 0.9f;
-        private String[] stopSequences = new String[0];
-
-        public Builder temperature(float t) { this.temperature = t; return this; }
-        public Builder maxTokens(int m) { this.maxTokens = m; return this; }
-        public Builder topP(float p) { this.topP = p; return this; }
-        public Builder stopSequences(String... s) { this.stopSequences = s; return this; }
-
-        public GenerationOptions build() {
-            return new GenerationOptions(temperature, maxTokens, topP, stopSequences);
-        }
-    }
-}
diff --git a/spector-embed-api/src/main/java/com/spectrayan/spector/embed/ParallelEmbeddingPipeline.java b/spector-embed-api/src/main/java/com/spectrayan/spector/embed/ParallelEmbeddingPipeline.java
index 9e96225..d2dfd78 100644
--- a/spector-embed-api/src/main/java/com/spectrayan/spector/embed/ParallelEmbeddingPipeline.java
+++ b/spector-embed-api/src/main/java/com/spectrayan/spector/embed/ParallelEmbeddingPipeline.java
@@ -1,51 +1,24 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.embed;
 
-import com.spectrayan.spector.commons.concurrent.ConcurrentExecutionException;
-import com.spectrayan.spector.commons.concurrent.ConcurrentTasks;
-
 import java.util.ArrayList;
 import java.util.List;
-import java.util.concurrent.Callable;
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-import com.spectrayan.spector.commons.error.ErrorCode;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
 
 /**
  * Parallel embedding pipeline that processes text chunks in configurable batches
- * using structured concurrency.
+ * using virtual threads.
  *
  * <p>Features:</p>
  * <ul>
  *   <li>Configurable batch sizes for grouping chunks</li>
- *   <li>Structured concurrency-based parallelism via {@link ConcurrentTasks}</li>
+ *   <li>Virtual thread-based parallelism for concurrent batch processing</li>
  *   <li>Retry logic for failed batches with configurable retry count</li>
  *   <li>Failure isolation: failed batches don't block remaining batches</li>
  *   <li>Ordering preservation: output[i] always corresponds to input[i]</li>
  * </ul>
  *
- * <h3>Concurrency</h3>
- * <p>Uses {@link ConcurrentTasks#forkJoinAll} which provides dual-mode concurrency:
- * structured concurrency (JEP 505) by default, or classic virtual-thread executor
- * when disabled via {@code -Dspector.concurrency.structured=false}.</p>
- *
- * <p>Since {@code processBatch()} handles all exceptions internally and never throws,
- * the structured concurrency fail-fast behavior is safe — it won't cancel sibling
- * batches on failure.</p>
- *
  * <p>Validates: Requirements 7.1, 7.2, 7.3, 7.4</p>
  */
 public class ParallelEmbeddingPipeline {
@@ -59,7 +32,7 @@ public class ParallelEmbeddingPipeline {
      */
     public ParallelEmbeddingPipeline(EmbeddingProvider provider) {
         if (provider == null) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_NULL, "provider");
+            throw new IllegalArgumentException("provider must not be null");
         }
         this.provider = provider;
     }
@@ -68,7 +41,7 @@ public ParallelEmbeddingPipeline(EmbeddingProvider provider) {
      * Embeds a list of text chunks in parallel batches.
      *
      * <p>Chunks are split into batches of {@code config.batchSize()}, and each batch
-     * is submitted concurrently via {@link ConcurrentTasks}. Failed batches are
+     * is submitted to a virtual thread for concurrent processing. Failed batches are
      * retried up to {@code config.maxRetries()} times. If all retries are exhausted,
      * the failure is recorded and processing continues with remaining batches.</p>
      *
@@ -95,33 +68,36 @@ public List<PipelineEmbeddingResult> embed(List<String> texts, EmbedConfig confi
         List<List<String>> batches = partition(texts, batchSize);
         int numBatches = batches.size();
 
-        // Build tasks — each batch is a Callable that never throws
-        // (processBatch handles errors internally)
-        List<Callable<List<PipelineEmbeddingResult>>> tasks = new ArrayList<>(numBatches);
-        for (int batchIdx = 0; batchIdx < numBatches; batchIdx++) {
-            final List<String> batch = batches.get(batchIdx);
-            final int startIndex = batchIdx * batchSize;
-            final int retries = maxRetries;
-            tasks.add(() -> processBatch(batch, startIndex, retries));
-        }
+        // Results array preserving order; one sub-list per batch
+        @SuppressWarnings("unchecked")
+        List<PipelineEmbeddingResult>[] batchResults = new List[numBatches];
+
+        // Process batches in parallel using virtual threads
+        try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {
+            List<Future<List<PipelineEmbeddingResult>>> futures = new ArrayList<>(numBatches);
+
+            for (int batchIdx = 0; batchIdx < numBatches; batchIdx++) {
+                final int idx = batchIdx;
+                final List<String> batch = batches.get(idx);
+                final int startIndex = idx * batchSize;
+                final int retries = maxRetries;
 
-        // Execute all batches in parallel
-        List<List<PipelineEmbeddingResult>> batchResults;
-        try {
-            batchResults = ConcurrentTasks.forkJoinAll(tasks);
-        } catch (ConcurrentExecutionException | InterruptedException e) {
-            // Should not happen since processBatch handles errors internally,
-            // but handle defensively
-            if (e instanceof InterruptedException) {
-                Thread.currentThread().interrupt();
+                futures.add(executor.submit(() -> processBatch(batch, startIndex, retries)));
             }
-            // Fall back to failure results for all chunks
-            List<PipelineEmbeddingResult> failureResults = new ArrayList<>(totalChunks);
-            for (int i = 0; i < totalChunks; i++) {
-                failureResults.add(PipelineEmbeddingResult.failure(i,
-                        "Unexpected concurrent error: " + e.getMessage()));
+
+            // Collect results in order
+            for (int i = 0; i < numBatches; i++) {
+                try {
+                    batchResults[i] = futures.get(i).get();
+                } catch (Exception e) {
+                    // Should not happen since processBatch handles errors internally,
+                    // but handle defensively
+                    List<String> batch = batches.get(i);
+                    int startIndex = i * batchSize;
+                    batchResults[i] = createFailureResults(batch, startIndex,
+                            "Unexpected error: " + e.getMessage());
+                }
             }
-            return failureResults;
         }
 
         // Flatten batch results into a single ordered list
@@ -135,10 +111,6 @@ public List<PipelineEmbeddingResult> embed(List<String> texts, EmbedConfig confi
     /**
      * Processes a single batch with retry logic.
      *
-     * <p><b>Important:</b> This method never throws — it catches all exceptions
-     * and returns failure results. This is critical for structured concurrency
-     * compatibility, since throwing would cancel sibling batches.</p>
-     *
      * @param batch      the texts in this batch
      * @param startIndex the global index of the first chunk in this batch
      * @param maxRetries maximum retry attempts
diff --git a/spector-embed-api/src/main/java/com/spectrayan/spector/embed/PipelineEmbeddingResult.java b/spector-embed-api/src/main/java/com/spectrayan/spector/embed/PipelineEmbeddingResult.java
index d8e7f8d..62509f2 100644
--- a/spector-embed-api/src/main/java/com/spectrayan/spector/embed/PipelineEmbeddingResult.java
+++ b/spector-embed-api/src/main/java/com/spectrayan/spector/embed/PipelineEmbeddingResult.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.embed;
 
 /**
diff --git a/spector-embed-api/src/main/java/com/spectrayan/spector/embed/TextGenerationProvider.java b/spector-embed-api/src/main/java/com/spectrayan/spector/embed/TextGenerationProvider.java
deleted file mode 100644
index 8d99965..0000000
--- a/spector-embed-api/src/main/java/com/spectrayan/spector/embed/TextGenerationProvider.java
+++ /dev/null
@@ -1,102 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.embed;
-
-/**
- * Service Provider Interface for text generation (LLM inference).
- *
- * <p>Implementations send prompts to a language model and return generated text.
- * This is separate from {@link EmbeddingProvider} because embedding and generation
- * are fundamentally different operations — many providers support one but not both.</p>
- *
- * <h3>Contract</h3>
- * <ul>
- *   <li>{@link #generate(String)} must return a non-null response</li>
- *   <li>Implementations must be thread-safe</li>
- *   <li>Timeouts are implementation-specific (recommended: 30s default)</li>
- * </ul>
- *
- * <h3>Primary Use Case: Sleep Consolidation</h3>
- * <p>The {@code ReflectDaemon} uses this during REM Sleep to synthesize
- * semantic facts from episodic memory clusters:
- * <em>"Summarize these N memories into a factual rule."</em></p>
- *
- * <h3>Built-in Implementations</h3>
- * <ul>
- *   <li>Future: {@code OllamaGenerationProvider} — local Ollama server</li>
- *   <li>Future: {@code OpenAiGenerationProvider} — OpenAI API</li>
- * </ul>
- *
- * @see EmbeddingProvider
- */
-public interface TextGenerationProvider extends AutoCloseable {
-
-    /**
-     * Generates text from a prompt.
-     *
-     * @param prompt the input prompt
-     * @return generated text response
-     * @throws GenerationException if generation fails
-     */
-    String generate(String prompt);
-
-    /**
-     * Generates text with configurable options.
-     *
-     * @param prompt  the input prompt
-     * @param options generation configuration (temperature, max tokens, etc.)
-     * @return generated text response
-     * @throws GenerationException if generation fails
-     */
-    default String generate(String prompt, GenerationOptions options) {
-        return generate(prompt); // default ignores options
-    }
-
-    /**
-     * Returns the name of the underlying model.
-     *
-     * @return model identifier (e.g., "qwen3:8b", "gpt-4o")
-     */
-    String modelName();
-
-    /**
-     * Returns whether this provider is available and ready.
-     *
-     * @return true if the provider can accept generation requests
-     */
-    default boolean isAvailable() {
-        return true;
-    }
-
-    /**
-     * Default no-op close. Override if the provider holds resources.
-     */
-    @Override
-    default void close() {}
-
-    /**
-     * Exception thrown when text generation fails.
-     */
-    class GenerationException extends RuntimeException {
-        public GenerationException(String message) {
-            super(message);
-        }
-
-        public GenerationException(String message, Throwable cause) {
-            super(message, cause);
-        }
-    }
-}
diff --git a/spector-embed-api/src/main/java/com/spectrayan/spector/embed/error/SpectorEmbeddingTimeoutException.java b/spector-embed-api/src/main/java/com/spectrayan/spector/embed/error/SpectorEmbeddingTimeoutException.java
deleted file mode 100644
index 2720ff6..0000000
--- a/spector-embed-api/src/main/java/com/spectrayan/spector/embed/error/SpectorEmbeddingTimeoutException.java
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.embed.error;
-
-import com.spectrayan.spector.commons.error.*;
-
-/**
- * Exception thrown when an embedding request exceeds the configured timeout limits.
- *
- * @see SpectorEmbeddingException
- */
-public class SpectorEmbeddingTimeoutException extends SpectorEmbeddingException {
-
-    private final long timeoutMs;
-
-    public SpectorEmbeddingTimeoutException(long timeoutMs) {
-        super(ErrorCode.EMBEDDING_TIMEOUT, timeoutMs);
-        this.timeoutMs = timeoutMs;
-    }
-
-    public SpectorEmbeddingTimeoutException(long timeoutMs, Throwable cause) {
-        super(ErrorCode.EMBEDDING_TIMEOUT, cause, timeoutMs);
-        this.timeoutMs = timeoutMs;
-    }
-
-    /** Returns the timeout duration in milliseconds that was exceeded. */
-    public long getTimeoutMs() {
-        return timeoutMs;
-    }
-}
diff --git a/spector-embed-api/src/main/java/com/spectrayan/spector/embed/error/SpectorEmbeddingUnavailableException.java b/spector-embed-api/src/main/java/com/spectrayan/spector/embed/error/SpectorEmbeddingUnavailableException.java
deleted file mode 100644
index 9d356d6..0000000
--- a/spector-embed-api/src/main/java/com/spectrayan/spector/embed/error/SpectorEmbeddingUnavailableException.java
+++ /dev/null
@@ -1,53 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.embed.error;
-
-import com.spectrayan.spector.commons.error.*;
-
-/**
- * Exception thrown when the embedding provider or model is not reachable.
- *
- * @see SpectorEmbeddingException
- */
-public class SpectorEmbeddingUnavailableException extends SpectorEmbeddingException {
-
-    private final String provider;
-
-    public SpectorEmbeddingUnavailableException(String provider) {
-        super(ErrorCode.EMBEDDING_UNAVAILABLE, provider);
-        this.provider = provider;
-    }
-
-    public SpectorEmbeddingUnavailableException(String provider, Throwable cause) {
-        super(ErrorCode.EMBEDDING_UNAVAILABLE, cause, provider);
-        this.provider = provider;
-    }
-
-    public SpectorEmbeddingUnavailableException(ErrorCode errorCode, String provider) {
-        super(errorCode, provider);
-        this.provider = provider;
-    }
-
-    public SpectorEmbeddingUnavailableException(ErrorCode errorCode, Throwable cause, String provider) {
-        super(errorCode, cause, provider);
-        this.provider = provider;
-    }
-
-    /** Returns the name or URL of the embedding provider that is unavailable. */
-    public String getProvider() {
-        return provider;
-    }
-}
diff --git a/spector-embed-api/src/test/java/com/spectrayan/spector/embed/EmbeddingApiTest.java b/spector-embed-api/src/test/java/com/spectrayan/spector/embed/EmbeddingApiTest.java
index 839b42a..b0fb148 100644
--- a/spector-embed-api/src/test/java/com/spectrayan/spector/embed/EmbeddingApiTest.java
+++ b/spector-embed-api/src/test/java/com/spectrayan/spector/embed/EmbeddingApiTest.java
@@ -1,23 +1,5 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.embed;
 
-import com.spectrayan.spector.commons.error.SpectorEmbeddingException;
-import com.spectrayan.spector.commons.error.ErrorCode;
-
 import static org.assertj.core.api.Assertions.assertThat;
 
 import org.junit.jupiter.api.Test;
@@ -72,14 +54,14 @@ void embeddingConfigWithMethods() {
 
     @Test
     void embeddingExceptionMessage() {
-        var ex = new SpectorEmbeddingException(ErrorCode.EMBEDDING_REQUEST_FAILED, "test error");
-        assertThat(ex.getMessage()).contains("test error").contains("SPE-300-002");
+        var ex = new EmbeddingException("test error");
+        assertThat(ex.getMessage()).isEqualTo("test error");
     }
 
     @Test
     void embeddingExceptionWithCause() {
         var cause = new RuntimeException("root");
-        var ex = new SpectorEmbeddingException(ErrorCode.EMBEDDING_REQUEST_FAILED, cause, "wrapper");
+        var ex = new EmbeddingException("wrapper", cause);
         assertThat(ex.getCause()).isEqualTo(cause);
     }
 
diff --git a/spector-embed-api/src/test/java/com/spectrayan/spector/embed/ParallelEmbeddingPipelineTest.java b/spector-embed-api/src/test/java/com/spectrayan/spector/embed/ParallelEmbeddingPipelineTest.java
index 6c8b0dc..66b4ece 100644
--- a/spector-embed-api/src/test/java/com/spectrayan/spector/embed/ParallelEmbeddingPipelineTest.java
+++ b/spector-embed-api/src/test/java/com/spectrayan/spector/embed/ParallelEmbeddingPipelineTest.java
@@ -1,23 +1,5 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.embed;
 
-import com.spectrayan.spector.commons.error.SpectorEmbeddingException;
-import com.spectrayan.spector.commons.error.ErrorCode;
-
 import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.atomic.AtomicInteger;
@@ -102,7 +84,7 @@ public EmbeddingResult embed(String text) {
             @Override
             public List<EmbeddingResult> embedBatch(List<String> texts) {
                 if (callCount.incrementAndGet() <= 2) {
-                    throw new SpectorEmbeddingException(ErrorCode.EMBEDDING_REQUEST_FAILED, "Temporary failure");
+                    throw new EmbeddingException("Temporary failure");
                 }
                 return texts.stream().map(this::embed).toList();
             }
@@ -126,12 +108,12 @@ void allRetriesExhaustedReportsFailure() {
         EmbeddingProvider alwaysFails = new EmbeddingProvider() {
             @Override
             public EmbeddingResult embed(String text) {
-                throw new SpectorEmbeddingException(ErrorCode.EMBEDDING_REQUEST_FAILED, "Always fails");
+                throw new EmbeddingException("Always fails");
             }
 
             @Override
             public List<EmbeddingResult> embedBatch(List<String> texts) {
-                throw new SpectorEmbeddingException(ErrorCode.EMBEDDING_REQUEST_FAILED, "Always fails");
+                throw new EmbeddingException("Always fails");
             }
 
             @Override
@@ -166,7 +148,7 @@ public EmbeddingResult embed(String text) {
             public List<EmbeddingResult> embedBatch(List<String> texts) {
                 // Fail if the batch contains "fail"
                 if (texts.stream().anyMatch(t -> t.contains("fail"))) {
-                    throw new SpectorEmbeddingException(ErrorCode.EMBEDDING_REQUEST_FAILED, "Batch failed");
+                    throw new EmbeddingException("Batch failed");
                 }
                 return texts.stream().map(this::embed).toList();
             }
diff --git a/spector-embed-ollama/README.md b/spector-embed-ollama/README.md
deleted file mode 100644
index b01cc7d..0000000
--- a/spector-embed-ollama/README.md
+++ /dev/null
@@ -1,33 +0,0 @@
-# spector-embed-ollama 🤖
-
-> **Out-of-the-box Ollama embedding integration, fallback handling, and parallel batch calling for Spector.**
-
-`spector-embed-ollama` implements the `EmbeddingProvider` contract for local Ollama instances. It supports parallel API calls, high-throughput batching, automatic JSON escape handling, and resilient connection timeout fallbacks.
-
----
-
-## 🏗️ Core Architecture & Roles
-
-1. **`OllamaEmbeddingProvider`:** Connects to local or remote Ollama HTTP servers (e.g. `http://localhost:11434/api/embed`) using asynchronous JDK HTTP Clients.
-2. **Parallel GPU Batching:** Splits large text collections into optimal GPU batches (e.g., 500 vectors) to saturate local GPU accelerators.
-3. **Resiliency Fallbacks:** Manages connection pooling, HTTP request timeouts, and automatically retries failed batches to ensure ingestion pipeline safety.
-
----
-
-## 🚀 Key APIs
-
-### Configuring Ollama Provider
-```java
-// Connect to a local Ollama service running qwen3-embedding
-EmbeddingProvider provider = new OllamaEmbeddingProvider(
-    "http://localhost:11434",
-    "qwen3-embedding"
-);
-
-// Single vector generation
-float[] vector = provider.embed("Spector uses Panama FFM");
-
-// Batch generation
-List<String> sentences = List.of("First sentence", "Second sentence");
-float[][] batchVectors = provider.embedBatch(sentences);
-```
diff --git a/spector-embed-ollama/pom.xml b/spector-embed-ollama/pom.xml
index 0529591..bc8385c 100644
--- a/spector-embed-ollama/pom.xml
+++ b/spector-embed-ollama/pom.xml
@@ -6,7 +6,7 @@
 
     <parent>
         <groupId>com.spectrayan</groupId>
-        <artifactId>spector</artifactId>
+        <artifactId>spector-search</artifactId>
         <version>0.1.0-SNAPSHOT</version>
     </parent>
 
@@ -22,7 +22,7 @@
 
         <!-- Jackson for JSON parsing of Ollama responses -->
         <dependency>
-            <groupId>tools.jackson.core</groupId>
+            <groupId>com.fasterxml.jackson.core</groupId>
             <artifactId>jackson-databind</artifactId>
         </dependency>
     </dependencies>
diff --git a/spector-embed-ollama/src/main/java/com/spectrayan/spector/embed/ollama/OllamaEmbeddingProvider.java b/spector-embed-ollama/src/main/java/com/spectrayan/spector/embed/ollama/OllamaEmbeddingProvider.java
index 2f4231a..a05d59a 100644
--- a/spector-embed-ollama/src/main/java/com/spectrayan/spector/embed/ollama/OllamaEmbeddingProvider.java
+++ b/spector-embed-ollama/src/main/java/com/spectrayan/spector/embed/ollama/OllamaEmbeddingProvider.java
@@ -1,26 +1,10 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.embed.ollama;
 
-import tools.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
 import com.spectrayan.spector.embed.EmbeddingConfig;
-import com.spectrayan.spector.commons.error.SpectorEmbeddingException;
-import com.spectrayan.spector.embed.error.SpectorEmbeddingUnavailableException;
-import com.spectrayan.spector.embed.error.SpectorEmbeddingTimeoutException;
-import com.spectrayan.spector.commons.error.ErrorCode;
+import com.spectrayan.spector.embed.EmbeddingException;
 import com.spectrayan.spector.embed.EmbeddingProvider;
 import com.spectrayan.spector.embed.EmbeddingResult;
 
@@ -102,7 +86,7 @@ public static OllamaEmbeddingProvider createDefault() {
     @Override
     public EmbeddingResult embed(String text) {
         if (text == null || text.isBlank()) {
-            throw new SpectorEmbeddingException(ErrorCode.EMBEDDING_REQUEST_FAILED, "text must not be null or blank");
+            throw new EmbeddingException("Cannot embed null or blank text");
         }
 
         try {
@@ -121,22 +105,18 @@ public EmbeddingResult embed(String text) {
             HttpResponse<String> response = httpClient.send(request, HttpResponse.BodyHandlers.ofString());
 
             if (response.statusCode() != 200) {
-                throw new SpectorEmbeddingException(ErrorCode.EMBEDDING_REQUEST_FAILED, "Ollama returned HTTP " + response.statusCode()
+                throw new EmbeddingException("Ollama returned HTTP " + response.statusCode()
                         + ": " + response.body());
             }
 
             return parseEmbedResponse(response.body());
-        } catch (SpectorEmbeddingException e) {
+        } catch (EmbeddingException e) {
             throw e;
-        } catch (java.net.http.HttpTimeoutException e) {
-            throw new SpectorEmbeddingTimeoutException(config.timeout().toMillis(), e);
-        } catch (java.net.ConnectException | java.net.UnknownHostException e) {
-            throw new SpectorEmbeddingUnavailableException(config.baseUrl(), e);
         } catch (InterruptedException e) {
             Thread.currentThread().interrupt();
-            throw new SpectorEmbeddingException(ErrorCode.EMBEDDING_REQUEST_FAILED, e, "Embedding request interrupted");
+            throw new EmbeddingException("Embedding request interrupted", e);
         } catch (Exception e) {
-            throw new SpectorEmbeddingException(ErrorCode.EMBEDDING_REQUEST_FAILED, e, "Ollama: " + e.getMessage());
+            throw new EmbeddingException("Failed to embed text via Ollama: " + e.getMessage(), e);
         }
     }
 
@@ -161,22 +141,18 @@ public List<EmbeddingResult> embedBatch(List<String> texts) {
             HttpResponse<String> response = httpClient.send(request, HttpResponse.BodyHandlers.ofString());
 
             if (response.statusCode() != 200) {
-                throw new SpectorEmbeddingException(ErrorCode.EMBEDDING_REQUEST_FAILED, "Ollama batch returned HTTP " + response.statusCode()
+                throw new EmbeddingException("Ollama batch returned HTTP " + response.statusCode()
                         + ": " + response.body());
             }
 
             return parseBatchResponse(response.body());
-        } catch (SpectorEmbeddingException e) {
+        } catch (EmbeddingException e) {
             throw e;
-        } catch (java.net.http.HttpTimeoutException e) {
-            throw new SpectorEmbeddingTimeoutException(config.timeout().toMillis(), e);
-        } catch (java.net.ConnectException | java.net.UnknownHostException e) {
-            throw new SpectorEmbeddingUnavailableException(config.baseUrl(), e);
         } catch (InterruptedException e) {
             Thread.currentThread().interrupt();
-            throw new SpectorEmbeddingException(ErrorCode.EMBEDDING_REQUEST_FAILED, e, "batch embedding interrupted");
+            throw new EmbeddingException("Batch embedding interrupted", e);
         } catch (Exception e) {
-            throw new SpectorEmbeddingException(ErrorCode.EMBEDDING_REQUEST_FAILED, e, "Ollama batch: " + e.getMessage());
+            throw new EmbeddingException("Failed to batch embed via Ollama: " + e.getMessage(), e);
         }
     }
 
@@ -201,91 +177,59 @@ public EmbeddingConfig config() {
         return config;
     }
 
-    // ─────────────── Response parsing (streaming — avoids DOM tree overhead) ───────────────
+    // ─────────────── Response parsing ───────────────
 
     private EmbeddingResult parseEmbedResponse(String json) {
-        try (var parser = MAPPER.createParser(json)) {
-            float[] vector = parseFirstEmbedding(parser);
-            if (vector == null) {
-                throw new SpectorEmbeddingException(ErrorCode.EMBEDDING_REQUEST_FAILED, "no embeddings in Ollama response");
+        try {
+            JsonNode root = MAPPER.readTree(json);
+            JsonNode embeddings = root.get("embeddings");
+
+            if (embeddings == null || !embeddings.isArray() || embeddings.isEmpty()) {
+                throw new EmbeddingException("No embeddings in Ollama response: " + json);
             }
+
+            float[] vector = parseVector(embeddings.get(0));
             cachedDimensions = vector.length;
+
             return new EmbeddingResult(vector, -1, config.model());
-        } catch (SpectorEmbeddingException e) {
+        } catch (EmbeddingException e) {
             throw e;
         } catch (Exception e) {
-            throw new SpectorEmbeddingException(ErrorCode.EMBEDDING_REQUEST_FAILED, e, "failed to parse Ollama response");
+            throw new EmbeddingException("Failed to parse Ollama response: " + e.getMessage(), e);
         }
     }
 
     private List<EmbeddingResult> parseBatchResponse(String json) {
-        try (var parser = MAPPER.createParser(json)) {
-            List<EmbeddingResult> results = new ArrayList<>();
-            // Navigate to "embeddings" array
-            if (!advanceToEmbeddingsArray(parser)) {
-                throw new SpectorEmbeddingException(ErrorCode.EMBEDDING_REQUEST_FAILED, "no embeddings array in Ollama batch response");
+        try {
+            JsonNode root = MAPPER.readTree(json);
+            JsonNode embeddings = root.get("embeddings");
+
+            if (embeddings == null || !embeddings.isArray()) {
+                throw new EmbeddingException("No embeddings array in Ollama batch response");
             }
-            // Each element in the "embeddings" array is itself an array of floats
-            while (parser.nextToken() == tools.jackson.core.JsonToken.START_ARRAY) {
-                float[] vector = parseFloatArray(parser);
+
+            List<EmbeddingResult> results = new ArrayList<>();
+            for (JsonNode node : embeddings) {
+                float[] vector = parseVector(node);
                 results.add(new EmbeddingResult(vector, -1, config.model()));
             }
+
             if (!results.isEmpty()) {
                 cachedDimensions = results.getFirst().dimensions();
             }
             return results;
-        } catch (SpectorEmbeddingException e) {
+        } catch (EmbeddingException e) {
             throw e;
         } catch (Exception e) {
-            throw new SpectorEmbeddingException(ErrorCode.EMBEDDING_REQUEST_FAILED, e, "failed to parse Ollama batch response");
+            throw new EmbeddingException("Failed to parse Ollama batch response: " + e.getMessage(), e);
         }
     }
 
-    /**
-     * Streaming parse: navigates to the first embedding vector and reads it as float[].
-     * Avoids building a full JsonNode tree — O(dims) heap instead of O(dims × node_overhead).
-     */
-    private float[] parseFirstEmbedding(tools.jackson.core.JsonParser parser) throws java.io.IOException {
-        if (!advanceToEmbeddingsArray(parser)) return null;
-        // First element in "embeddings" array should be an array of floats
-        if (parser.nextToken() != tools.jackson.core.JsonToken.START_ARRAY) return null;
-        return parseFloatArray(parser);
-    }
-
-    /**
-     * Advances the parser to the start of the "embeddings" array.
-     * Returns true if found, false otherwise.
-     */
-    private boolean advanceToEmbeddingsArray(tools.jackson.core.JsonParser parser) throws java.io.IOException {
-        while (parser.nextToken() != null) {
-            if (parser.currentToken() == tools.jackson.core.JsonToken.PROPERTY_NAME
-                    && "embeddings".equals(parser.currentName())) {
-                // Next token should be START_ARRAY
-                return parser.nextToken() == tools.jackson.core.JsonToken.START_ARRAY;
-            }
+    private static float[] parseVector(JsonNode arrayNode) {
+        float[] vector = new float[arrayNode.size()];
+        for (int i = 0; i < vector.length; i++) {
+            vector[i] = (float) arrayNode.get(i).asDouble();
         }
-        return false;
-    }
-
-    /**
-     * Reads a JSON array of numbers into a float[].
-     * Assumes the parser is positioned right after START_ARRAY.
-     * Uses a growable list to handle unknown dimensions, then converts to float[].
-     */
-    private float[] parseFloatArray(tools.jackson.core.JsonParser parser) throws java.io.IOException {
-        // Use cached dimensions as initial capacity hint if known
-        int hint = cachedDimensions > 0 ? cachedDimensions : 768;
-        float[] buf = new float[hint];
-        int idx = 0;
-
-        while (parser.nextToken() != tools.jackson.core.JsonToken.END_ARRAY) {
-            if (idx >= buf.length) {
-                buf = java.util.Arrays.copyOf(buf, buf.length * 2);
-            }
-            buf[idx++] = parser.getFloatValue();
-        }
-
-        // Trim to exact size
-        return idx == buf.length ? buf : java.util.Arrays.copyOf(buf, idx);
+        return vector;
     }
 }
diff --git a/spector-embed-ollama/src/test/java/com/spectrayan/spector/embed/ollama/OllamaEmbeddingProviderTest.java b/spector-embed-ollama/src/test/java/com/spectrayan/spector/embed/ollama/OllamaEmbeddingProviderTest.java
index c4e938a..ce611be 100644
--- a/spector-embed-ollama/src/test/java/com/spectrayan/spector/embed/ollama/OllamaEmbeddingProviderTest.java
+++ b/spector-embed-ollama/src/test/java/com/spectrayan/spector/embed/ollama/OllamaEmbeddingProviderTest.java
@@ -1,26 +1,10 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.embed.ollama;
 
-import com.spectrayan.spector.commons.error.SpectorEmbeddingException;
-
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 
 import com.spectrayan.spector.embed.EmbeddingConfig;
+import com.spectrayan.spector.embed.EmbeddingException;
 
 import org.junit.jupiter.api.Test;
 
@@ -61,7 +45,7 @@ void customConfig() {
     void embedNullTextThrows() {
         var provider = OllamaEmbeddingProvider.create("test");
         assertThatThrownBy(() -> provider.embed(null))
-                .isInstanceOf(SpectorEmbeddingException.class)
+                .isInstanceOf(EmbeddingException.class)
                 .hasMessageContaining("blank");
     }
 
@@ -69,7 +53,7 @@ void embedNullTextThrows() {
     void embedBlankTextThrows() {
         var provider = OllamaEmbeddingProvider.create("test");
         assertThatThrownBy(() -> provider.embed("  "))
-                .isInstanceOf(SpectorEmbeddingException.class)
+                .isInstanceOf(EmbeddingException.class)
                 .hasMessageContaining("blank");
     }
 
@@ -86,7 +70,7 @@ void embedFailsWhenServerUnavailable() {
                 .withTimeout(Duration.ofMillis(500));
         var provider = new OllamaEmbeddingProvider(config);
         assertThatThrownBy(() -> provider.embed("test text"))
-                .isInstanceOf(SpectorEmbeddingException.class)
-                .hasMessageContaining("SPE-300");
+                .isInstanceOf(EmbeddingException.class)
+                .hasMessageContaining("Failed");
     }
 }
diff --git a/spector-engine/README.md b/spector-engine/README.md
deleted file mode 100644
index 6fb271f..0000000
--- a/spector-engine/README.md
+++ /dev/null
@@ -1,34 +0,0 @@
-# spector-engine ⚙️
-
-> **The unified developer-facing facade, lifecycle manager, and configuration orchestrator for Spector.**
-
-`spector-engine` acts as the primary developer gateway. It groups all separate indices (HNSW, IVF-PQ, BM25), off-heap FFM vector stores, GPU wrappers, and LLM re-rankers under a single, highly intuitive facade: **`SpectorEngine`**.
-
----
-
-## 🏗️ Core Architecture & Roles
-
-1. **Unified Facade (`SpectorEngine`):** Orchestrates document chunking, parallel embedding generation, postings insertion, and vector storage inside a single `ingest` call.
-2. **Configuration Builder (`SpectorConfig`):** Fluent developer-facing builder that manages default configuration properties, auto-selects appropriate quantization modes, and calculates optimal rescoring scales.
-3. **Training Buffer (`EngineTrainingBuffer`):** Safely caches the first set of ingested vectors to build representative training sets before automatically executing `K-Means++` and building the `IVF` / `SpectorIndex` Centroids.
-
----
-
-## 🚀 Key APIs
-
-### Starting the Engine
-```java
-SpectorConfig config = SpectorConfig.DEFAULT
-    .withDimensions(384)
-    .withCapacity(50_000)
-    .withQuantization(QuantizationType.SCALAR_INT8)
-    .withRescore(3);
-
-try (SpectorEngine engine = new SpectorEngine(config)) {
-    // High-level Ingestion
-    engine.ingest("doc-abc", "Document text content...", embedding);
-
-    // Orchestrated Hybrid Search with re-ranking
-    SearchResponse response = engine.hybridSearch("search query", queryVector, 5);
-}
-```
diff --git a/spector-engine/pom.xml b/spector-engine/pom.xml
index 1197295..260660c 100644
--- a/spector-engine/pom.xml
+++ b/spector-engine/pom.xml
@@ -6,7 +6,7 @@
 
     <parent>
         <groupId>com.spectrayan</groupId>
-        <artifactId>spector</artifactId>
+        <artifactId>spector-search</artifactId>
         <version>0.1.0-SNAPSHOT</version>
     </parent>
 
@@ -19,10 +19,6 @@
             <groupId>com.spectrayan</groupId>
             <artifactId>spector-core</artifactId>
         </dependency>
-        <dependency>
-            <groupId>com.spectrayan</groupId>
-            <artifactId>spector-config</artifactId>
-        </dependency>
         <dependency>
             <groupId>com.spectrayan</groupId>
             <artifactId>spector-storage</artifactId>
@@ -43,15 +39,6 @@
             <groupId>com.spectrayan</groupId>
             <artifactId>spector-embed-api</artifactId>
         </dependency>
-        <dependency>
-            <groupId>com.spectrayan</groupId>
-            <artifactId>spector-ingestion</artifactId>
-        </dependency>
-
-        <dependency>
-            <groupId>com.spectrayan</groupId>
-            <artifactId>spector-rag</artifactId>
-        </dependency>
         <dependency>
             <groupId>com.spectrayan</groupId>
             <artifactId>spector-gpu</artifactId>
diff --git a/spector-engine/src/main/java/com/spectrayan/spector/engine/DefaultSpectorEngine.java b/spector-engine/src/main/java/com/spectrayan/spector/engine/DefaultSpectorEngine.java
deleted file mode 100644
index 78d6e33..0000000
--- a/spector-engine/src/main/java/com/spectrayan/spector/engine/DefaultSpectorEngine.java
+++ /dev/null
@@ -1,496 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.engine;
-
-import com.spectrayan.spector.config.IndexType;
-import com.spectrayan.spector.config.PersistenceFiles;
-import com.spectrayan.spector.config.PersistenceMode;
-import com.spectrayan.spector.config.SpectorConfig;
-import com.spectrayan.spector.core.simd.SimdCapability;
-import com.spectrayan.spector.core.similarity.SimilarityFunction;
-import com.spectrayan.spector.embed.EmbeddingProvider;
-import com.spectrayan.spector.gpu.GpuBatchSimilarity;
-import com.spectrayan.spector.index.VectorIndex;
-import com.spectrayan.spector.index.DiskHnswWriter;
-import com.spectrayan.spector.index.ShardedDiskHnswWriter;
-import com.spectrayan.spector.index.HnswIndex;
-import com.spectrayan.spector.query.HybridSearchOrchestrator;
-import com.spectrayan.spector.index.KeywordIndex;
-import com.spectrayan.spector.query.SearchQuery;
-import com.spectrayan.spector.query.SearchResponse;
-import com.spectrayan.spector.query.ranking.Reranker;
-import com.spectrayan.spector.storage.DocumentStore;
-import com.spectrayan.spector.storage.VectorStore;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import com.spectrayan.spector.commons.error.ErrorCode;
-import com.spectrayan.spector.commons.error.SpectorServerException;
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-
-import java.io.IOException;
-import java.nio.file.Path;
-
-/**
- * Default implementation of {@link SpectorEngine}.
- *
- * <p>Manages the lifecycle of all underlying components: vector store,
- * document store, HNSW index, BM25 index, hybrid query orchestrator,
- * optional GPU acceleration, and optional LLM re-ranking.
- * Provides a simple API for document ingestion and search.</p>
- *
- * <p>Delegates to {@link EngineIngestion} for ingestion and
- * {@link EngineSearch} for search operations.</p>
- *
- * <h3>Construction</h3>
- * <p>Use the fluent {@link Builder} for clean engine construction:</p>
- * <pre>{@code
- *   SpectorEngine engine = DefaultSpectorEngine.builder()
- *       .dimensions(384)
- *       .capacity(100_000)
- *       .similarity(SimilarityFunction.COSINE)
- *       .gpu(true)
- *       .reranker("http://localhost:11434", "llama3.2")
- *       .embeddingProvider(myProvider)
- *       .build();
- * }</pre>
- *
- * <h3>Design Patterns</h3>
- * <ul>
- *   <li><b>Facade</b> — unified API over 6+ subsystems</li>
- *   <li><b>Builder</b> — fluent construction via {@link Builder}</li>
- *   <li><b>Abstract Factory</b> — component assembly via {@link EngineComponentFactory}</li>
- *   <li><b>Delegation</b> — ingestion → {@link EngineIngestion}, search → {@link EngineSearch}</li>
- * </ul>
- */
-public class DefaultSpectorEngine implements SpectorEngine {
-
-    private static final Logger log = LoggerFactory.getLogger(DefaultSpectorEngine.class);
-
-    private final SpectorConfig config;
-    private final VectorStore vectorStore;
-    private final DocumentStore documentStore;
-    private final VectorIndex vectorIndex;
-    private final KeywordIndex keywordIndex;
-    private final EmbeddingProvider embeddingProvider; // nullable
-    private final Reranker reranker; // nullable
-    private final GpuBatchSimilarity gpuBatchSimilarity; // nullable
-    private final PersistenceFiles persistenceFiles;
-    private volatile boolean closed;
-
-    // Delegates
-    private final EngineIngestion ingestion;
-    private final EngineIngestionTarget ingestionTarget;
-    private final EngineSearch search;
-
-    // ─────────────── Construction ───────────────
-
-    /**
-     * Creates and initializes a new engine with the given configuration.
-     *
-     * @param config the engine configuration
-     */
-    public DefaultSpectorEngine(SpectorConfig config) {
-        this(config, null);
-    }
-
-    /**
-     * Creates an engine with configuration and an embedding provider.
-     *
-     * @param config   the engine configuration
-     * @param provider the embedding provider (nullable)
-     */
-    public DefaultSpectorEngine(SpectorConfig config, EmbeddingProvider provider) {
-        this(config, provider, new EngineComponentFactory());
-    }
-
-    /**
-     * Creates an engine with a custom component factory (for testing/extensibility).
-     *
-     * @param config   the engine configuration
-     * @param provider the embedding provider (nullable)
-     * @param factory  component factory for assembling subsystems
-     */
-    public DefaultSpectorEngine(SpectorConfig config, EmbeddingProvider provider,
-                         EngineComponentFactory factory) {
-        this.config = config;
-        this.embeddingProvider = provider;
-        this.persistenceFiles = PersistenceFiles.DEFAULTS;
-        this.closed = false;
-
-        log.info("Initializing SpectorEngine: dims={}, capacity={}, similarity={}, " +
-                        "quantization={}, persistence={}, indexType={}, embedding={}, " +
-                        "gpu={}, reranker={}, {}",
-                config.dimensions(), config.capacity(), config.similarityFunction(),
-                config.quantization(), config.persistenceMode(), config.indexType(),
-                provider != null ? provider.modelName() : "none",
-                config.gpuEnabled() ? "enabled" : "disabled",
-                config.rerankerEnabled() ? config.rerankerModel() : "disabled",
-                SimdCapability.report());
-
-        // ── Assemble components via Abstract Factory ──
-        EngineComponents components = factory.create(config);
-
-        this.vectorStore = components.vectorStore();
-        this.documentStore = components.documentStore();
-        this.vectorIndex = components.vectorIndex();
-        this.keywordIndex = components.keywordIndex();
-        this.reranker = components.reranker();
-        this.gpuBatchSimilarity = components.gpuBatch() instanceof GpuBatchSimilarity gpu
-                ? gpu : null;
-
-        // ── Wire orchestrator with optional re-ranker ──
-        var orchestrator = new HybridSearchOrchestrator(
-                keywordIndex, vectorIndex, reranker, documentStore);
-
-        // ── Create delegates ──
-        this.ingestion = new EngineIngestion(config, vectorStore, documentStore,
-                vectorIndex, keywordIndex, embeddingProvider);
-        this.ingestionTarget = new EngineIngestionTarget(config, vectorStore, documentStore,
-                vectorIndex, keywordIndex);
-        this.search = new EngineSearch(config, orchestrator, embeddingProvider, gpuBatchSimilarity);
-
-        log.info("SpectorEngine initialized successfully");
-    }
-
-    /** Creates an engine with default configuration. */
-    public DefaultSpectorEngine() {
-        this(SpectorConfig.DEFAULT);
-    }
-
-    /** Returns a new fluent {@link Builder} for constructing an engine. */
-    public static Builder builder() {
-        return new Builder();
-    }
-
-    // ─────────────── Ingestion Target ───────────────
-
-    /**
-     * Returns the engine's ingestion target for use with the unified {@link com.spectrayan.spector.ingestion.IngestionPipeline}.
-     */
-    @Override
-    public EngineIngestionTarget target() {
-        return ingestionTarget;
-    }
-
-    // ─────────────── Ingestion (delegated) ───────────────
-
-    /** Ingests a single document with its text content and vector embedding. */
-    @Override
-    public void ingest(String id, String content, float[] vector) {
-        ensureOpen();
-        ingestion.ingest(id, content, vector);
-    }
-
-    /** Ingests a document with title, content, and vector. */
-    @Override
-    public void ingest(String id, String title, String content, float[] vector) {
-        ensureOpen();
-        ingestion.ingest(id, title, content, vector);
-    }
-
-    /** Ingests a batch of documents. */
-    @Override
-    public void ingestBatch(String[] ids, String[] contents, float[][] vectors) {
-        ensureOpen();
-        ingestion.ingestBatch(ids, contents, vectors);
-    }
-
-    /** Deletes a document by ID from all indexes. */
-    @Override
-    public boolean delete(String id) {
-        ensureOpen();
-        return ingestion.delete(id);
-    }
-
-    /** Ingests a large document by splitting it into overlapping chunks. */
-    @Override
-    public int ingestChunked(String id, String content,
-                             java.util.function.Function<String, float[]> vectorProvider) {
-        ensureOpen();
-        return ingestion.ingestChunked(id, content, vectorProvider);
-    }
-
-    /** Ingests a large document with a custom chunker configuration. */
-    @Override
-    public int ingestChunked(String id, String content,
-                             java.util.function.Function<String, float[]> vectorProvider,
-                             com.spectrayan.spector.commons.TextChunker chunker) {
-        ensureOpen();
-        return ingestion.ingestChunked(id, content, vectorProvider, chunker);
-    }
-
-    /** Ingests structured content (XML, JSON, Java objects) by extracting text. */
-    @Override
-    public void ingestStructured(String id, String content, float[] vector) {
-        ensureOpen();
-        ingestion.ingestStructured(id, content, vector);
-    }
-
-    /** Ingests a large file using streaming chunking with bounded memory. */
-    @Override
-    public int ingestFile(java.nio.file.Path path, String documentId,
-                          java.util.function.Function<String, float[]> vectorProvider,
-                          int chunkSize, int overlap) throws java.io.IOException {
-        ensureOpen();
-        return ingestion.ingestFile(path, documentId, vectorProvider, chunkSize, overlap);
-    }
-
-    /** Ingests a large document using token-level chunking. */
-    @Override
-    public int ingestTokenChunked(String id, String content,
-                                  java.util.function.Function<String, float[]> vectorProvider,
-                                  int maxTokens, int overlapTokens) {
-        ensureOpen();
-        return ingestion.ingestTokenChunked(id, content, vectorProvider, maxTokens, overlapTokens);
-    }
-
-    /** Ingests a document with automatic embedding generation. */
-    @Override
-    public void ingest(String id, String content) {
-        ensureOpen();
-        ingestion.ingest(id, content);
-    }
-
-    /** Ingests a document with title and automatic embedding. */
-    @Override
-    public void ingest(String id, String title, String content) {
-        ensureOpen();
-        ingestion.ingest(id, title, content);
-    }
-
-    /** Auto-embed chunked ingestion for large documents. */
-    @Override
-    public int ingestChunkedAuto(String id, String content) {
-        ensureOpen();
-        return ingestion.ingestChunkedAuto(id, content);
-    }
-
-    /** Auto-embed file ingestion with streaming. */
-    @Override
-    public int ingestFileAuto(java.nio.file.Path path, String documentId,
-                              int chunkSize, int overlap) throws java.io.IOException {
-        ensureOpen();
-        return ingestion.ingestFileAuto(path, documentId, chunkSize, overlap);
-    }
-
-    // ─────────────── Search (delegated) ───────────────
-
-    /** Executes a search query. */
-    @Override
-    public SearchResponse search(SearchQuery query) {
-        ensureOpen();
-        return search.search(query);
-    }
-
-    /** Convenience: keyword search. */
-    @Override
-    public SearchResponse keywordSearch(String text, int topK) {
-        ensureOpen();
-        return search.keywordSearch(text, topK);
-    }
-
-    /** Convenience: vector search. */
-    @Override
-    public SearchResponse vectorSearch(float[] vector, int topK) {
-        ensureOpen();
-        return search.vectorSearch(vector, topK);
-    }
-
-    /** Convenience: hybrid search. */
-    @Override
-    public SearchResponse hybridSearch(String text, float[] vector, int topK) {
-        ensureOpen();
-        return search.hybridSearch(text, vector, topK);
-    }
-
-    /** Auto-embed search: embeds the query text and performs hybrid search. */
-    @Override
-    public SearchResponse search(String text, int topK) {
-        ensureOpen();
-        return search.search(text, topK);
-    }
-
-    // ─────────────── GPU-Accelerated Batch Operations ───────────────
-
-    /** Computes batch cosine similarities using GPU if available, CPU SIMD otherwise. */
-    @Override
-    public float[] batchCosineSimilarity(float[] query, float[] database, int n, int dims) {
-        ensureOpen();
-        return search.batchCosineSimilarity(query, database, n, dims);
-    }
-
-    /** Returns whether GPU acceleration is active. */
-    @Override
-    public boolean isGpuActive() {
-        return search.isGpuActive();
-    }
-
-    // ─────────────── Accessors ───────────────
-
-    /** Returns the engine configuration. */
-    @Override
-    public SpectorConfig config() { return config; }
-
-    /** Returns the number of indexed documents. */
-    @Override
-    public int documentCount() { return vectorStore.size(); }
-
-    /** Returns the document store. */
-    @Override
-    public DocumentStore documentStore() { return documentStore; }
-
-    /** Returns the vector store. */
-    @Override
-    public VectorStore vectorStore() { return vectorStore; }
-
-    /** Returns the underlying vector index (for ANN pre-filtering by Memory). */
-    @Override
-    public VectorIndex index() { return vectorIndex; }
-
-    /** Returns the embedding provider, or null if none configured. */
-    @Override
-    public EmbeddingProvider embeddingProvider() { return embeddingProvider; }
-
-    /** Returns true if an embedding provider is configured. */
-    @Override
-    public boolean hasEmbeddingProvider() { return embeddingProvider != null; }
-
-    /** Returns the active re-ranker, or null if none configured. */
-    @Override
-    public Reranker reranker() { return reranker; }
-
-    /** Returns true if LLM re-ranking is active. */
-    @Override
-    public boolean isRerankerActive() { return reranker != null; }
-
-    // ─────────────── Lifecycle ───────────────
-
-    @Override
-    public synchronized void close() {
-        if (!closed) {
-            closed = true;
-            try {
-                // Persist to disk if configured
-                if (config.persistenceMode() == PersistenceMode.DISK) {
-                    // HNSW index (sharded)
-                    if (vectorIndex instanceof com.spectrayan.spector.index.AbstractHnswIndex hnswIdx && hnswIdx.size() > 0) {
-                        try {
-                            Path shardDir = persistenceFiles.resolveShardDir(config.dataDirectory());
-                            int nodesPerShard = config.effectiveNodesPerShard();
-                            ShardedDiskHnswWriter.write(hnswIdx, shardDir, nodesPerShard);
-                            log.info("HNSW index persisted to {} shards in {}",
-                                    (hnswIdx.size() + nodesPerShard - 1) / nodesPerShard, shardDir);
-                        } catch (IOException e) {
-                            log.error("Failed to persist sharded HNSW index to disk", e);
-                        }
-                    }
-
-                    // SpectorIndex (Spectrum)
-                    if (vectorIndex instanceof com.spectrayan.spector.index.spectrum.SpectorIndex specIdx && specIdx.size() > 0) {
-                        try {
-                            Path specIndexDir = config.dataDirectory().resolve("index_spectrum");
-                            specIdx.save(specIndexDir, vectorStore);
-                            log.info("SpectorIndex persisted to {}", specIndexDir);
-                        } catch (IOException e) {
-                            log.error("Failed to persist SpectorIndex to disk", e);
-                        }
-                    }
-
-                    // Document store
-                    try {
-                        Path docsFile = persistenceFiles.resolveDocuments(config.dataDirectory());
-                        documentStore.save(docsFile);
-                        log.info("DocumentStore persisted to {} ({} docs)", docsFile, documentStore.size());
-                    } catch (Exception e) {
-                        log.error("Failed to persist DocumentStore to disk", e);
-                    }
-
-                    // Vector store ID mappings
-                    if (vectorStore instanceof com.spectrayan.spector.storage.ShardedMappedVectorStore smvs) {
-                        try {
-                            Path idFile = persistenceFiles.resolveIdMappings(config.dataDirectory());
-                            smvs.saveIdMappings(idFile);
-                            log.info("Vector store ID mappings persisted to {}", idFile);
-                        } catch (Exception e) {
-                            log.error("Failed to persist vector store ID mappings", e);
-                        }
-                    }
-                }
-
-                search.orchestrator().close();
-                vectorIndex.close();
-                keywordIndex.close();
-                vectorStore.close();
-                documentStore.close();
-                if (embeddingProvider != null) embeddingProvider.close();
-                if (gpuBatchSimilarity != null) gpuBatchSimilarity.close();
-            } catch (Exception e) {
-                log.warn("Error during engine shutdown", e);
-            }
-            log.info("SpectorEngine closed");
-        }
-    }
-
-    private void ensureOpen() {
-        if (closed) throw new SpectorServerException(ErrorCode.ENGINE_CLOSED);
-    }
-
-    // ═════════════════════════════════════════════════════════════════
-    //  Builder Pattern
-    // ═════════════════════════════════════════════════════════════════
-
-    /**
-     * Fluent builder for constructing {@link DefaultSpectorEngine} instances.
-     */
-    public static final class Builder {
-
-        private SpectorConfig config = SpectorConfig.DEFAULT;
-        private EmbeddingProvider embeddingProvider;
-        private EngineComponentFactory componentFactory;
-
-        Builder() {}
-
-        public Builder dimensions(int dims) { this.config = config.withDimensions(dims); return this; }
-        public Builder capacity(int capacity) { this.config = config.withCapacity(capacity); return this; }
-        public Builder similarity(SimilarityFunction sf) { this.config = config.withSimilarityFunction(sf); return this; }
-        public Builder quantization(com.spectrayan.spector.core.quantization.QuantizationType qt) { this.config = config.withQuantization(qt); return this; }
-        public Builder svasq() { this.config = config.withSvasq(); return this; }
-        public Builder svasq(int oversamplingFactor) { this.config = config.withSvasq(oversamplingFactor); return this; }
-        public Builder svasq4() { this.config = config.withSvasq4(); return this; }
-        public Builder svasq4(int oversamplingFactor) { this.config = config.withSvasq4(oversamplingFactor); return this; }
-        public Builder persistence(PersistenceMode mode, Path directory) { this.config = config.withPersistence(mode, directory); return this; }
-        public Builder ivfPq() { this.config = config.withIvfPq(); return this; }
-        public Builder ivfPq(int nlist, int nprobe, int subspaces) { this.config = config.withIvfPq(nlist, nprobe, subspaces); return this; }
-        public Builder spectrum() { this.config = config.withSpectrum(); return this; }
-        public Builder spectrum(int nCentroids, int nProbe, int shardThreshold) { this.config = config.withSpectrum(nCentroids, nProbe, shardThreshold); return this; }
-        public Builder gpu(boolean enabled) { this.config = config.withGpu(enabled); return this; }
-        public Builder reranker(String ollamaUrl, String model) { this.config = config.withReranker(ollamaUrl, model); return this; }
-        public Builder reranker(String ollamaUrl, String model, int maxCandidates) { this.config = config.withReranker(ollamaUrl, model, maxCandidates); return this; }
-        public Builder embeddingProvider(EmbeddingProvider provider) { this.embeddingProvider = provider; return this; }
-        public Builder componentFactory(EngineComponentFactory factory) { this.componentFactory = factory; return this; }
-        public Builder config(SpectorConfig config) { this.config = config; return this; }
-        public SpectorConfig config() { return this.config; }
-
-        /** Builds and returns a fully initialized {@link DefaultSpectorEngine}. */
-        public SpectorEngine build() {
-            EngineComponentFactory factory = componentFactory != null
-                    ? componentFactory : new EngineComponentFactory();
-            return new DefaultSpectorEngine(config, embeddingProvider, factory);
-        }
-    }
-}
\ No newline at end of file
diff --git a/spector-engine/src/main/java/com/spectrayan/spector/engine/EngineComponentFactory.java b/spector-engine/src/main/java/com/spectrayan/spector/engine/EngineComponentFactory.java
index f081b84..eff7d00 100644
--- a/spector-engine/src/main/java/com/spectrayan/spector/engine/EngineComponentFactory.java
+++ b/spector-engine/src/main/java/com/spectrayan/spector/engine/EngineComponentFactory.java
@@ -1,41 +1,17 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.engine;
 
-
-
-
-import com.spectrayan.spector.storage.VectorStoreFactory;
-import com.spectrayan.spector.index.VectorIndexFactory;
-import com.spectrayan.spector.config.SpectorConfig;
 import com.spectrayan.spector.gpu.GpuBatchSimilarity;
 import com.spectrayan.spector.gpu.GpuCapability;
 import com.spectrayan.spector.index.BM25Index;
 import com.spectrayan.spector.index.DiskHnswIndex;
-import com.spectrayan.spector.index.ShardedDiskHnswIndex;
 import com.spectrayan.spector.index.KeywordIndex;
 import com.spectrayan.spector.index.VectorIndex;
 import com.spectrayan.spector.query.ranking.LlmReranker;
 import com.spectrayan.spector.query.ranking.Reranker;
 import com.spectrayan.spector.storage.DocumentStore;
-import com.spectrayan.spector.storage.ShardedIndexFormat;
-import com.spectrayan.spector.storage.ShardedMappedVectorStore;
-import com.spectrayan.spector.config.PersistenceMode;
+import com.spectrayan.spector.storage.InMemoryVectorStore;
+import com.spectrayan.spector.storage.PersistenceMode;
 import com.spectrayan.spector.storage.VectorStore;
-import com.spectrayan.spector.config.PersistenceFiles;
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -69,23 +45,15 @@ public class EngineComponentFactory {
 
     private final VectorIndexFactory indexFactory;
     private final VectorStoreFactory storeFactory;
-    private final PersistenceFiles persistenceFiles;
 
     public EngineComponentFactory() {
-        this(new VectorIndexFactory(), new VectorStoreFactory(), PersistenceFiles.DEFAULTS);
+        this(new VectorIndexFactory(), new VectorStoreFactory());
     }
 
     /** Allows injecting custom factories (for testing). */
     public EngineComponentFactory(VectorIndexFactory indexFactory, VectorStoreFactory storeFactory) {
-        this(indexFactory, storeFactory, PersistenceFiles.DEFAULTS);
-    }
-
-    /** Full constructor with custom persistence file names. */
-    public EngineComponentFactory(VectorIndexFactory indexFactory, VectorStoreFactory storeFactory,
-                                   PersistenceFiles persistenceFiles) {
         this.indexFactory = indexFactory;
         this.storeFactory = storeFactory;
-        this.persistenceFiles = persistenceFiles;
     }
 
     /**
@@ -99,93 +67,38 @@ public EngineComponents create(SpectorConfig config) {
         DocumentStore ds;
         VectorIndex vi;
         KeywordIndex ki;
+        boolean loadedFromDisk = false;
 
-        // ── Create fresh writable components ──
-        vs = storeFactory.create(config);
-        vi = indexFactory.create(config, vs);
-        ki = new BM25Index();
-
-        // ── Load persisted data from disk (if available) ──
+        // ── Try loading from disk ──
         if (config.persistenceMode() == PersistenceMode.DISK) {
-            // 1. Load VectorStore ID mappings (restores id→index map + count)
-            if (vs instanceof ShardedMappedVectorStore smvs) {
-                Path idMappingsFile = persistenceFiles.resolveIdMappings(config.dataDirectory());
-                if (Files.exists(idMappingsFile)) {
-                    smvs.loadIdMappings(idMappingsFile);
-                    log.info("Loaded VectorStore ID mappings: {} entries", smvs.size());
-                }
-            }
-
-            // 2. Load HNSW graph structure from sharded index
-            Path shardDir = persistenceFiles.resolveShardDir(config.dataDirectory());
-            Path manifestFile = ShardedIndexFormat.resolveManifest(shardDir);
-            if (Files.exists(manifestFile) && vi instanceof com.spectrayan.spector.index.AbstractHnswIndex writable) {
+            Path indexFile = config.dataDirectory().resolve("index.spct");
+            if (Files.exists(indexFile)) {
                 try {
-                    var diskIndex = ShardedDiskHnswIndex.open(shardDir);
-                    int nodeCount = diskIndex.size();
-                    log.info("Loading {} nodes from sharded disk index into writable HNSW...", nodeCount);
-
-                    for (int i = 0; i < nodeCount; i++) {
-                        String id = diskIndex.getId(i);
-                        float[] vector = diskIndex.readVector(i);
-                        int level = diskIndex.readLevel(i);
-
-                        // Resolve store index from loaded ID mappings
-                        int storeIndex = vs.indexOf(id);
-                        if (storeIndex < 0) {
-                            // Vector not in store yet — add it
-                            storeIndex = vs.put(id, vector);
-                        }
-
-                        // Collect neighbor arrays
-                        int[] layer0 = diskIndex.readNeighbors(i, 0);
-                        int[][] upper = null;
-                        if (level > 0) {
-                            upper = new int[level][];
-                            for (int l = 1; l <= level; l++) {
-                                upper[l - 1] = diskIndex.readNeighbors(i, l);
-                            }
-                        }
-
-                        writable.addPrebuilt(id, storeIndex, vector, level, layer0, upper);
-                    }
-
-                    // Restore graph state (entry point + max level)
-                    if (nodeCount > 0) {
-                        writable.restoreGraphState(diskIndex.entryPoint(), diskIndex.maxLevel());
-                    }
-
-                    diskIndex.close();
-                    log.info("Loaded {} nodes into writable HNSW index from {} shards",
-                            nodeCount, diskIndex.shardCount());
+                    log.info("Loading existing disk index from {}", indexFile);
+                    var diskIndex = DiskHnswIndex.open(indexFile);
+                    vs = new InMemoryVectorStore(config.dimensions(), config.capacity());
+                    ds = new DocumentStore(config.capacity());
+                    vi = diskIndex;
+                    ki = new BM25Index();
+                    loadedFromDisk = true;
+                    log.info("Loaded disk index: {} vectors", diskIndex.size());
                 } catch (IOException e) {
-                    log.warn("Failed to load sharded disk index, starting fresh: {}", e.getMessage());
+                    log.warn("Failed to load disk index, creating fresh: {}", e.getMessage());
+                    vs = null; ds = null; vi = null; ki = null;
                 }
-            }
-
-            // 2b. Load SpectorIndex structure
-            Path specIndexDir = config.dataDirectory().resolve("index_spectrum");
-            if (Files.exists(specIndexDir.resolve("meta.properties")) && vi instanceof com.spectrayan.spector.index.spectrum.SpectorIndex) {
-                try {
-                    vi = com.spectrayan.spector.index.spectrum.SpectorIndex.load(
-                            specIndexDir, config.dimensions(),
-                            ((com.spectrayan.spector.index.spectrum.SpectorIndex) vi).config(), vs);
-                    log.info("Loaded SpectorIndex from disk: {} nodes", vi.size());
-                } catch (IOException e) {
-                    log.warn("Failed to load SpectorIndex from disk, starting fresh: {}", e.getMessage());
-                }
-            }
-
-            // 3. Load DocumentStore
-            Path docsFile = persistenceFiles.resolveDocuments(config.dataDirectory());
-            if (Files.exists(docsFile)) {
-                ds = DocumentStore.load(docsFile);
-                log.info("Loaded DocumentStore from disk: {} documents", ds.size());
             } else {
-                ds = new DocumentStore(config.capacity());
+                vs = null; ds = null; vi = null; ki = null;
             }
         } else {
+            vs = null; ds = null; vi = null; ki = null;
+        }
+
+        // ── Build fresh components if not loaded from disk ──
+        if (!loadedFromDisk) {
+            vs = storeFactory.create(config);
             ds = new DocumentStore(config.capacity());
+            vi = indexFactory.create(config);
+            ki = new BM25Index();
         }
 
         // ── GPU acceleration (optional, graceful fallback) ──
diff --git a/spector-engine/src/main/java/com/spectrayan/spector/engine/EngineComponents.java b/spector-engine/src/main/java/com/spectrayan/spector/engine/EngineComponents.java
index 2453f60..d1d73f5 100644
--- a/spector-engine/src/main/java/com/spectrayan/spector/engine/EngineComponents.java
+++ b/spector-engine/src/main/java/com/spectrayan/spector/engine/EngineComponents.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.engine;
 
 import com.spectrayan.spector.index.KeywordIndex;
diff --git a/spector-engine/src/main/java/com/spectrayan/spector/engine/EngineIngestion.java b/spector-engine/src/main/java/com/spectrayan/spector/engine/EngineIngestion.java
deleted file mode 100644
index edb3385..0000000
--- a/spector-engine/src/main/java/com/spectrayan/spector/engine/EngineIngestion.java
+++ /dev/null
@@ -1,364 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.engine;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.function.Function;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import com.spectrayan.spector.commons.ContentExtractor;
-import com.spectrayan.spector.commons.StreamingChunker;
-import com.spectrayan.spector.commons.TextChunker;
-import com.spectrayan.spector.commons.TokenChunker;
-import com.spectrayan.spector.config.IndexType;
-import com.spectrayan.spector.config.SpectorConfig;
-import com.spectrayan.spector.embed.EmbeddingProvider;
-import com.spectrayan.spector.index.VectorIndex;
-import com.spectrayan.spector.index.HnswIndex;
-import com.spectrayan.spector.index.ivf.IvfPqIndex;
-import com.spectrayan.spector.index.spectrum.SpectorIndex;
-import com.spectrayan.spector.index.KeywordIndex;
-import com.spectrayan.spector.storage.Document;
-import com.spectrayan.spector.storage.DocumentStore;
-import com.spectrayan.spector.storage.VectorStore;
-import com.spectrayan.spector.commons.error.SpectorInternalException;
-import com.spectrayan.spector.commons.error.ErrorCode;
-
-/**
- * Handles all document ingestion logic for the Spector engine.
- *
- * <p>Extracted from {@link SpectorEngine} to decompose the god class into
- * focused, single-responsibility components. Manages:</p>
- * <ul>
- *   <li>Single document ingestion (with/without embedding)</li>
- *   <li>Batch ingestion</li>
- *   <li>Chunked ingestion (character-level, token-level, streaming)</li>
- *   <li>Structured content extraction</li>
- *   <li>IVF-PQ and Spectrum auto-training buffers</li>
- * </ul>
- */
-final class EngineIngestion {
-
-    private static final Logger log = LoggerFactory.getLogger(EngineIngestion.class);
-
-    private final SpectorConfig config;
-    private final VectorStore vectorStore;
-    private final DocumentStore documentStore;
-    private final VectorIndex vectorIndex;
-    private final KeywordIndex keywordIndex;
-    private final EmbeddingProvider embeddingProvider; // nullable
-
-    // IVF-PQ training state
-    private List<float[]> ivfTrainingBuffer;
-    private List<String> ivfTrainingIds;
-    private List<String> ivfTrainingContents;
-    private volatile boolean ivfTrained;
-
-    // Spectrum training state
-    private List<float[]> spectrumTrainingBuffer;
-    private List<String> spectrumTrainingIds;
-    private List<String> spectrumTrainingContents;
-    private volatile boolean spectrumTrained;
-
-    EngineIngestion(SpectorConfig config, VectorStore vectorStore, DocumentStore documentStore,
-                    VectorIndex vectorIndex, KeywordIndex keywordIndex,
-                    EmbeddingProvider embeddingProvider) {
-        this.config = config;
-        this.vectorStore = vectorStore;
-        this.documentStore = documentStore;
-        this.vectorIndex = vectorIndex;
-        this.keywordIndex = keywordIndex;
-        this.embeddingProvider = embeddingProvider;
-        this.ivfTrained = (vectorIndex instanceof IvfPqIndex ivfPq) && ivfPq.isTrained();
-        this.spectrumTrained = (vectorIndex instanceof SpectorIndex spec) && spec.isTrained();
-
-        // IVF-PQ training buffer initialization
-        if (config.indexType() == IndexType.IVF_PQ) {
-            int minTrainingSamples = Math.max(config.effectiveNlist() * 40, 256);
-            this.ivfTrainingBuffer = new ArrayList<>(minTrainingSamples);
-            this.ivfTrainingIds = new ArrayList<>(minTrainingSamples);
-            this.ivfTrainingContents = new ArrayList<>(minTrainingSamples);
-            log.info("IVF-PQ index created (untrained). Will auto-train after {} vectors.",
-                    minTrainingSamples);
-        }
-
-        // Spectrum training buffer initialization
-        if (config.indexType() == IndexType.SPECTRUM) {
-            int minTrainingSamples = Math.max(config.effectiveSpectrumNCentroids() * 40, 256);
-            this.spectrumTrainingBuffer = new ArrayList<>(minTrainingSamples);
-            this.spectrumTrainingIds = new ArrayList<>(minTrainingSamples);
-            this.spectrumTrainingContents = new ArrayList<>(minTrainingSamples);
-            log.info("Spectrum index created (untrained). Will auto-train after {} vectors.",
-                    minTrainingSamples);
-        }
-    }
-
-    // ─────────────── Core Ingestion ───────────────
-
-    /**
-     * Ingests a single document with its text content and vector embedding.
-     */
-    void ingest(String id, String content, float[] vector) {
-        // IVF-PQ auto-training: buffer vectors until we have enough to train
-        if (config.indexType() == IndexType.IVF_PQ && !ivfTrained) {
-            ivfTrainingBuffer.add(vector.clone());
-            ivfTrainingIds.add(id);
-            ivfTrainingContents.add(content);
-
-            int minSamples = Math.max(config.effectiveNlist() * 40, 256);
-            if (ivfTrainingBuffer.size() >= minSamples) {
-                trainAndFlushIvfPq();
-            } else {
-                documentStore.put(Document.of(id, content));
-                keywordIndex.index(id, content);
-                return;
-            }
-            return;
-        }
-
-        // Spectrum auto-training: buffer vectors until we have enough to train
-        if (config.indexType() == IndexType.SPECTRUM && !spectrumTrained) {
-            spectrumTrainingBuffer.add(vector.clone());
-            spectrumTrainingIds.add(id);
-            spectrumTrainingContents.add(content);
-
-            int minSamples = Math.max(config.effectiveSpectrumNCentroids() * 40, 256);
-            if (spectrumTrainingBuffer.size() >= minSamples) {
-                trainAndFlushSpectrum();
-            } else {
-                documentStore.put(Document.of(id, content));
-                keywordIndex.index(id, content);
-                return;
-            }
-            return;
-        }
-
-        // Normal ingestion path
-        int storeIndex = vectorStore.put(id, vector);
-        documentStore.put(Document.of(id, content));
-        vectorIndex.add(id, storeIndex, vector);
-        keywordIndex.index(id, content);
-    }
-
-    /**
-     * Ingests a document with title, content, and vector.
-     */
-    void ingest(String id, String title, String content, float[] vector) {
-        int storeIndex = vectorStore.put(id, vector);
-        documentStore.put(Document.of(id, title, content));
-        vectorIndex.add(id, storeIndex, vector);
-        keywordIndex.index(id, title + " " + content);
-    }
-
-    /**
-     * Ingests a batch of documents.
-     */
-    void ingestBatch(String[] ids, String[] contents, float[][] vectors) {
-        for (int i = 0; i < ids.length; i++) {
-            ingest(ids[i], contents[i], vectors[i]);
-        }
-    }
-
-    /**
-     * Deletes a document by ID from all indexes.
-     */
-    boolean delete(String id) {
-        Document removed = documentStore.remove(id);
-        if (removed != null) {
-            keywordIndex.remove(id);
-            log.debug("Deleted document '{}'", id);
-            return true;
-        }
-        return false;
-    }
-
-    // ─────────────── Large Document Ingestion ───────────────
-
-    /**
-     * Ingests a large document by splitting it into overlapping chunks.
-     */
-    int ingestChunked(String id, String content,
-                      Function<String, float[]> vectorProvider) {
-        return ingestChunked(id, content, vectorProvider, new TextChunker());
-    }
-
-    /**
-     * Ingests a large document with a custom chunker configuration.
-     */
-    int ingestChunked(String id, String content,
-                      Function<String, float[]> vectorProvider,
-                      TextChunker chunker) {
-        var chunks = chunker.chunk(id, content);
-
-        // Store lightweight metadata only — full content is redundant since each
-        // chunk is individually stored in VectorStore + KeywordIndex.
-        // This avoids holding O(content_size) on the Java heap per document.
-        documentStore.put(Document.of(id, "[chunked: " + chunks.size() + " chunks]"));
-
-        for (var chunk : chunks) {
-            float[] vector = vectorProvider.apply(chunk.text());
-            int storeIndex = vectorStore.put(chunk.chunkId(), vector);
-            vectorIndex.add(chunk.chunkId(), storeIndex, vector);
-            keywordIndex.index(chunk.chunkId(), chunk.text());
-        }
-
-        log.info("Ingested '{}' as {} chunks (chunkSize={}, overlap={})",
-                id, chunks.size(), chunker.chunkSize(), chunker.overlap());
-        return chunks.size();
-    }
-
-    /**
-     * Ingests structured content by extracting text first.
-     */
-    void ingestStructured(String id, String content, float[] vector) {
-        String extracted = ContentExtractor.extract(content);
-        ingest(id, extracted, vector);
-    }
-
-    /**
-     * Ingests a large file using streaming chunking with bounded memory.
-     */
-    int ingestFile(java.nio.file.Path path, String documentId,
-                   Function<String, float[]> vectorProvider,
-                   int chunkSize, int overlap) throws java.io.IOException {
-        int count = 0;
-        try (var stream = StreamingChunker.chunkFile(path, documentId, chunkSize, overlap)) {
-            var iter = stream.iterator();
-            while (iter.hasNext()) {
-                var chunk = iter.next();
-                float[] vector = vectorProvider.apply(chunk.text());
-                int storeIndex = vectorStore.put(chunk.chunkId(), vector);
-                vectorIndex.add(chunk.chunkId(), storeIndex, vector);
-                keywordIndex.index(chunk.chunkId(), chunk.text());
-                count++;
-            }
-        }
-        log.info("Streaming-ingested file '{}' as {} chunks (chunkSize={}, overlap={})",
-                path.getFileName(), count, chunkSize, overlap);
-        return count;
-    }
-
-    /**
-     * Ingests a large document using token-level chunking.
-     */
-    int ingestTokenChunked(String id, String content,
-                           Function<String, float[]> vectorProvider,
-                           int maxTokens, int overlapTokens) {
-        var chunker = new TokenChunker(maxTokens, overlapTokens);
-        documentStore.put(Document.of(id, content));
-
-        var chunks = chunker.chunk(id, content);
-        for (var chunk : chunks) {
-            float[] vector = vectorProvider.apply(chunk.text());
-            int storeIndex = vectorStore.put(chunk.chunkId(), vector);
-            vectorIndex.add(chunk.chunkId(), storeIndex, vector);
-            keywordIndex.index(chunk.chunkId(), chunk.text());
-        }
-
-        log.info("Token-chunked '{}' into {} chunks (maxTokens={}, overlap={})",
-                id, chunks.size(), maxTokens, overlapTokens);
-        return chunks.size();
-    }
-
-    // ─────────────── Auto-Embed Ingestion ───────────────
-
-    /** Ingests a document with automatic embedding generation. */
-    void ingest(String id, String content) {
-        requireEmbeddingProvider();
-        float[] vector = embeddingProvider.embed(content).vector();
-        ingest(id, content, vector);
-    }
-
-    /** Ingests a document with title and automatic embedding. */
-    void ingest(String id, String title, String content) {
-        requireEmbeddingProvider();
-        float[] vector = embeddingProvider.embed(title + " " + content).vector();
-        ingest(id, title, content, vector);
-    }
-
-    /** Auto-embed chunked ingestion. */
-    int ingestChunkedAuto(String id, String content) {
-        requireEmbeddingProvider();
-        return ingestChunked(id, content, text -> embeddingProvider.embed(text).vector());
-    }
-
-    /** Auto-embed file ingestion. */
-    int ingestFileAuto(java.nio.file.Path path, String documentId,
-                       int chunkSize, int overlap) throws java.io.IOException {
-        requireEmbeddingProvider();
-        return ingestFile(path, documentId,
-                text -> embeddingProvider.embed(text).vector(), chunkSize, overlap);
-    }
-
-    // ─────────────── Training ───────────────
-
-    private void trainAndFlushIvfPq() {
-        if (!(vectorIndex instanceof IvfPqIndex ivfPq)) return;
-
-        float[][] trainingData = ivfTrainingBuffer.toArray(float[][]::new);
-        log.info("Auto-training IVF-PQ with {} vectors...", trainingData.length);
-        ivfPq.train(trainingData);
-
-        for (int i = 0; i < ivfTrainingBuffer.size(); i++) {
-            float[] vec = ivfTrainingBuffer.get(i);
-            String id = ivfTrainingIds.get(i);
-            String content = ivfTrainingContents.get(i);
-            int storeIndex = vectorStore.put(id, vec);
-            documentStore.put(Document.of(id, content));
-            vectorIndex.add(id, storeIndex, vec);
-            keywordIndex.index(id, content);
-        }
-
-        ivfTrainingBuffer = null;
-        ivfTrainingIds = null;
-        ivfTrainingContents = null;
-        ivfTrained = true;
-        log.info("IVF-PQ training complete. {} vectors indexed.", ivfPq.size());
-    }
-
-    private void trainAndFlushSpectrum() {
-        if (!(vectorIndex instanceof SpectorIndex spectrumIdx)) return;
-
-        float[][] trainingData = spectrumTrainingBuffer.toArray(float[][]::new);
-        log.info("Auto-training Spectrum with {} vectors...", trainingData.length);
-        spectrumIdx.train(trainingData);
-
-        for (int i = 0; i < spectrumTrainingBuffer.size(); i++) {
-            float[] vec = spectrumTrainingBuffer.get(i);
-            String bufferedId = spectrumTrainingIds.get(i);
-            String content = spectrumTrainingContents.get(i);
-            int storeIndex = vectorStore.put(bufferedId, vec);
-            documentStore.put(Document.of(bufferedId, content));
-            vectorIndex.add(bufferedId, storeIndex, vec);
-            keywordIndex.index(bufferedId, content);
-        }
-
-        spectrumTrainingBuffer = null;
-        spectrumTrainingIds = null;
-        spectrumTrainingContents = null;
-        spectrumTrained = true;
-        log.info("Spectrum training complete. {} vectors indexed.", spectrumIdx.size());
-    }
-
-    private void requireEmbeddingProvider() {
-        if (embeddingProvider == null) {
-            throw new SpectorInternalException(ErrorCode.ARGUMENT_INVALID, com.spectrayan.spector.commons.error.ErrorCode.EMBEDDING_PROVIDER_MISSING.format());
-        }
-    }
-}
diff --git a/spector-engine/src/main/java/com/spectrayan/spector/engine/EngineIngestionTarget.java b/spector-engine/src/main/java/com/spectrayan/spector/engine/EngineIngestionTarget.java
deleted file mode 100644
index ef51de2..0000000
--- a/spector-engine/src/main/java/com/spectrayan/spector/engine/EngineIngestionTarget.java
+++ /dev/null
@@ -1,202 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.engine;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import com.spectrayan.spector.config.IndexType;
-import com.spectrayan.spector.config.SpectorConfig;
-import com.spectrayan.spector.index.KeywordIndex;
-import com.spectrayan.spector.index.VectorIndex;
-import com.spectrayan.spector.index.ivf.IvfPqIndex;
-import com.spectrayan.spector.index.spectrum.SpectorIndex;
-import com.spectrayan.spector.ingestion.IngestionTarget;
-import com.spectrayan.spector.storage.Document;
-import com.spectrayan.spector.storage.DocumentStore;
-import com.spectrayan.spector.storage.VectorStore;
-
-/**
- * Engine-side implementation of {@link IngestionTarget}.
- *
- * <p>Routes each ingested chunk to the engine's storage subsystems:
- * VectorStore (off-heap) → VectorIndex (HNSW/IVF/Spectrum) → KeywordIndex (BM25).</p>
- *
- * <h3>IVF-PQ / Spectrum Auto-Training</h3>
- * <p>For IVF-PQ and Spectrum index types, vectors are buffered until enough
- * training samples are collected. During buffering, documents are still
- * indexed for keyword search but not added to the vector index.</p>
- *
- * @see IngestionTarget
- */
-public final class EngineIngestionTarget implements IngestionTarget {
-
-    private static final Logger log = LoggerFactory.getLogger(EngineIngestionTarget.class);
-
-    private final SpectorConfig config;
-    private final VectorStore vectorStore;
-    private final DocumentStore documentStore;
-    private final VectorIndex vectorIndex;
-    private final KeywordIndex keywordIndex;
-
-    // IVF-PQ training state
-    private List<float[]> ivfTrainingBuffer;
-    private List<String> ivfTrainingIds;
-    private List<String> ivfTrainingContents;
-    private volatile boolean ivfTrained;
-
-    // Spectrum training state
-    private List<float[]> spectrumTrainingBuffer;
-    private List<String> spectrumTrainingIds;
-    private List<String> spectrumTrainingContents;
-    private volatile boolean spectrumTrained;
-
-    public EngineIngestionTarget(SpectorConfig config, VectorStore vectorStore,
-                                  DocumentStore documentStore, VectorIndex vectorIndex,
-                                  KeywordIndex keywordIndex) {
-        this.config = config;
-        this.vectorStore = vectorStore;
-        this.documentStore = documentStore;
-        this.vectorIndex = vectorIndex;
-        this.keywordIndex = keywordIndex;
-        this.ivfTrained = false;
-        this.spectrumTrained = false;
-
-        // IVF-PQ training buffer initialization
-        if (config.indexType() == IndexType.IVF_PQ) {
-            int minTrainingSamples = Math.max(config.effectiveNlist() * 40, 256);
-            this.ivfTrainingBuffer = new ArrayList<>(minTrainingSamples);
-            this.ivfTrainingIds = new ArrayList<>(minTrainingSamples);
-            this.ivfTrainingContents = new ArrayList<>(minTrainingSamples);
-            log.info("IVF-PQ training: will auto-train after {} vectors.", minTrainingSamples);
-        }
-
-        // Spectrum training buffer initialization
-        if (config.indexType() == IndexType.SPECTRUM) {
-            int minTrainingSamples = Math.max(config.effectiveSpectrumNCentroids() * 40, 256);
-            this.spectrumTrainingBuffer = new ArrayList<>(minTrainingSamples);
-            this.spectrumTrainingIds = new ArrayList<>(minTrainingSamples);
-            this.spectrumTrainingContents = new ArrayList<>(minTrainingSamples);
-            log.info("Spectrum training: will auto-train after {} vectors.", minTrainingSamples);
-        }
-    }
-
-    // ═══════════════════════════════════════════════════════════════
-    // IngestionTarget implementation
-    // ═══════════════════════════════════════════════════════════════
-
-    @Override
-    public void ingest(String id, String text, float[] vector) {
-        // IVF-PQ auto-training: buffer vectors until we have enough to train
-        if (config.indexType() == IndexType.IVF_PQ && !ivfTrained) {
-            ivfTrainingBuffer.add(vector.clone());
-            ivfTrainingIds.add(id);
-            ivfTrainingContents.add(text);
-
-            int minSamples = Math.max(config.effectiveNlist() * 40, 256);
-            if (ivfTrainingBuffer.size() >= minSamples) {
-                trainAndFlushIvfPq();
-            } else {
-                documentStore.put(Document.of(id, text));
-                keywordIndex.index(id, text);
-            }
-            return;
-        }
-
-        // Spectrum auto-training: buffer vectors until we have enough to train
-        if (config.indexType() == IndexType.SPECTRUM && !spectrumTrained) {
-            spectrumTrainingBuffer.add(vector.clone());
-            spectrumTrainingIds.add(id);
-            spectrumTrainingContents.add(text);
-
-            int minSamples = Math.max(config.effectiveSpectrumNCentroids() * 40, 256);
-            if (spectrumTrainingBuffer.size() >= minSamples) {
-                trainAndFlushSpectrum();
-            } else {
-                documentStore.put(Document.of(id, text));
-                keywordIndex.index(id, text);
-            }
-            return;
-        }
-
-        // Normal ingestion path
-        int storeIndex = vectorStore.put(id, vector);
-        vectorIndex.add(id, storeIndex, vector);
-        keywordIndex.index(id, text);
-    }
-
-    @Override
-    public void storeParentMetadata(String parentId, int chunkCount) {
-        documentStore.put(Document.of(parentId, "[chunked: " + chunkCount + " chunks]"));
-    }
-
-    // ═══════════════════════════════════════════════════════════════
-    // IVF-PQ / Spectrum training
-    // ═══════════════════════════════════════════════════════════════
-
-    private void trainAndFlushIvfPq() {
-        log.info("Training IVF-PQ with {} vectors...", ivfTrainingBuffer.size());
-        float[][] trainingData = ivfTrainingBuffer.toArray(float[][]::new);
-        ((IvfPqIndex) vectorIndex).train(trainingData);
-        ivfTrained = true;
-
-        // Flush buffered vectors
-        for (int i = 0; i < ivfTrainingBuffer.size(); i++) {
-            float[] vec = ivfTrainingBuffer.get(i);
-            String bufferedId = ivfTrainingIds.get(i);
-            String bufferedContent = ivfTrainingContents.get(i);
-
-            int storeIndex = vectorStore.put(bufferedId, vec);
-            documentStore.put(Document.of(bufferedId, bufferedContent));
-            vectorIndex.add(bufferedId, storeIndex, vec);
-            keywordIndex.index(bufferedId, bufferedContent);
-        }
-
-        // Free training buffers
-        ivfTrainingBuffer = null;
-        ivfTrainingIds = null;
-        ivfTrainingContents = null;
-        log.info("IVF-PQ trained and {} buffered vectors flushed.", trainingData.length);
-    }
-
-    private void trainAndFlushSpectrum() {
-        log.info("Training Spectrum with {} vectors...", spectrumTrainingBuffer.size());
-        float[][] trainingData = spectrumTrainingBuffer.toArray(float[][]::new);
-        ((SpectorIndex) vectorIndex).train(trainingData);
-        spectrumTrained = true;
-
-        // Flush buffered vectors
-        for (int i = 0; i < spectrumTrainingBuffer.size(); i++) {
-            float[] vec = spectrumTrainingBuffer.get(i);
-            String bufferedId = spectrumTrainingIds.get(i);
-            String bufferedContent = spectrumTrainingContents.get(i);
-
-            int storeIndex = vectorStore.put(bufferedId, vec);
-            documentStore.put(Document.of(bufferedId, bufferedContent));
-            vectorIndex.add(bufferedId, storeIndex, vec);
-            keywordIndex.index(bufferedId, bufferedContent);
-        }
-
-        // Free training buffers
-        spectrumTrainingBuffer = null;
-        spectrumTrainingIds = null;
-        spectrumTrainingContents = null;
-        log.info("Spectrum trained and {} buffered vectors flushed.", trainingData.length);
-    }
-}
diff --git a/spector-engine/src/main/java/com/spectrayan/spector/engine/EngineSearch.java b/spector-engine/src/main/java/com/spectrayan/spector/engine/EngineSearch.java
deleted file mode 100644
index de31dfb..0000000
--- a/spector-engine/src/main/java/com/spectrayan/spector/engine/EngineSearch.java
+++ /dev/null
@@ -1,124 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.engine;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import com.spectrayan.spector.config.SpectorConfig;
-import com.spectrayan.spector.core.similarity.SimilarityFunction;
-import com.spectrayan.spector.embed.EmbeddingProvider;
-import com.spectrayan.spector.gpu.GpuBatchSimilarity;
-import com.spectrayan.spector.index.VectorIndex;
-import com.spectrayan.spector.query.HybridSearchOrchestrator;
-import com.spectrayan.spector.query.SearchQuery;
-import com.spectrayan.spector.query.SearchResponse;
-import com.spectrayan.spector.commons.error.SpectorInternalException;
-import com.spectrayan.spector.commons.error.ErrorCode;
-
-/**
- * Handles all search logic for the Spector engine.
- *
- * <p>Extracted from {@link SpectorEngine} to decompose the god class into
- * focused, single-responsibility components. Manages:</p>
- * <ul>
- *   <li>Hybrid, keyword, and vector search via {@link HybridSearchOrchestrator}</li>
- *   <li>Auto-embed search (text → embedding → hybrid search)</li>
- *   <li>GPU-accelerated batch similarity (with CPU fallback)</li>
- * </ul>
- */
-final class EngineSearch {
-
-    private static final Logger log = LoggerFactory.getLogger(EngineSearch.class);
-
-    private final SpectorConfig config;
-    private final HybridSearchOrchestrator orchestrator;
-    private final EmbeddingProvider embeddingProvider; // nullable
-    private final GpuBatchSimilarity gpuBatchSimilarity; // nullable
-
-    EngineSearch(SpectorConfig config, HybridSearchOrchestrator orchestrator,
-                 EmbeddingProvider embeddingProvider, GpuBatchSimilarity gpuBatchSimilarity) {
-        this.config = config;
-        this.orchestrator = orchestrator;
-        this.embeddingProvider = embeddingProvider;
-        this.gpuBatchSimilarity = gpuBatchSimilarity;
-    }
-
-    // ─────────────── Search ───────────────
-
-    /** Executes a search query. */
-    SearchResponse search(SearchQuery query) {
-        return orchestrator.search(query);
-    }
-
-    /** Convenience: keyword search. */
-    SearchResponse keywordSearch(String text, int topK) {
-        return search(SearchQuery.keyword(text, topK));
-    }
-
-    /** Convenience: vector search. */
-    SearchResponse vectorSearch(float[] vector, int topK) {
-        return search(SearchQuery.vector(vector, topK));
-    }
-
-    /** Convenience: hybrid search. */
-    SearchResponse hybridSearch(String text, float[] vector, int topK) {
-        return search(SearchQuery.hybrid(text, vector, topK));
-    }
-
-    /**
-     * Auto-embed search: embeds the query text and performs hybrid search.
-     */
-    SearchResponse search(String text, int topK) {
-        requireEmbeddingProvider();
-        float[] queryVector = embeddingProvider.embed(text).vector();
-        return hybridSearch(text, queryVector, topK);
-    }
-
-    // ─────────────── GPU-Accelerated Batch Operations ───────────────
-
-    /**
-     * Computes batch cosine similarities using GPU if available, CPU SIMD otherwise.
-     */
-    float[] batchCosineSimilarity(float[] query, float[] database, int n, int dims) {
-        if (gpuBatchSimilarity != null) {
-            return gpuBatchSimilarity.batchCosineSimilarity(query, database, n, dims);
-        }
-        // CPU SIMD fallback
-        float[] results = new float[n];
-        for (int i = 0; i < n; i++) {
-            float[] vec = new float[dims];
-            System.arraycopy(database, i * dims, vec, 0, dims);
-            results[i] = config.similarityFunction().compute(query, vec);
-        }
-        return results;
-    }
-
-    /** Returns whether GPU acceleration is active. */
-    boolean isGpuActive() {
-        return gpuBatchSimilarity != null;
-    }
-
-    HybridSearchOrchestrator orchestrator() {
-        return orchestrator;
-    }
-
-    private void requireEmbeddingProvider() {
-        if (embeddingProvider == null) {
-            throw new SpectorInternalException(ErrorCode.ARGUMENT_INVALID, com.spectrayan.spector.commons.error.ErrorCode.EMBEDDING_PROVIDER_MISSING.format());
-        }
-    }
-}
diff --git a/spector-engine/src/main/java/com/spectrayan/spector/engine/IndexType.java b/spector-engine/src/main/java/com/spectrayan/spector/engine/IndexType.java
new file mode 100644
index 0000000..c8b9b96
--- /dev/null
+++ b/spector-engine/src/main/java/com/spectrayan/spector/engine/IndexType.java
@@ -0,0 +1,19 @@
+package com.spectrayan.spector.engine;
+
+/**
+ * Selects the vector index implementation.
+ *
+ * <ul>
+ *   <li>{@link #HNSW} — Default graph-based ANN index. Best for datasets up to ~5M vectors.</li>
+ *   <li>{@link #IVF_PQ} — Inverted file with product quantization. Best for 1M+ vectors
+ *       where memory is constrained. Requires a training step.</li>
+ * </ul>
+ */
+public enum IndexType {
+
+    /** HNSW (Hierarchical Navigable Small World) graph index. Default. */
+    HNSW,
+
+    /** IVF-PQ (Inverted File with Product Quantization) index. High compression. */
+    IVF_PQ
+}
diff --git a/spector-index/src/main/java/com/spectrayan/spector/index/RescoreStrategy.java b/spector-engine/src/main/java/com/spectrayan/spector/engine/RescoreStrategy.java
similarity index 76%
rename from spector-index/src/main/java/com/spectrayan/spector/index/RescoreStrategy.java
rename to spector-engine/src/main/java/com/spectrayan/spector/engine/RescoreStrategy.java
index 96eaa3b..a274de2 100644
--- a/spector-index/src/main/java/com/spectrayan/spector/index/RescoreStrategy.java
+++ b/spector-engine/src/main/java/com/spectrayan/spector/engine/RescoreStrategy.java
@@ -1,26 +1,11 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.index;
+package com.spectrayan.spector.engine;
 
 import java.util.ArrayList;
 import java.util.List;
 import java.util.function.BiFunction;
 import java.util.function.IntFunction;
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-import com.spectrayan.spector.commons.error.ErrorCode;
+
+import com.spectrayan.spector.index.ScoredResult;
 
 /**
  * Rescore strategy that retrieves oversampled candidates from a quantized index
@@ -39,11 +24,12 @@ public final class RescoreStrategy {
      *
      * @param oversamplingFactor multiplier for the requested K to determine candidate count;
      *                           must be at least 1
-     * @throws SpectorValidationException if oversamplingFactor is less than 1
+     * @throws IllegalArgumentException if oversamplingFactor is less than 1
      */
     public RescoreStrategy(int oversamplingFactor) {
         if (oversamplingFactor < 1) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_OUT_OF_RANGE, "oversamplingFactor", 1, Integer.MAX_VALUE, oversamplingFactor);
+            throw new IllegalArgumentException(
+                    "oversamplingFactor must be at least 1, got: " + oversamplingFactor);
         }
         this.oversamplingFactor = oversamplingFactor;
     }
diff --git a/spector-config/src/main/java/com/spectrayan/spector/config/SpectorConfig.java b/spector-engine/src/main/java/com/spectrayan/spector/engine/SpectorConfig.java
similarity index 50%
rename from spector-config/src/main/java/com/spectrayan/spector/config/SpectorConfig.java
rename to spector-engine/src/main/java/com/spectrayan/spector/engine/SpectorConfig.java
index b1c7d16..e9ef4ea 100644
--- a/spector-config/src/main/java/com/spectrayan/spector/config/SpectorConfig.java
+++ b/spector-engine/src/main/java/com/spectrayan/spector/engine/SpectorConfig.java
@@ -1,29 +1,14 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.config;
+package com.spectrayan.spector.engine;
 
 import java.nio.file.Path;
 
-import com.spectrayan.spector.commons.error.ErrorCode;
-import com.spectrayan.spector.config.error.SpectorConfigValueException;
-import com.spectrayan.spector.core.quantization.QuantizationType;
-import com.spectrayan.spector.core.similarity.SimilarityFunction;
+import com.spectrayan.spector.core.QuantizationType;
+import com.spectrayan.spector.core.SimilarityFunction;
+import com.spectrayan.spector.index.HnswParams;
+import com.spectrayan.spector.storage.PersistenceMode;
 
 /**
- * Immutable configuration for a Spector engine instance.
+ * Immutable configuration for a Spector Search engine instance.
  *
  * @param dimensions         vector dimensionality
  * @param capacity           max number of documents
@@ -32,7 +17,7 @@
  * @param quantization       vector quantization strategy
  * @param persistenceMode    storage persistence mode
  * @param dataDirectory      directory for persistent index files (null for in-memory)
- * @param indexType          vector index type (HNSW, IVF_PQ, or SPECTRUM)
+ * @param indexType          vector index type (HNSW or IVF_PQ)
  * @param ivfNlist           IVF cluster count (only for IVF_PQ)
  * @param ivfNprobe          IVF probe count during search (only for IVF_PQ)
  * @param pqSubspaces        PQ subspace count M (only for IVF_PQ, must divide dimensions)
@@ -42,9 +27,6 @@
  * @param rerankerModel      Ollama model name for re-ranking (e.g., "llama3.2")
  * @param rerankerMaxCandidates max candidates to send to the LLM re-ranker
  * @param oversamplingFactor   rescore oversampling factor (0 = use default based on quantization type)
- * @param spectrumNCentroids number of IVF centroids for SPECTRUM index (0 = auto: 4×√capacity)
- * @param spectrumNProbe     number of centroids to probe at query time for SPECTRUM (0 = auto: 16)
- * @param spectrumShardThreshold shard size at which flat scan promotes to HNSW (0 = auto: 20000)
  */
 public record SpectorConfig(
         int dimensions,
@@ -63,58 +45,14 @@ public record SpectorConfig(
         String rerankerOllamaUrl,
         String rerankerModel,
         int rerankerMaxCandidates,
-        int oversamplingFactor,
-        int spectrumNCentroids,
-        int spectrumNProbe,
-        int spectrumShardThreshold
+        int oversamplingFactor
 ) {
     /** Default: 384-dim embeddings, 100K capacity, cosine similarity, HNSW, no quantization, in-memory. */
     public static final SpectorConfig DEFAULT =
             new SpectorConfig(384, 100_000, SimilarityFunction.COSINE, HnswParams.DEFAULT,
                     QuantizationType.NONE, PersistenceMode.IN_MEMORY, null,
                     IndexType.HNSW, 0, 0, 0,
-                    false, false, null, null, 20, 0,
-                    0, 0, 0);
-
-    /**
-     * Creates a {@link SpectorConfig} from hierarchical properties.
-     *
-     * <p>Reads all configuration values from the given {@link SpectorProperties},
-     * falling back to defaults defined in {@code spector-defaults.yml}.</p>
-     *
-     * @param props the hierarchical properties
-     * @return a fully configured SpectorConfig
-     */
-    public static SpectorConfig from(SpectorProperties props) {
-        var engine = SpectorConfigFactory.engineDefaults(props);
-        var hnsw = SpectorConfigFactory.hnswDefaults(props);
-        var ivf = SpectorConfigFactory.ivfDefaults(props);
-        var spectrum = SpectorConfigFactory.spectrumDefaults(props);
-        var reranker = SpectorConfigFactory.rerankerDefaults(props);
-
-        return new SpectorConfig(
-                engine.dimensions(),
-                engine.capacity(),
-                SimilarityFunction.valueOf(engine.similarity()),
-                new HnswParams(hnsw.m(), hnsw.efConstruction(), hnsw.efSearch()),
-                QuantizationType.valueOf(engine.quantization()),
-                PersistenceMode.valueOf(engine.persistenceMode()),
-                "IN_MEMORY".equals(engine.persistenceMode()) ? null : engine.dataDirectory(),
-                IndexType.valueOf(engine.indexType()),
-                ivf.nlist(),
-                ivf.nprobe(),
-                ivf.pqSubspaces(),
-                engine.gpuEnabled(),
-                reranker.enabled(),
-                reranker.ollamaUrl(),
-                reranker.model(),
-                reranker.maxCandidates(),
-                engine.oversamplingFactor(),
-                spectrum.nCentroids(),
-                spectrum.nProbe(),
-                spectrum.shardThreshold()
-        );
-    }
+                    false, false, null, null, 20, 0);
 
     /** Backward-compatible constructor (HNSW, no quantization, in-memory). */
     public SpectorConfig(int dimensions, int capacity,
@@ -122,8 +60,7 @@ public SpectorConfig(int dimensions, int capacity,
         this(dimensions, capacity, similarityFunction, hnswParams,
                 QuantizationType.NONE, PersistenceMode.IN_MEMORY, null,
                 IndexType.HNSW, 0, 0, 0,
-                false, false, null, null, 20, 0,
-                0, 0, 0);
+                false, false, null, null, 20, 0);
     }
 
     /** Pre-quantization constructor (HNSW, in-memory). */
@@ -134,8 +71,7 @@ public SpectorConfig(int dimensions, int capacity,
         this(dimensions, capacity, similarityFunction, hnswParams,
                 quantization, persistenceMode, dataDirectory,
                 IndexType.HNSW, 0, 0, 0,
-                false, false, null, null, 20, 0,
-                0, 0, 0);
+                false, false, null, null, 20, 0);
     }
 
     /** Pre-IVF-PQ constructor (no GPU, no reranker). */
@@ -147,36 +83,34 @@ public SpectorConfig(int dimensions, int capacity,
         this(dimensions, capacity, similarityFunction, hnswParams,
                 quantization, persistenceMode, dataDirectory,
                 indexType, ivfNlist, ivfNprobe, pqSubspaces,
-                false, false, null, null, 20, 0,
-                0, 0, 0);
+                false, false, null, null, 20, 0);
     }
 
     public SpectorConfig {
-        if (dimensions <= 0) throw new SpectorConfigValueException("dimensions", dimensions + " (must be positive)");
-        if (capacity <= 0) throw new SpectorConfigValueException("capacity", capacity + " (must be positive)");
+        if (dimensions <= 0) throw new IllegalArgumentException("dimensions must be positive");
+        if (capacity <= 0) throw new IllegalArgumentException("capacity must be positive");
         if (persistenceMode == PersistenceMode.DISK && dataDirectory == null) {
-            throw new SpectorConfigValueException(ErrorCode.CONFIG_REQUIRED_MISSING, "dataDirectory", "required for DISK persistence");
+            throw new IllegalArgumentException("dataDirectory required for DISK persistence");
         }
         if (indexType == IndexType.IVF_PQ && pqSubspaces > 0 && dimensions % pqSubspaces != 0) {
-            throw new SpectorConfigValueException("pqSubspaces", pqSubspaces + " (must divide dimensions=" + dimensions + ")");
+            throw new IllegalArgumentException(
+                    "dimensions (" + dimensions + ") must be divisible by pqSubspaces (" + pqSubspaces + ")");
         }
         if (rerankerEnabled && (rerankerOllamaUrl == null || rerankerOllamaUrl.isBlank())) {
-            throw new SpectorConfigValueException(ErrorCode.CONFIG_REQUIRED_MISSING, "rerankerOllamaUrl", "required when reranker is enabled");
+            throw new IllegalArgumentException("rerankerOllamaUrl is required when reranker is enabled");
         }
         if (rerankerMaxCandidates <= 0) {
             rerankerMaxCandidates = 20;
         }
     }
 
-
-
     /** Builder-style with custom dimensions. */
     public SpectorConfig withDimensions(int dims) {
         return new SpectorConfig(dims, capacity, similarityFunction, hnswParams,
                 quantization, persistenceMode, dataDirectory,
                 indexType, ivfNlist, ivfNprobe, pqSubspaces,
                 gpuEnabled, rerankerEnabled, rerankerOllamaUrl, rerankerModel, rerankerMaxCandidates,
-                oversamplingFactor, spectrumNCentroids, spectrumNProbe, spectrumShardThreshold);
+                oversamplingFactor);
     }
 
     /** Builder-style with custom capacity. */
@@ -185,7 +119,7 @@ public SpectorConfig withCapacity(int cap) {
                 quantization, persistenceMode, dataDirectory,
                 indexType, ivfNlist, ivfNprobe, pqSubspaces,
                 gpuEnabled, rerankerEnabled, rerankerOllamaUrl, rerankerModel, rerankerMaxCandidates,
-                oversamplingFactor, spectrumNCentroids, spectrumNProbe, spectrumShardThreshold);
+                oversamplingFactor);
     }
 
     /** Builder-style with custom similarity function. */
@@ -194,7 +128,7 @@ public SpectorConfig withSimilarityFunction(SimilarityFunction sf) {
                 quantization, persistenceMode, dataDirectory,
                 indexType, ivfNlist, ivfNprobe, pqSubspaces,
                 gpuEnabled, rerankerEnabled, rerankerOllamaUrl, rerankerModel, rerankerMaxCandidates,
-                oversamplingFactor, spectrumNCentroids, spectrumNProbe, spectrumShardThreshold);
+                oversamplingFactor);
     }
 
     /** Builder-style with quantization type. */
@@ -203,7 +137,7 @@ public SpectorConfig withQuantization(QuantizationType qt) {
                 qt, persistenceMode, dataDirectory,
                 indexType, ivfNlist, ivfNprobe, pqSubspaces,
                 gpuEnabled, rerankerEnabled, rerankerOllamaUrl, rerankerModel, rerankerMaxCandidates,
-                oversamplingFactor, spectrumNCentroids, spectrumNProbe, spectrumShardThreshold);
+                oversamplingFactor);
     }
 
     /** Builder-style with persistence mode and data directory. */
@@ -212,7 +146,7 @@ public SpectorConfig withPersistence(PersistenceMode mode, Path directory) {
                 quantization, mode, directory,
                 indexType, ivfNlist, ivfNprobe, pqSubspaces,
                 gpuEnabled, rerankerEnabled, rerankerOllamaUrl, rerankerModel, rerankerMaxCandidates,
-                oversamplingFactor, spectrumNCentroids, spectrumNProbe, spectrumShardThreshold);
+                oversamplingFactor);
     }
 
     /**
@@ -227,7 +161,7 @@ public SpectorConfig withIvfPq(int nlist, int nprobe, int subspaces) {
                 quantization, persistenceMode, dataDirectory,
                 IndexType.IVF_PQ, nlist, nprobe, subspaces,
                 gpuEnabled, rerankerEnabled, rerankerOllamaUrl, rerankerModel, rerankerMaxCandidates,
-                oversamplingFactor, 0, 0, 0);
+                oversamplingFactor);
     }
 
     /** Builder-style to switch to IVF-PQ index with auto parameters. */
@@ -249,7 +183,7 @@ public SpectorConfig withGpu(boolean enabled) {
                 quantization, persistenceMode, dataDirectory,
                 indexType, ivfNlist, ivfNprobe, pqSubspaces,
                 enabled, rerankerEnabled, rerankerOllamaUrl, rerankerModel, rerankerMaxCandidates,
-                oversamplingFactor, spectrumNCentroids, spectrumNProbe, spectrumShardThreshold);
+                oversamplingFactor);
     }
 
     /**
@@ -264,7 +198,7 @@ public SpectorConfig withReranker(String ollamaUrl, String model, int maxCandida
                 quantization, persistenceMode, dataDirectory,
                 indexType, ivfNlist, ivfNprobe, pqSubspaces,
                 gpuEnabled, true, ollamaUrl, model, maxCandidates,
-                oversamplingFactor, spectrumNCentroids, spectrumNProbe, spectrumShardThreshold);
+                oversamplingFactor);
     }
 
     /**
@@ -277,52 +211,6 @@ public SpectorConfig withReranker(String ollamaUrl, String model) {
         return withReranker(ollamaUrl, model, 20);
     }
 
-    /**
-     * Builder-style to enable SVASQ (FWHT-rotated INT8) quantization.
-     *
-     * <p>SVASQ applies a random Walsh-Hadamard Transform before INT8 quantization to
-     * isotropize the per-dimension variance distribution, reducing quantization error.
-     * The oversampling factor controls how many extra candidates are retrieved before
-     * exact-float rescoring (3 is a good default for ≥ 90% recall@10).</p>
-     *
-     * @param oversamplingFactor rescore oversampling factor (≥ 1; 3 recommended)
-     */
-    public SpectorConfig withSvasq(int oversamplingFactor) {
-        return new SpectorConfig(dimensions, capacity, similarityFunction, hnswParams,
-                QuantizationType.SVASQ, persistenceMode, dataDirectory,
-                indexType, ivfNlist, ivfNprobe, pqSubspaces,
-                gpuEnabled, rerankerEnabled, rerankerOllamaUrl, rerankerModel, rerankerMaxCandidates,
-                Math.max(1, oversamplingFactor),
-                spectrumNCentroids, spectrumNProbe, spectrumShardThreshold);
-    }
-
-    /** Builder-style to enable SVASQ with the default oversampling factor (3). */
-    public SpectorConfig withSvasq() {
-        return withSvasq(3);
-    }
-
-    /**
-     * Builder-style to enable SVASQ-4 (FWHT-rotated INT4, nibble-packed) quantization.
-     *
-     * <p>SVASQ-4 provides ~2× additional compression over SVASQ-8 at the cost of slightly
-     * lower fidelity. With oversampling rescore, recall@10 is typically 97–99%.</p>
-     *
-     * @param oversamplingFactor rescore oversampling factor (≥ 1; 3 recommended)
-     */
-    public SpectorConfig withSvasq4(int oversamplingFactor) {
-        return new SpectorConfig(dimensions, capacity, similarityFunction, hnswParams,
-                QuantizationType.SVASQ_4, persistenceMode, dataDirectory,
-                indexType, ivfNlist, ivfNprobe, pqSubspaces,
-                gpuEnabled, rerankerEnabled, rerankerOllamaUrl, rerankerModel, rerankerMaxCandidates,
-                Math.max(1, oversamplingFactor),
-                spectrumNCentroids, spectrumNProbe, spectrumShardThreshold);
-    }
-
-    /** Builder-style to enable SVASQ-4 with the default oversampling factor (3). */
-    public SpectorConfig withSvasq4() {
-        return withSvasq4(3);
-    }
-
     /**
      * Builder-style to set the rescore oversampling factor.
      *
@@ -331,54 +219,30 @@ public SpectorConfig withSvasq4() {
      * means 3×K candidates are retrieved, then the top K are returned after rescoring.</p>
      *
      * @param oversamplingFactor positive integer (≥ 1); factor of 1 skips rescore
-     * @throws SpectorValidationException if oversamplingFactor < 1
+     * @throws IllegalArgumentException if oversamplingFactor < 1
      */
     public SpectorConfig withRescore(int oversamplingFactor) {
         if (oversamplingFactor < 1) {
-            throw new SpectorConfigValueException("oversamplingFactor", oversamplingFactor + " (must be >= 1)");
+            throw new IllegalArgumentException(
+                    "oversamplingFactor must be >= 1, got: " + oversamplingFactor);
         }
         return new SpectorConfig(dimensions, capacity, similarityFunction, hnswParams,
                 quantization, persistenceMode, dataDirectory,
                 indexType, ivfNlist, ivfNprobe, pqSubspaces,
                 gpuEnabled, rerankerEnabled, rerankerOllamaUrl, rerankerModel, rerankerMaxCandidates,
-                oversamplingFactor, spectrumNCentroids, spectrumNProbe, spectrumShardThreshold);
-    }
-
-    /**
-     * Builder-style to switch to SPECTRUM index.
-     *
-     * <p>Spectrum combines IVF coarse routing, adaptive flat→HNSW per-shard search,
-     * and SVASQ residual INT8 quantization. Parameters control the IVF structure and
-     * the promotion threshold for flat→HNSW transition.</p>
-     *
-     * @param nCentroids     number of IVF centroids (0 = auto: 4×√capacity)
-     * @param nProbe         centroids to probe at query time (0 = auto: 16)
-     * @param shardThreshold shard size to trigger HNSW promotion (0 = auto: 20000)
-     */
-    public SpectorConfig withSpectrum(int nCentroids, int nProbe, int shardThreshold) {
-        return new SpectorConfig(dimensions, capacity, similarityFunction, hnswParams,
-                quantization, persistenceMode, dataDirectory,
-                IndexType.SPECTRUM, ivfNlist, ivfNprobe, pqSubspaces,
-                gpuEnabled, rerankerEnabled, rerankerOllamaUrl, rerankerModel, rerankerMaxCandidates,
-                oversamplingFactor, nCentroids, nProbe, shardThreshold);
-    }
-
-    /** Builder-style to switch to SPECTRUM index with auto parameters. */
-    public SpectorConfig withSpectrum() {
-        return withSpectrum(0, 0, 0);
+                oversamplingFactor);
     }
 
     /**
      * Returns the effective oversampling factor, applying defaults based on quantization type
      * when no explicit value has been set.
      *
-     * <p>Defaults: INT4 → 3, INT2 → 5, SVASQ → 3 (FWHT rotation improves recall enough
-     * that moderate oversampling achieves ≥ 90% recall@10), all others → 1 (no oversampling).</p>
+     * <p>Defaults: INT4 → 3, INT2 → 5, all others → 1 (no oversampling).</p>
      */
     public int effectiveOversamplingFactor() {
         if (oversamplingFactor > 0) return oversamplingFactor;
         return switch (quantization) {
-            case SCALAR_INT4, TURBO_QUANT, SVASQ, SVASQ_4 -> 3;
+            case SCALAR_INT4 -> 3;
             case SCALAR_INT2 -> 5;
             default -> 1;
         };
@@ -402,43 +266,4 @@ public int effectivePqSubspaces() {
         if (pqSubspaces > 0) return pqSubspaces;
         return Math.max(4, dimensions / 8);
     }
-
-    // ─────────────── Spectrum computed defaults ───────────────
-
-    /** Effective Spectrum nCentroids (auto = 4×√capacity, clamped to [16, capacity/10]). */
-    public int effectiveSpectrumNCentroids() {
-        if (spectrumNCentroids > 0) return spectrumNCentroids;
-        int auto = (int) (4 * Math.sqrt(capacity));
-        return Math.max(16, Math.min(auto, capacity / 10));
-    }
-
-    /** Effective Spectrum nProbe (auto = 16). */
-    public int effectiveSpectrumNProbe() {
-        return spectrumNProbe > 0 ? spectrumNProbe : 16;
-    }
-
-    /** Effective Spectrum shard threshold (auto = 20000). */
-    public int effectiveSpectrumShardThreshold() {
-        return spectrumShardThreshold > 0 ? spectrumShardThreshold : 20_000;
-    }
-
-    // ─────────────── Index/Vector sharding defaults ───────────────
-
-    /**
-     * Default number of nodes per shard for index and vector file sharding.
-     * At 384 dimensions × 4 bytes, this yields ~30 MB vector data per shard.
-     */
-    public static final int DEFAULT_NODES_PER_SHARD = 50_000;
-
-    /**
-     * Returns the effective nodes-per-shard for index and vector file sharding.
-     *
-     * <p>Currently returns the constant default ({@value #DEFAULT_NODES_PER_SHARD}).
-     * This can be extended to read from configuration properties if needed.</p>
-     *
-     * @return nodes per shard
-     */
-    public int effectiveNodesPerShard() {
-        return DEFAULT_NODES_PER_SHARD;
-    }
 }
diff --git a/spector-engine/src/main/java/com/spectrayan/spector/engine/SpectorEngine.java b/spector-engine/src/main/java/com/spectrayan/spector/engine/SpectorEngine.java
index ba934c2..bbf2fde 100644
--- a/spector-engine/src/main/java/com/spectrayan/spector/engine/SpectorEngine.java
+++ b/spector-engine/src/main/java/com/spectrayan/spector/engine/SpectorEngine.java
@@ -1,167 +1,747 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.engine;
 
-import com.spectrayan.spector.config.SpectorConfig;
+import com.spectrayan.spector.commons.ContentExtractor;
+import com.spectrayan.spector.commons.StreamingChunker;
+import com.spectrayan.spector.commons.TextChunker;
+import com.spectrayan.spector.commons.TokenChunker;
+import com.spectrayan.spector.core.SimilarityFunction;
+import com.spectrayan.spector.core.SimdCapability;
 import com.spectrayan.spector.embed.EmbeddingProvider;
+import com.spectrayan.spector.gpu.GpuBatchSimilarity;
+import com.spectrayan.spector.index.BM25Index;
+import com.spectrayan.spector.index.DiskHnswWriter;
+import com.spectrayan.spector.index.HnswIndex;
+import com.spectrayan.spector.index.KeywordIndex;
+import com.spectrayan.spector.index.ScoredResult;
 import com.spectrayan.spector.index.VectorIndex;
+import com.spectrayan.spector.index.ivf.IvfPqIndex;
+import com.spectrayan.spector.query.HybridSearchOrchestrator;
 import com.spectrayan.spector.query.SearchQuery;
 import com.spectrayan.spector.query.SearchResponse;
 import com.spectrayan.spector.query.ranking.Reranker;
+import com.spectrayan.spector.storage.Document;
 import com.spectrayan.spector.storage.DocumentStore;
+import com.spectrayan.spector.storage.PersistenceMode;
 import com.spectrayan.spector.storage.VectorStore;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 import java.io.IOException;
 import java.nio.file.Path;
-import java.util.function.Function;
 
 /**
- * Primary interface for the Spector engine.
+ * Unified entry-point for the Spector Search engine.
  *
- * <p>Provides a unified API for document ingestion, search, and lifecycle
- * management. Implementations include {@link DefaultSpectorEngine} (the
- * standard implementation) and metered decorators for observability.</p>
+ * <p>Manages the lifecycle of all underlying components: vector store,
+ * document store, HNSW index, BM25 index, hybrid query orchestrator,
+ * optional GPU acceleration, and optional LLM re-ranking.
+ * Provides a simple API for document ingestion and search.</p>
  *
- * <h3>Usage</h3>
+ * <h3>Construction</h3>
+ * <p>Use the fluent {@link Builder} for clean engine construction:</p>
  * <pre>{@code
- *   SpectorEngine engine = DefaultSpectorEngine.builder()
+ *   SpectorEngine engine = SpectorEngine.builder()
  *       .dimensions(384)
  *       .capacity(100_000)
+ *       .similarity(SimilarityFunction.COSINE)
+ *       .gpu(true)
+ *       .reranker("http://localhost:11434", "llama3.2")
+ *       .embeddingProvider(myProvider)
  *       .build();
+ * }</pre>
  *
- *   engine.ingest("doc-1", "Hello world", vectorData);
- *   SearchResponse response = engine.search(SearchQuery.keyword("hello", 10));
+ * <h3>Legacy Construction</h3>
+ * <pre>{@code
+ *   try (var engine = new SpectorEngine(config)) {
+ *       engine.ingest("doc-1", "Hello world", embedding);
+ *       SearchResponse response = engine.search(
+ *           SearchQuery.hybrid("hello", queryEmbedding, 10));
+ *   }
  * }</pre>
  *
- * @see DefaultSpectorEngine
+ * <h3>Design Patterns</h3>
+ * <ul>
+ *   <li><b>Facade</b> — unified API over 6+ subsystems</li>
+ *   <li><b>Builder</b> — fluent construction via {@link Builder}</li>
+ *   <li><b>Abstract Factory</b> — component assembly via {@link EngineComponentFactory}</li>
+ *   <li><b>Factory Method</b> — index/store creation via {@link VectorIndexFactory}/{@link VectorStoreFactory}</li>
+ * </ul>
  */
-public interface SpectorEngine extends AutoCloseable {
+public class SpectorEngine implements AutoCloseable {
+
+    private static final Logger log = LoggerFactory.getLogger(SpectorEngine.class);
+
+    private final SpectorConfig config;
+    private final VectorStore vectorStore;
+    private final DocumentStore documentStore;
+    private final VectorIndex vectorIndex;
+    private final KeywordIndex keywordIndex;
+    private final HybridSearchOrchestrator orchestrator;
+    private final EmbeddingProvider embeddingProvider; // nullable
+    private final GpuBatchSimilarity gpuBatchSimilarity; // nullable
+    private final Reranker reranker; // nullable
+    private volatile boolean closed;
+
+    // IVF-PQ training state — buffers vectors until enough for training
+    private java.util.List<float[]> ivfTrainingBuffer;
+    private java.util.List<String> ivfTrainingIds;
+    private java.util.List<String> ivfTrainingContents;
+    private volatile boolean ivfTrained;
+
+    // ─────────────── Construction ───────────────
+
+    /**
+     * Creates and initializes a new engine with the given configuration.
+     *
+     * <p>Components are assembled by {@link EngineComponentFactory} which
+     * uses {@link VectorIndexFactory} and {@link VectorStoreFactory} to
+     * create the appropriate implementations based on configuration.</p>
+     *
+     * @param config the engine configuration
+     */
+    public SpectorEngine(SpectorConfig config) {
+        this(config, null);
+    }
+
+    /**
+     * Creates an engine with configuration and an embedding provider.
+     *
+     * @param config   the engine configuration
+     * @param provider the embedding provider (nullable)
+     */
+    public SpectorEngine(SpectorConfig config, EmbeddingProvider provider) {
+        this(config, provider, new EngineComponentFactory());
+    }
+
+    /**
+     * Creates an engine with a custom component factory (for testing/extensibility).
+     *
+     * @param config   the engine configuration
+     * @param provider the embedding provider (nullable)
+     * @param factory  component factory for assembling subsystems
+     */
+    public SpectorEngine(SpectorConfig config, EmbeddingProvider provider,
+                         EngineComponentFactory factory) {
+        this.config = config;
+        this.embeddingProvider = provider;
+        this.closed = false;
+        this.ivfTrained = false;
+
+        log.info("Initializing SpectorEngine: dims={}, capacity={}, similarity={}, " +
+                        "quantization={}, persistence={}, indexType={}, embedding={}, " +
+                        "gpu={}, reranker={}, {}",
+                config.dimensions(), config.capacity(), config.similarityFunction(),
+                config.quantization(), config.persistenceMode(), config.indexType(),
+                provider != null ? provider.modelName() : "none",
+                config.gpuEnabled() ? "enabled" : "disabled",
+                config.rerankerEnabled() ? config.rerankerModel() : "disabled",
+                SimdCapability.report());
+
+        // ── Assemble components via Abstract Factory ──
+        EngineComponents components = factory.create(config);
+
+        this.vectorStore = components.vectorStore();
+        this.documentStore = components.documentStore();
+        this.vectorIndex = components.vectorIndex();
+        this.keywordIndex = components.keywordIndex();
+        this.reranker = components.reranker();
+        this.gpuBatchSimilarity = components.gpuBatch() instanceof GpuBatchSimilarity gpu
+                ? gpu : null;
+
+        // ── IVF-PQ training buffer initialization ──
+        if (config.indexType() == IndexType.IVF_PQ) {
+            int minTrainingSamples = Math.max(config.effectiveNlist() * 40, 256);
+            this.ivfTrainingBuffer = new java.util.ArrayList<>(minTrainingSamples);
+            this.ivfTrainingIds = new java.util.ArrayList<>(minTrainingSamples);
+            this.ivfTrainingContents = new java.util.ArrayList<>(minTrainingSamples);
+            log.info("IVF-PQ index created (untrained). Will auto-train after {} vectors.",
+                    minTrainingSamples);
+        }
+
+        // ── Wire orchestrator with optional re-ranker ──
+        this.orchestrator = new HybridSearchOrchestrator(
+                keywordIndex, vectorIndex, reranker, documentStore);
+
+        log.info("SpectorEngine initialized successfully");
+    }
+
+    /** Creates an engine with default configuration. */
+    public SpectorEngine() {
+        this(SpectorConfig.DEFAULT);
+    }
+
+    /**
+     * Returns a new fluent {@link Builder} for constructing an engine.
+     *
+     * @return a new builder
+     */
+    public static Builder builder() {
+        return new Builder();
+    }
 
     // ─────────────── Ingestion ───────────────
 
-    /** Ingests a single document with its text content and vector embedding. */
-    void ingest(String id, String content, float[] vector);
+    /**
+     * Ingests a single document with its text content and vector embedding.
+     *
+     * @param id       unique document identifier
+     * @param content  text content for keyword search
+     * @param vector   embedding vector for semantic search
+     */
+    public void ingest(String id, String content, float[] vector) {
+        ensureOpen();
+
+        // IVF-PQ auto-training: buffer vectors until we have enough to train
+        if (config.indexType() == IndexType.IVF_PQ && !ivfTrained) {
+            ivfTrainingBuffer.add(vector.clone());
+            ivfTrainingIds.add(id);
+            ivfTrainingContents.add(content);
+
+            int minSamples = Math.max(config.effectiveNlist() * 40, 256);
+            if (ivfTrainingBuffer.size() >= minSamples) {
+                trainAndFlushIvfPq();
+            } else {
+                // Still buffering — store document metadata for keyword search
+                documentStore.put(Document.of(id, content));
+                keywordIndex.index(id, content);
+                return;
+            }
+            return;
+        }
+
+        // Normal ingestion path
+        int storeIndex = vectorStore.put(id, vector);
+        documentStore.put(Document.of(id, content));
+        vectorIndex.add(id, storeIndex, vector);
+        keywordIndex.index(id, content);
+    }
 
-    /** Ingests a document with title, content, and vector. */
-    void ingest(String id, String title, String content, float[] vector);
+    /**
+     * Ingests a document with title, content, and vector.
+     *
+     * @param id       unique document identifier
+     * @param title    document title
+     * @param content  text content for keyword search
+     * @param vector   embedding vector for semantic search
+     */
+    public void ingest(String id, String title, String content, float[] vector) {
+        ensureOpen();
+
+        int storeIndex = vectorStore.put(id, vector);
+        documentStore.put(Document.of(id, title, content));
+        vectorIndex.add(id, storeIndex, vector);
+        keywordIndex.index(id, title + " " + content);
+    }
 
-    /** Ingests a batch of documents. */
-    void ingestBatch(String[] ids, String[] contents, float[][] vectors);
+    /**
+     * Ingests a batch of documents.
+     *
+     * @param ids      document IDs
+     * @param contents text contents
+     * @param vectors  embedding vectors
+     */
+    public void ingestBatch(String[] ids, String[] contents, float[][] vectors) {
+        ensureOpen();
+        for (int i = 0; i < ids.length; i++) {
+            ingest(ids[i], contents[i], vectors[i]);
+        }
+    }
 
-    /** Deletes a document by ID from all indexes. */
-    boolean delete(String id);
+    /**
+     * Deletes a document by ID from all indexes.
+     *
+     * <p>Removes the document from the document store and keyword index.
+     * Note: vector index entries are not removed (HNSW does not support
+     * point deletion); they become orphaned and will not appear in
+     * results because the document store lookup will return null.</p>
+     *
+     * @param id document identifier to delete
+     * @return true if the document existed and was removed
+     */
+    public boolean delete(String id) {
+        ensureOpen();
+        Document removed = documentStore.remove(id);
+        if (removed != null) {
+            keywordIndex.remove(id);
+            log.debug("Deleted document '{}'", id);
+            return true;
+        }
+        return false;
+    }
 
-    /** Ingests a large document by splitting it into overlapping chunks. */
-    int ingestChunked(String id, String content,
-                      Function<String, float[]> vectorProvider);
+    // ─────────────── Large Document Ingestion ───────────────
+
+    /**
+     * Ingests a large document by splitting it into overlapping chunks.
+     *
+     * @param id            document ID
+     * @param content       full document text
+     * @param vectorProvider function mapping chunk text to an embedding vector
+     * @return number of chunks ingested
+     */
+    public int ingestChunked(String id, String content,
+                             java.util.function.Function<String, float[]> vectorProvider) {
+        return ingestChunked(id, content, vectorProvider, new TextChunker());
+    }
 
-    /** Ingests a large document with a custom chunker configuration. */
-    int ingestChunked(String id, String content,
-                      Function<String, float[]> vectorProvider,
-                      com.spectrayan.spector.commons.TextChunker chunker);
+    /**
+     * Ingests a large document with a custom chunker configuration.
+     *
+     * @param id            document ID
+     * @param content       full document text
+     * @param vectorProvider function mapping chunk text to an embedding vector
+     * @param chunker       configured TextChunker
+     * @return number of chunks ingested
+     */
+    public int ingestChunked(String id, String content,
+                             java.util.function.Function<String, float[]> vectorProvider,
+                             TextChunker chunker) {
+        ensureOpen();
+
+        // Store the full document metadata
+        documentStore.put(Document.of(id, content));
+
+        var chunks = chunker.chunk(id, content);
+        for (var chunk : chunks) {
+            float[] vector = vectorProvider.apply(chunk.text());
+            int storeIndex = vectorStore.put(chunk.chunkId(), vector);
+            vectorIndex.add(chunk.chunkId(), storeIndex, vector);
+            keywordIndex.index(chunk.chunkId(), chunk.text());
+        }
+
+        log.info("Ingested '{}' as {} chunks (chunkSize={}, overlap={})",
+                id, chunks.size(), chunker.chunkSize(), chunker.overlap());
+        return chunks.size();
+    }
 
-    /** Ingests structured content (XML, JSON, Java objects) by extracting text. */
-    void ingestStructured(String id, String content, float[] vector);
+    /**
+     * Ingests structured content (XML, JSON, Java objects) by extracting text.
+     *
+     * @param id            document ID
+     * @param content       structured content (XML, JSON, or plain text)
+     * @param vector        embedding vector (for the extracted text)
+     */
+    public void ingestStructured(String id, String content, float[] vector) {
+        String extracted = ContentExtractor.extract(content);
+        ingest(id, extracted, vector);
+    }
 
-    /** Ingests a large file using streaming chunking with bounded memory. */
-    int ingestFile(Path path, String documentId,
-                   Function<String, float[]> vectorProvider,
-                   int chunkSize, int overlap) throws IOException;
+    /**
+     * Ingests a large file using streaming chunking with bounded memory.
+     *
+     * @param path           path to the text file
+     * @param documentId     parent document ID
+     * @param vectorProvider function mapping chunk text to an embedding vector
+     * @param chunkSize      target chunk size in characters
+     * @param overlap        overlap between chunks in characters
+     * @return number of chunks ingested
+     * @throws java.io.IOException if the file cannot be read
+     */
+    public int ingestFile(java.nio.file.Path path, String documentId,
+                          java.util.function.Function<String, float[]> vectorProvider,
+                          int chunkSize, int overlap) throws java.io.IOException {
+        ensureOpen();
+        int count = 0;
+
+        try (var stream = StreamingChunker.chunkFile(path, documentId, chunkSize, overlap)) {
+            var iter = stream.iterator();
+            while (iter.hasNext()) {
+                var chunk = iter.next();
+                float[] vector = vectorProvider.apply(chunk.text());
+                int storeIndex = vectorStore.put(chunk.chunkId(), vector);
+                vectorIndex.add(chunk.chunkId(), storeIndex, vector);
+                keywordIndex.index(chunk.chunkId(), chunk.text());
+                count++;
+            }
+        }
+
+        log.info("Streaming-ingested file '{}' as {} chunks (chunkSize={}, overlap={})",
+                path.getFileName(), count, chunkSize, overlap);
+        return count;
+    }
 
-    /** Ingests a large document using token-level chunking. */
-    int ingestTokenChunked(String id, String content,
-                           Function<String, float[]> vectorProvider,
-                           int maxTokens, int overlapTokens);
+    /**
+     * Ingests a large document using token-level chunking for precise token limits.
+     *
+     * @param id            document ID
+     * @param content       full document text
+     * @param vectorProvider function mapping chunk text to an embedding vector
+     * @param maxTokens     maximum tokens per chunk
+     * @param overlapTokens overlap tokens between chunks
+     * @return number of chunks ingested
+     */
+    public int ingestTokenChunked(String id, String content,
+                                  java.util.function.Function<String, float[]> vectorProvider,
+                                  int maxTokens, int overlapTokens) {
+        ensureOpen();
+
+        var chunker = new TokenChunker(maxTokens, overlapTokens);
+        documentStore.put(Document.of(id, content));
+
+        var chunks = chunker.chunk(id, content);
+        for (var chunk : chunks) {
+            float[] vector = vectorProvider.apply(chunk.text());
+            int storeIndex = vectorStore.put(chunk.chunkId(), vector);
+            vectorIndex.add(chunk.chunkId(), storeIndex, vector);
+            keywordIndex.index(chunk.chunkId(), chunk.text());
+        }
+
+        log.info("Token-chunked '{}' into {} chunks (maxTokens={}, overlap={})",
+                id, chunks.size(), maxTokens, overlapTokens);
+        return chunks.size();
+    }
 
-    /** Ingests a document with automatic embedding generation. */
-    void ingest(String id, String content);
+    // ─────────────── Auto-Embed Ingestion ───────────────
+
+    /**
+     * Ingests a document with automatic embedding generation.
+     * Requires an {@link EmbeddingProvider} to be configured.
+     *
+     * @param id      unique document identifier
+     * @param content text content
+     * @throws IllegalStateException if no embedding provider is configured
+     */
+    public void ingest(String id, String content) {
+        ensureOpen();
+        requireEmbeddingProvider();
+        float[] vector = embeddingProvider.embed(content).vector();
+        ingest(id, content, vector);
+    }
 
-    /** Ingests a document with title and automatic embedding. */
-    void ingest(String id, String title, String content);
+    /**
+     * Ingests a document with title and automatic embedding.
+     *
+     * @param id      unique document identifier
+     * @param title   document title
+     * @param content text content
+     */
+    public void ingest(String id, String title, String content) {
+        ensureOpen();
+        requireEmbeddingProvider();
+        float[] vector = embeddingProvider.embed(title + " " + content).vector();
+        ingest(id, title, content, vector);
+    }
 
-    /** Auto-embed chunked ingestion for large documents. */
-    int ingestChunkedAuto(String id, String content);
+    /**
+     * Auto-embed chunked ingestion for large documents.
+     *
+     * @param id      document ID
+     * @param content full document text
+     * @return number of chunks ingested
+     */
+    public int ingestChunkedAuto(String id, String content) {
+        requireEmbeddingProvider();
+        return ingestChunked(id, content, text -> embeddingProvider.embed(text).vector());
+    }
 
-    /** Auto-embed file ingestion with streaming. */
-    int ingestFileAuto(Path path, String documentId,
-                       int chunkSize, int overlap) throws IOException;
+    /**
+     * Auto-embed file ingestion with streaming.
+     *
+     * @param path       path to the text file
+     * @param documentId parent document ID
+     * @param chunkSize  target chunk size in characters
+     * @param overlap    overlap between chunks
+     * @return number of chunks ingested
+     * @throws java.io.IOException if the file cannot be read
+     */
+    public int ingestFileAuto(java.nio.file.Path path, String documentId,
+                              int chunkSize, int overlap) throws java.io.IOException {
+        requireEmbeddingProvider();
+        return ingestFile(path, documentId,
+                text -> embeddingProvider.embed(text).vector(), chunkSize, overlap);
+    }
 
     // ─────────────── Search ───────────────
 
-    /** Executes a search query. */
-    SearchResponse search(SearchQuery query);
+    /**
+     * Executes a search query.
+     *
+     * @param query the search query
+     * @return the search response
+     */
+    public SearchResponse search(SearchQuery query) {
+        ensureOpen();
+        return orchestrator.search(query);
+    }
 
     /** Convenience: keyword search. */
-    SearchResponse keywordSearch(String text, int topK);
+    public SearchResponse keywordSearch(String text, int topK) {
+        return search(SearchQuery.keyword(text, topK));
+    }
 
     /** Convenience: vector search. */
-    SearchResponse vectorSearch(float[] vector, int topK);
+    public SearchResponse vectorSearch(float[] vector, int topK) {
+        return search(SearchQuery.vector(vector, topK));
+    }
 
     /** Convenience: hybrid search. */
-    SearchResponse hybridSearch(String text, float[] vector, int topK);
+    public SearchResponse hybridSearch(String text, float[] vector, int topK) {
+        return search(SearchQuery.hybrid(text, vector, topK));
+    }
 
-    /** Auto-embed search: embeds the query text and performs hybrid search. */
-    SearchResponse search(String text, int topK);
+    /**
+     * Auto-embed search: embeds the query text and performs hybrid search.
+     *
+     * @param text query text
+     * @param topK max results
+     * @return search response
+     */
+    public SearchResponse search(String text, int topK) {
+        ensureOpen();
+        requireEmbeddingProvider();
+        float[] queryVector = embeddingProvider.embed(text).vector();
+        return hybridSearch(text, queryVector, topK);
+    }
 
     // ─────────────── GPU-Accelerated Batch Operations ───────────────
 
-    /** Computes batch cosine similarities using GPU if available, CPU SIMD otherwise. */
-    float[] batchCosineSimilarity(float[] query, float[] database, int n, int dims);
+    /**
+     * Computes batch cosine similarities using GPU if available, CPU SIMD otherwise.
+     *
+     * @param query    query vector
+     * @param database flat database vectors (N × D)
+     * @param n        number of database vectors
+     * @param dims     vector dimensionality
+     * @return array of N similarity scores
+     */
+    public float[] batchCosineSimilarity(float[] query, float[] database, int n, int dims) {
+        ensureOpen();
+        if (gpuBatchSimilarity != null) {
+            return gpuBatchSimilarity.batchCosineSimilarity(query, database, n, dims);
+        }
+        // CPU SIMD fallback
+        float[] results = new float[n];
+        for (int i = 0; i < n; i++) {
+            float[] vec = new float[dims];
+            System.arraycopy(database, i * dims, vec, 0, dims);
+            results[i] = config.similarityFunction().compute(query, vec);
+        }
+        return results;
+    }
 
     /** Returns whether GPU acceleration is active. */
-    boolean isGpuActive();
+    public boolean isGpuActive() {
+        return gpuBatchSimilarity != null;
+    }
 
     // ─────────────── Accessors ───────────────
 
     /** Returns the engine configuration. */
-    SpectorConfig config();
+    public SpectorConfig config() { return config; }
 
     /** Returns the number of indexed documents. */
-    int documentCount();
+    public int documentCount() { return vectorStore.size(); }
 
     /** Returns the document store. */
-    DocumentStore documentStore();
+    public DocumentStore documentStore() { return documentStore; }
 
     /** Returns the vector store. */
-    VectorStore vectorStore();
-
-    /** Returns the underlying vector index (for ANN pre-filtering by Memory). */
-    VectorIndex index();
+    public VectorStore vectorStore() { return vectorStore; }
 
     /** Returns the embedding provider, or null if none configured. */
-    EmbeddingProvider embeddingProvider();
+    public EmbeddingProvider embeddingProvider() { return embeddingProvider; }
 
     /** Returns true if an embedding provider is configured. */
-    boolean hasEmbeddingProvider();
+    public boolean hasEmbeddingProvider() { return embeddingProvider != null; }
 
     /** Returns the active re-ranker, or null if none configured. */
-    Reranker reranker();
+    public Reranker reranker() { return reranker; }
 
     /** Returns true if LLM re-ranking is active. */
-    boolean isRerankerActive();
+    public boolean isRerankerActive() { return reranker != null; }
 
-    /** Returns the engine's ingestion target for use with the unified IngestionPipeline. */
-    EngineIngestionTarget target();
+    // ─────────────── Lifecycle ───────────────
 
-    /** Closes the engine and releases all resources. */
     @Override
-    void close();
+    public synchronized void close() {
+        if (!closed) {
+            closed = true;
+            try {
+                // Persist to disk if configured
+                if (config.persistenceMode() == PersistenceMode.DISK
+                        && vectorIndex instanceof HnswIndex hnswIdx
+                        && hnswIdx.size() > 0) {
+                    try {
+                        Path indexFile = config.dataDirectory().resolve("index.spct");
+                        DiskHnswWriter.write(hnswIdx, indexFile);
+                        log.info("HNSW index persisted to {}", indexFile);
+                    } catch (IOException e) {
+                        log.error("Failed to persist HNSW index to disk", e);
+                    }
+                }
+
+                orchestrator.close();
+                vectorIndex.close();
+                keywordIndex.close();
+                vectorStore.close();
+                documentStore.close();
+                if (embeddingProvider != null) embeddingProvider.close();
+                if (gpuBatchSimilarity != null) gpuBatchSimilarity.close();
+            } catch (Exception e) {
+                log.warn("Error during engine shutdown", e);
+            }
+            log.info("SpectorEngine closed");
+        }
+    }
+
+    private void ensureOpen() {
+        if (closed) throw new IllegalStateException("SpectorEngine is closed");
+    }
+
+    private void requireEmbeddingProvider() {
+        if (embeddingProvider == null) {
+            throw new IllegalStateException(
+                    "No EmbeddingProvider configured. Use SpectorEngine(config, provider) or supply vectors manually.");
+        }
+    }
+
+    /**
+     * Trains the IVF-PQ index on buffered vectors and flushes all buffered documents into the index.
+     */
+    private void trainAndFlushIvfPq() {
+        if (!(vectorIndex instanceof IvfPqIndex ivfPq)) return;
+
+        float[][] trainingData = ivfTrainingBuffer.toArray(float[][]::new);
+        log.info("Auto-training IVF-PQ with {} vectors...", trainingData.length);
+        ivfPq.train(trainingData);
+
+        // Flush all buffered vectors into the index
+        for (int i = 0; i < ivfTrainingBuffer.size(); i++) {
+            float[] vec = ivfTrainingBuffer.get(i);
+            String id = ivfTrainingIds.get(i);
+            String content = ivfTrainingContents.get(i);
+
+            int storeIndex = vectorStore.put(id, vec);
+            documentStore.put(Document.of(id, content));
+            vectorIndex.add(id, storeIndex, vec);
+            keywordIndex.index(id, content);
+        }
+
+        // Clear buffers
+        ivfTrainingBuffer = null;
+        ivfTrainingIds = null;
+        ivfTrainingContents = null;
+        ivfTrained = true;
+        log.info("IVF-PQ training complete. {} vectors indexed.", ivfPq.size());
+    }
 
-    /** Returns a new fluent {@link DefaultSpectorEngine.Builder} for constructing an engine. */
-    static DefaultSpectorEngine.Builder builder() {
-        return DefaultSpectorEngine.builder();
+    // ═════════════════════════════════════════════════════════════════
+    //  Builder Pattern
+    // ═════════════════════════════════════════════════════════════════
+
+    /**
+     * Fluent builder for constructing {@link SpectorEngine} instances.
+     *
+     * <p>Provides a readable, type-safe API for configuring the engine:</p>
+     * <pre>{@code
+     *   SpectorEngine engine = SpectorEngine.builder()
+     *       .dimensions(768)
+     *       .capacity(500_000)
+     *       .similarity(SimilarityFunction.DOT_PRODUCT)
+     *       .quantization(QuantizationType.SCALAR_INT8)
+     *       .persistence(PersistenceMode.DISK, Path.of("/data"))
+     *       .gpu(true)
+     *       .reranker("http://localhost:11434", "llama3.2", 30)
+     *       .embeddingProvider(new OllamaEmbeddingProvider(...))
+     *       .build();
+     * }</pre>
+     */
+    public static final class Builder {
+
+        private SpectorConfig config = SpectorConfig.DEFAULT;
+        private EmbeddingProvider embeddingProvider;
+        private EngineComponentFactory componentFactory;
+
+        Builder() {}
+
+        /** Sets vector dimensionality (default: 384). */
+        public Builder dimensions(int dims) {
+            this.config = config.withDimensions(dims);
+            return this;
+        }
+
+        /** Sets max document capacity (default: 100,000). */
+        public Builder capacity(int capacity) {
+            this.config = config.withCapacity(capacity);
+            return this;
+        }
+
+        /** Sets the similarity function (default: COSINE). */
+        public Builder similarity(SimilarityFunction sf) {
+            this.config = config.withSimilarityFunction(sf);
+            return this;
+        }
+
+        /** Sets quantization type (default: NONE). */
+        public Builder quantization(com.spectrayan.spector.core.QuantizationType qt) {
+            this.config = config.withQuantization(qt);
+            return this;
+        }
+
+        /** Sets persistence mode and data directory. */
+        public Builder persistence(PersistenceMode mode, Path directory) {
+            this.config = config.withPersistence(mode, directory);
+            return this;
+        }
+
+        /** Switches to IVF-PQ index with auto parameters. */
+        public Builder ivfPq() {
+            this.config = config.withIvfPq();
+            return this;
+        }
+
+        /** Switches to IVF-PQ index with explicit parameters. */
+        public Builder ivfPq(int nlist, int nprobe, int subspaces) {
+            this.config = config.withIvfPq(nlist, nprobe, subspaces);
+            return this;
+        }
+
+        /** Enables or disables GPU acceleration. */
+        public Builder gpu(boolean enabled) {
+            this.config = config.withGpu(enabled);
+            return this;
+        }
+
+        /** Enables LLM re-ranking with default max candidates. */
+        public Builder reranker(String ollamaUrl, String model) {
+            this.config = config.withReranker(ollamaUrl, model);
+            return this;
+        }
+
+        /** Enables LLM re-ranking with explicit max candidates. */
+        public Builder reranker(String ollamaUrl, String model, int maxCandidates) {
+            this.config = config.withReranker(ollamaUrl, model, maxCandidates);
+            return this;
+        }
+
+        /** Sets the embedding provider for auto-embed ingestion and search. */
+        public Builder embeddingProvider(EmbeddingProvider provider) {
+            this.embeddingProvider = provider;
+            return this;
+        }
+
+        /** Sets a custom component factory (for testing). */
+        public Builder componentFactory(EngineComponentFactory factory) {
+            this.componentFactory = factory;
+            return this;
+        }
+
+        /** Sets the full config directly (advanced). */
+        public Builder config(SpectorConfig config) {
+            this.config = config;
+            return this;
+        }
+
+        /**
+         * Builds and returns a fully initialized {@link SpectorEngine}.
+         *
+         * @return a new engine instance
+         */
+        public SpectorEngine build() {
+            EngineComponentFactory factory = componentFactory != null
+                    ? componentFactory : new EngineComponentFactory();
+            return new SpectorEngine(config, embeddingProvider, factory);
+        }
     }
 }
diff --git a/spector-engine/src/main/java/com/spectrayan/spector/engine/VectorIndexFactory.java b/spector-engine/src/main/java/com/spectrayan/spector/engine/VectorIndexFactory.java
new file mode 100644
index 0000000..4d66a82
--- /dev/null
+++ b/spector-engine/src/main/java/com/spectrayan/spector/engine/VectorIndexFactory.java
@@ -0,0 +1,124 @@
+package com.spectrayan.spector.engine;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.spectrayan.spector.core.QuantizationType;
+import com.spectrayan.spector.index.HnswIndex;
+import com.spectrayan.spector.index.QuantizedHnswIndex;
+import com.spectrayan.spector.index.VectorIndex;
+import com.spectrayan.spector.index.ivf.IvfPqIndex;
+
+/**
+ * Factory Method pattern for creating {@link VectorIndex} instances.
+ *
+ * <p>Centralizes the index creation logic that was previously inlined
+ * in {@link SpectorEngine}'s constructor. New index types can be added
+ * by extending this class or adding a case to the factory method —
+ * without modifying the engine itself (Open/Closed Principle).</p>
+ *
+ * <h3>Supported Index Types</h3>
+ * <ul>
+ *   <li>{@link IndexType#HNSW} — Standard or quantized HNSW graph index</li>
+ *   <li>{@link IndexType#IVF_PQ} — Inverted file with product quantization</li>
+ * </ul>
+ */
+public class VectorIndexFactory {
+
+    private static final Logger log = LoggerFactory.getLogger(VectorIndexFactory.class);
+
+    /**
+     * Creates a {@link VectorIndex} based on the engine configuration.
+     *
+     * <p>If GPU is enabled with INT4 or INT2 quantization but the vector dimensions
+     * are not a multiple of 32, GPU acceleration is disabled for this index and a
+     * warning is logged. The index will fall back to CPU/SIMD computation.</p>
+     *
+     * @param config the engine configuration
+     * @return a new, empty vector index
+     */
+    public VectorIndex create(SpectorConfig config) {
+        SpectorConfig effectiveConfig = applyGpuFallbackIfNeeded(config);
+        return switch (effectiveConfig.indexType()) {
+            case HNSW -> createHnsw(effectiveConfig);
+            case IVF_PQ -> createIvfPq(effectiveConfig);
+        };
+    }
+
+    /**
+     * Checks whether GPU must be disabled due to non-aligned dimensions for INT4/INT2.
+     *
+     * <p>GPU-accelerated distance computation for INT4 and INT2 packed formats requires
+     * vector dimensions to be a multiple of 32. When this alignment requirement is not met,
+     * this method disables GPU and returns a modified config that falls back to CPU/SIMD.</p>
+     *
+     * @param config the original engine configuration
+     * @return the config with GPU disabled if fallback is needed, otherwise the original config
+     */
+    SpectorConfig applyGpuFallbackIfNeeded(SpectorConfig config) {
+        if (!config.gpuEnabled()) {
+            return config;
+        }
+
+        QuantizationType quantization = config.quantization();
+        if (quantization != QuantizationType.SCALAR_INT4 && quantization != QuantizationType.SCALAR_INT2) {
+            return config;
+        }
+
+        if (config.dimensions() % 32 != 0) {
+            log.warn("GPU acceleration disabled for {} quantization: vector dimensions {} "
+                            + "are not a multiple of 32. Falling back to CPU/SIMD computation.",
+                    quantization, config.dimensions());
+            return config.withGpu(false);
+        }
+
+        return config;
+    }
+
+    /**
+     * Creates an HNSW-based index, optionally with scalar quantization.
+     */
+    private VectorIndex createHnsw(SpectorConfig config) {
+        QuantizationType qt = config.quantization();
+
+        if (qt == QuantizationType.SCALAR_INT8) {
+            log.info("Creating QuantizedHnswIndex (SQ8): dims={}, capacity={}",
+                    config.dimensions(), config.capacity());
+            return new QuantizedHnswIndex(
+                    config.dimensions(), config.capacity(),
+                    config.similarityFunction(), config.hnswParams());
+        }
+
+        if (qt == QuantizationType.SCALAR_INT4 || qt == QuantizationType.SCALAR_INT2) {
+            int effectiveOversampling = config.effectiveOversamplingFactor();
+            log.info("Creating QuantizedHnswIndex ({}): dims={}, capacity={}, oversampling={}",
+                    qt, config.dimensions(), config.capacity(), effectiveOversampling);
+            // NonUniformQuantizer will be injected after calibration during ingestion;
+            // pass null here for lazy calibration (index will require quantizer before search)
+            return new QuantizedHnswIndex(
+                    config.dimensions(), config.capacity(),
+                    config.similarityFunction(), config.hnswParams(),
+                    null, qt, null, effectiveOversampling);
+        }
+
+        log.info("Creating HnswIndex: dims={}, capacity={}", config.dimensions(), config.capacity());
+        return new HnswIndex(
+                config.dimensions(), config.capacity(),
+                config.similarityFunction(), config.hnswParams());
+    }
+
+    /**
+     * Creates an IVF-PQ index (untrained — training happens during ingestion).
+     */
+    private VectorIndex createIvfPq(SpectorConfig config) {
+        log.info("Creating IvfPqIndex: dims={}, nlist={}, nprobe={}, M={}",
+                config.dimensions(), config.effectiveNlist(),
+                config.effectiveNprobe(), config.effectivePqSubspaces());
+        return new IvfPqIndex(
+                config.dimensions(),
+                config.effectiveNlist(),
+                config.effectiveNprobe(),
+                config.effectivePqSubspaces(),
+                config.similarityFunction());
+    }
+}
diff --git a/spector-storage/src/main/java/com/spectrayan/spector/storage/VectorStoreFactory.java b/spector-engine/src/main/java/com/spectrayan/spector/engine/VectorStoreFactory.java
similarity index 50%
rename from spector-storage/src/main/java/com/spectrayan/spector/storage/VectorStoreFactory.java
rename to spector-engine/src/main/java/com/spectrayan/spector/engine/VectorStoreFactory.java
index 56d89b7..5022805 100644
--- a/spector-storage/src/main/java/com/spectrayan/spector/storage/VectorStoreFactory.java
+++ b/spector-engine/src/main/java/com/spectrayan/spector/engine/VectorStoreFactory.java
@@ -1,24 +1,9 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.storage;
-
+package com.spectrayan.spector.engine;
 
-import com.spectrayan.spector.config.SpectorConfig;
-import com.spectrayan.spector.config.PersistenceMode;
-import com.spectrayan.spector.config.PersistenceFiles;
+import com.spectrayan.spector.storage.InMemoryVectorStore;
+import com.spectrayan.spector.storage.MappedVectorStore;
+import com.spectrayan.spector.storage.PersistenceMode;
+import com.spectrayan.spector.storage.VectorStore;
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -43,15 +28,6 @@
 public class VectorStoreFactory {
 
     private static final Logger log = LoggerFactory.getLogger(VectorStoreFactory.class);
-    private final PersistenceFiles persistenceFiles;
-
-    public VectorStoreFactory() {
-        this(PersistenceFiles.DEFAULTS);
-    }
-
-    public VectorStoreFactory(PersistenceFiles persistenceFiles) {
-        this.persistenceFiles = persistenceFiles;
-    }
 
     /**
      * Creates a {@link VectorStore} based on the engine configuration.
@@ -73,15 +49,13 @@ private VectorStore createInMemory(SpectorConfig config) {
     }
 
     private VectorStore createMapped(SpectorConfig config) {
-        Path shardDir = persistenceFiles.resolveShardDir(config.dataDirectory());
-        int nodesPerShard = config.effectiveNodesPerShard();
-        log.info("Creating ShardedMappedVectorStore: dims={}, capacity={}, nodesPerShard={}, dir={}",
-                config.dimensions(), config.capacity(), nodesPerShard, shardDir);
+        Path file = config.dataDirectory().resolve("vectors.mmap");
+        log.info("Creating MappedVectorStore: dims={}, capacity={}, path={}",
+                config.dimensions(), config.capacity(), file);
         try {
-            return new ShardedMappedVectorStore(shardDir, config.dimensions(),
-                    config.capacity(), nodesPerShard);
+            return new MappedVectorStore(file, config.dimensions(), config.capacity());
         } catch (IOException e) {
-            throw new UncheckedIOException("Failed to create sharded vector store: " + shardDir, e);
+            throw new UncheckedIOException("Failed to create memory-mapped vector store: " + file, e);
         }
     }
 }
diff --git a/spector-engine/src/main/java/com/spectrayan/spector/engine/package-info.java b/spector-engine/src/main/java/com/spectrayan/spector/engine/package-info.java
index 9d18dd3..6ef536c 100644
--- a/spector-engine/src/main/java/com/spectrayan/spector/engine/package-info.java
+++ b/spector-engine/src/main/java/com/spectrayan/spector/engine/package-info.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 /**
  * Spector Engine — Unified search engine facade, lifecycle management, and ingestion pipeline.
  *
diff --git a/spector-engine/src/main/java/com/spectrayan/spector/engine/rag/ChunkAttribution.java b/spector-engine/src/main/java/com/spectrayan/spector/engine/rag/ChunkAttribution.java
new file mode 100644
index 0000000..8d40129
--- /dev/null
+++ b/spector-engine/src/main/java/com/spectrayan/spector/engine/rag/ChunkAttribution.java
@@ -0,0 +1,19 @@
+package com.spectrayan.spector.engine.rag;
+
+/**
+ * Source attribution metadata for a chunk included in the assembled context.
+ *
+ * @param documentId  the identifier of the source document
+ * @param chunkOffset the offset (index) of the chunk within the source document
+ */
+public record ChunkAttribution(String documentId, int chunkOffset) {
+
+    public ChunkAttribution {
+        if (documentId == null || documentId.isBlank()) {
+            throw new IllegalArgumentException("documentId must not be null or blank");
+        }
+        if (chunkOffset < 0) {
+            throw new IllegalArgumentException("chunkOffset must not be negative");
+        }
+    }
+}
diff --git a/spector-rag/src/main/java/com/spectrayan/spector/rag/ContextBuilder.java b/spector-engine/src/main/java/com/spectrayan/spector/engine/rag/ContextBuilder.java
similarity index 74%
rename from spector-rag/src/main/java/com/spectrayan/spector/rag/ContextBuilder.java
rename to spector-engine/src/main/java/com/spectrayan/spector/engine/rag/ContextBuilder.java
index fde33a7..b6645fa 100644
--- a/spector-rag/src/main/java/com/spectrayan/spector/rag/ContextBuilder.java
+++ b/spector-engine/src/main/java/com/spectrayan/spector/engine/rag/ContextBuilder.java
@@ -1,34 +1,18 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.rag;
+package com.spectrayan.spector.engine.rag;
 
 import java.util.ArrayList;
 import java.util.Comparator;
 import java.util.List;
 
 import com.spectrayan.spector.commons.WordTokenizer;
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-import com.spectrayan.spector.commons.error.ErrorCode;
 
 /**
  * Assembles scored chunks into a coherent context string within a configured token limit.
  *
  * <p>Chunks are ordered by descending relevance score. When the total token count exceeds
  * the limit, lowest-scored chunks are removed until the remaining chunks fit. Uses
- * {@link WordTokenizer#countTokens(String)} for consistent token measurement.</p>
+ * {@link WordTokenizer#countTokens(String)} for consistent token measurement with the
+ * Chunking Engine.</p>
  *
  * <h3>Usage</h3>
  * <pre>{@code
@@ -44,7 +28,9 @@ public class ContextBuilder {
     /** Maximum allowed token limit. */
     private static final int MAX_TOKEN_LIMIT = 131_072;
 
-    /** Separator inserted between chunks in the assembled context string. */
+    /**
+     * Separator inserted between chunks in the assembled context string.
+     */
     private static final String CHUNK_SEPARATOR = "\n\n";
 
     /**
@@ -57,18 +43,20 @@ public class ContextBuilder {
      * @param chunks     the scored chunks from retrieval
      * @param tokenLimit the maximum number of tokens allowed in the assembled context
      * @return the assembled context result with attributions
-     * @throws SpectorValidationException if tokenLimit is outside the valid range [256, 131072]
+     * @throws IllegalArgumentException if tokenLimit is outside the valid range [256, 131072]
      */
     public ContextResult build(List<ScoredChunk> chunks, int tokenLimit) {
         if (tokenLimit < MIN_TOKEN_LIMIT || tokenLimit > MAX_TOKEN_LIMIT) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_OUT_OF_RANGE, "tokenLimit", MIN_TOKEN_LIMIT, MAX_TOKEN_LIMIT, tokenLimit);
+            throw new IllegalArgumentException(
+                    "tokenLimit must be between " + MIN_TOKEN_LIMIT + " and " + MAX_TOKEN_LIMIT
+                            + ", got: " + tokenLimit);
         }
 
         if (chunks == null || chunks.isEmpty()) {
             return ContextResult.empty();
         }
 
-        // Sort by descending score; stable sort preserves original retrieval order for ties
+        // Sort by descending score; for equal scores, preserve original retrieval order (stable sort)
         List<ScoredChunk> sorted = new ArrayList<>(chunks);
         sorted.sort(Comparator.comparingDouble(ScoredChunk::score).reversed());
 
@@ -84,6 +72,7 @@ public ContextResult build(List<ScoredChunk> chunks, int tokenLimit) {
                 included.add(sc);
                 totalTokens += separatorTokens + chunkTokens;
             }
+            // If even the highest-scored chunk doesn't fit alone, skip it
         }
 
         if (included.isEmpty()) {
@@ -111,7 +100,12 @@ public ContextResult build(List<ScoredChunk> chunks, int tokenLimit) {
         return new ContextResult(contextText.toString(), attributions, false);
     }
 
+    /**
+     * Returns the token count of the chunk separator.
+     * Cached effectively since the separator is constant.
+     */
     private int countSeparatorTokens() {
+        // Two newlines contain no word tokens per WordTokenizer (whitespace only)
         return WordTokenizer.countTokens(CHUNK_SEPARATOR);
     }
 }
diff --git a/spector-engine/src/main/java/com/spectrayan/spector/engine/rag/ContextResult.java b/spector-engine/src/main/java/com/spectrayan/spector/engine/rag/ContextResult.java
new file mode 100644
index 0000000..f09adac
--- /dev/null
+++ b/spector-engine/src/main/java/com/spectrayan/spector/engine/rag/ContextResult.java
@@ -0,0 +1,30 @@
+package com.spectrayan.spector.engine.rag;
+
+import java.util.List;
+
+/**
+ * Result of context assembly by the {@link ContextBuilder}.
+ *
+ * @param contextText  the assembled context string (empty if no chunks fit)
+ * @param attributions source attribution entries for each included chunk
+ * @param isEmpty      indicator that no chunks were included in the context
+ */
+public record ContextResult(String contextText, List<ChunkAttribution> attributions, boolean isEmpty) {
+
+    public ContextResult {
+        if (contextText == null) {
+            throw new IllegalArgumentException("contextText must not be null");
+        }
+        if (attributions == null) {
+            throw new IllegalArgumentException("attributions must not be null");
+        }
+        attributions = List.copyOf(attributions);
+    }
+
+    /**
+     * Creates an empty context result indicating no chunks were included.
+     */
+    public static ContextResult empty() {
+        return new ContextResult("", List.of(), true);
+    }
+}
diff --git a/spector-engine/src/main/java/com/spectrayan/spector/engine/rag/ScoredChunk.java b/spector-engine/src/main/java/com/spectrayan/spector/engine/rag/ScoredChunk.java
new file mode 100644
index 0000000..0f9728f
--- /dev/null
+++ b/spector-engine/src/main/java/com/spectrayan/spector/engine/rag/ScoredChunk.java
@@ -0,0 +1,21 @@
+package com.spectrayan.spector.engine.rag;
+
+import com.spectrayan.spector.commons.TextChunk;
+
+/**
+ * A text chunk annotated with a relevance score from search.
+ *
+ * @param chunk the text chunk
+ * @param score relevance score (higher is more relevant)
+ */
+public record ScoredChunk(TextChunk chunk, float score) {
+
+    public ScoredChunk {
+        if (chunk == null) {
+            throw new IllegalArgumentException("chunk must not be null");
+        }
+        if (Float.isNaN(score)) {
+            throw new IllegalArgumentException("score must not be NaN");
+        }
+    }
+}
diff --git a/spector-engine/src/main/java/com/spectrayan/spector/engine/rag/package-info.java b/spector-engine/src/main/java/com/spectrayan/spector/engine/rag/package-info.java
new file mode 100644
index 0000000..15dc966
--- /dev/null
+++ b/spector-engine/src/main/java/com/spectrayan/spector/engine/rag/package-info.java
@@ -0,0 +1,7 @@
+/**
+ * RAG (Retrieval-Augmented Generation) pipeline components for the Spector Engine.
+ *
+ * <p>This package provides the {@link com.spectrayan.spector.engine.rag.ContextBuilder}
+ * which assembles scored chunks into a token-limited context string suitable for LLM prompting.</p>
+ */
+package com.spectrayan.spector.engine.rag;
diff --git a/spector-index/src/test/java/com/spectrayan/spector/index/RescoreStrategyTest.java b/spector-engine/src/test/java/com/spectrayan/spector/engine/RescoreStrategyTest.java
similarity index 82%
rename from spector-index/src/test/java/com/spectrayan/spector/index/RescoreStrategyTest.java
rename to spector-engine/src/test/java/com/spectrayan/spector/engine/RescoreStrategyTest.java
index 8c9fa1e..1869a62 100644
--- a/spector-index/src/test/java/com/spectrayan/spector/index/RescoreStrategyTest.java
+++ b/spector-engine/src/test/java/com/spectrayan/spector/engine/RescoreStrategyTest.java
@@ -1,21 +1,4 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.index;
-
-import com.spectrayan.spector.commons.error.SpectorValidationException;
+package com.spectrayan.spector.engine;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -34,14 +17,14 @@ class RescoreStrategyTest {
     @Test
     void constructorRejectsZeroOversamplingFactor() {
         assertThatThrownBy(() -> new RescoreStrategy(0))
-                .isInstanceOf(SpectorValidationException.class)
+                .isInstanceOf(IllegalArgumentException.class)
                 .hasMessageContaining("oversamplingFactor");
     }
 
     @Test
     void constructorRejectsNegativeOversamplingFactor() {
         assertThatThrownBy(() -> new RescoreStrategy(-3))
-                .isInstanceOf(SpectorValidationException.class)
+                .isInstanceOf(IllegalArgumentException.class)
                 .hasMessageContaining("oversamplingFactor");
     }
 
@@ -74,7 +57,7 @@ void candidateCountWhenTotalEqualsOversampledCount() {
     void rescoreReturnsTopKByExactDistance() {
         RescoreStrategy strategy = new RescoreStrategy(3);
 
-        // Simulate 6 candidates from quantized search (k=2, factor=3 → 6 candidates)
+        // Simulate 6 candidates from quantized search (k=2, factor=3 → 6 candidates)
         List<ScoredResult> quantizedCandidates = List.of(
                 new ScoredResult("a", 0, 0.9f),
                 new ScoredResult("b", 1, 0.8f),
@@ -84,7 +67,7 @@ void rescoreReturnsTopKByExactDistance() {
                 new ScoredResult("f", 5, 0.4f)
         );
 
-        // Exact distances differ from quantized scores — "e" and "c" are actually closest
+        // Exact distances differ from quantized scores — "e" and "c" are actually closest
         float[] exactDistances = {0.50f, 0.80f, 0.10f, 0.70f, 0.05f, 0.60f};
 
         float[] query = {1.0f, 2.0f};
diff --git a/spector-engine/src/test/java/com/spectrayan/spector/engine/SpectorConfigRescoreTest.java b/spector-engine/src/test/java/com/spectrayan/spector/engine/SpectorConfigRescoreTest.java
index b298c2b..29505ba 100644
--- a/spector-engine/src/test/java/com/spectrayan/spector/engine/SpectorConfigRescoreTest.java
+++ b/spector-engine/src/test/java/com/spectrayan/spector/engine/SpectorConfigRescoreTest.java
@@ -1,28 +1,10 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.engine;
 
-
-import com.spectrayan.spector.config.SpectorConfig;
-import com.spectrayan.spector.commons.error.SpectorConfigException;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import org.junit.jupiter.api.Test;
 
-import com.spectrayan.spector.core.quantization.QuantizationType;
+import com.spectrayan.spector.core.QuantizationType;
 
 /**
  * Unit tests for SpectorConfig rescore/oversampling factor support.
@@ -46,13 +28,13 @@ void withRescore_factorOfOne_isValid() {
     @Test
     void withRescore_rejectsZero() {
         assertThatThrownBy(() -> SpectorConfig.DEFAULT.withRescore(0))
-                .isInstanceOf(SpectorConfigException.class);
+                .isInstanceOf(IllegalArgumentException.class);
     }
 
     @Test
     void withRescore_rejectsNegative() {
         assertThatThrownBy(() -> SpectorConfig.DEFAULT.withRescore(-1))
-                .isInstanceOf(SpectorConfigException.class);
+                .isInstanceOf(IllegalArgumentException.class);
     }
 
     @Test
diff --git a/spector-engine/src/test/java/com/spectrayan/spector/engine/SpectorEngineTest.java b/spector-engine/src/test/java/com/spectrayan/spector/engine/SpectorEngineTest.java
index 555f631..5f42435 100644
--- a/spector-engine/src/test/java/com/spectrayan/spector/engine/SpectorEngineTest.java
+++ b/spector-engine/src/test/java/com/spectrayan/spector/engine/SpectorEngineTest.java
@@ -1,29 +1,9 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.engine;
 
-import com.spectrayan.spector.commons.error.SpectorException;
-
-
-import com.spectrayan.spector.config.SpectorConfig;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 
-import com.spectrayan.spector.core.similarity.SimilarityFunction;
-import com.spectrayan.spector.config.IndexType;
+import com.spectrayan.spector.core.SimilarityFunction;
 import com.spectrayan.spector.query.SearchQuery;
 import com.spectrayan.spector.query.SearchResponse;
 
@@ -44,7 +24,7 @@ private SpectorConfig testConfig() {
 
     @Test
     void ingestAndKeywordSearch() {
-        try (var engine = new DefaultSpectorEngine(testConfig())) {
+        try (var engine = new SpectorEngine(testConfig())) {
             engine.ingest("d1", "java programming language", randomVector(DIM, 1));
             engine.ingest("d2", "python machine learning", randomVector(DIM, 2));
 
@@ -56,7 +36,7 @@ void ingestAndKeywordSearch() {
 
     @Test
     void ingestAndVectorSearch() {
-        try (var engine = new DefaultSpectorEngine(testConfig())) {
+        try (var engine = new SpectorEngine(testConfig())) {
             float[] v1 = randomVector(DIM, 1);
             engine.ingest("d1", "hello", v1);
             engine.ingest("d2", "world", randomVector(DIM, 2));
@@ -69,7 +49,7 @@ void ingestAndVectorSearch() {
 
     @Test
     void ingestAndHybridSearch() {
-        try (var engine = new DefaultSpectorEngine(testConfig())) {
+        try (var engine = new SpectorEngine(testConfig())) {
             float[] v1 = randomVector(DIM, 1);
             engine.ingest("d1", "java virtual machine performance", v1);
             engine.ingest("d2", "python deep learning", randomVector(DIM, 2));
@@ -82,7 +62,7 @@ void ingestAndHybridSearch() {
 
     @Test
     void documentCount() {
-        try (var engine = new DefaultSpectorEngine(testConfig())) {
+        try (var engine = new SpectorEngine(testConfig())) {
             assertThat(engine.documentCount()).isEqualTo(0);
             engine.ingest("d1", "hello", randomVector(DIM, 1));
             assertThat(engine.documentCount()).isEqualTo(1);
@@ -93,7 +73,7 @@ void documentCount() {
 
     @Test
     void batchIngest() {
-        try (var engine = new DefaultSpectorEngine(testConfig())) {
+        try (var engine = new SpectorEngine(testConfig())) {
             String[] ids = {"d1", "d2", "d3"};
             String[] contents = {"alpha", "beta", "gamma"};
             float[][] vectors = {randomVector(DIM, 1), randomVector(DIM, 2), randomVector(DIM, 3)};
@@ -105,16 +85,16 @@ void batchIngest() {
 
     @Test
     void closedEngineThrows() {
-        var engine = new DefaultSpectorEngine(testConfig());
+        var engine = new SpectorEngine(testConfig());
         engine.close();
         assertThatThrownBy(() -> engine.ingest("d1", "text", randomVector(DIM, 1)))
-                .isInstanceOf(SpectorException.class);
+                .isInstanceOf(IllegalStateException.class);
     }
 
     @Test
     void configAccessor() {
         var config = testConfig();
-        try (var engine = new DefaultSpectorEngine(config)) {
+        try (var engine = new SpectorEngine(config)) {
             assertThat(engine.config()).isEqualTo(config);
             assertThat(engine.config().dimensions()).isEqualTo(DIM);
         }
@@ -122,7 +102,7 @@ void configAccessor() {
 
     @Test
     void multipleDocumentsEndToEnd() {
-        try (var engine = new DefaultSpectorEngine(testConfig())) {
+        try (var engine = new SpectorEngine(testConfig())) {
             Random rng = new Random(42);
             for (int i = 0; i < 50; i++) {
                 engine.ingest("doc-" + i, "document number " + i + " with text", randomVector(DIM, rng));
@@ -144,7 +124,7 @@ void ivfPq_autoTrainsAndSearches() {
                 .withCapacity(2000)
                 .withIvfPq(8, 4, 4); // nlist=8, nprobe=4, M=4
 
-        try (var engine = new DefaultSpectorEngine(config)) {
+        try (var engine = new SpectorEngine(config)) {
             Random rng = new Random(42);
 
             // Ingest enough vectors for auto-training (nlist*40 = 320)
@@ -165,7 +145,7 @@ void ivfPq_keywordSearchWorksBeforeTraining() {
                 .withCapacity(2000)
                 .withIvfPq(8, 4, 4);
 
-        try (var engine = new DefaultSpectorEngine(config)) {
+        try (var engine = new SpectorEngine(config)) {
             engine.ingest("d1", "java programming language", randomVector(DIM, 1));
             engine.ingest("d2", "python machine learning", randomVector(DIM, 2));
 
@@ -194,165 +174,6 @@ void ivfPq_autoDefaults() {
         assertThat(config.effectivePqSubspaces()).isGreaterThanOrEqualTo(4);
     }
 
-    // ─────────────── SVASQ Engine Integration ───────────────
-
-    @Test
-    void svasq_configBuilder_setsCorrectQuantization() {
-        var config = SpectorConfig.DEFAULT
-                .withDimensions(128)
-                .withCapacity(1000)
-                .withSvasq();
-
-        assertThat(config.quantization())
-                .isEqualTo(com.spectrayan.spector.core.quantization.QuantizationType.SVASQ);
-        // Default oversampling for SVASQ is 3
-        assertThat(config.effectiveOversamplingFactor()).isEqualTo(3);
-    }
-
-    @Test
-    void svasq_engineBuilder_fluentApi() {
-        var config = SpectorEngine.builder()
-                .dimensions(64)
-                .capacity(500)
-                .similarity(SimilarityFunction.COSINE)
-                .svasq(3)
-                .config();  // inspect the config without building the engine
-
-        assertThat(config.quantization())
-                .isEqualTo(com.spectrayan.spector.core.quantization.QuantizationType.SVASQ);
-        assertThat(config.effectiveOversamplingFactor()).isEqualTo(3);
-    }
-
-    @Test
-    void svasq_ingestAndVectorSearch_returnsResults() {
-        // Use capacity = numDocs to trigger SVASQ auto-calibration immediately
-        int numDocs = 150;
-        var config = SpectorConfig.DEFAULT
-                .withDimensions(DIM)
-                .withCapacity(numDocs)
-                .withSvasq();
-
-        try (var engine = new DefaultSpectorEngine(config)) {
-            Random rng = new Random(42);
-            for (int i = 0; i < numDocs; i++) {
-                engine.ingest("doc-" + i, "document number " + i, randomVector(DIM, rng));
-            }
-            assertThat(engine.documentCount()).isEqualTo(numDocs);
-
-            SearchResponse response = engine.vectorSearch(randomVector(DIM, 999L), 5);
-            assertThat(response.results()).isNotEmpty();
-            assertThat(response.results().length).isLessThanOrEqualTo(5);
-        }
-    }
-
-    @Test
-    void svasq_hybridSearch_returnsBothKeywordAndVector() {
-        int numDocs = 150;
-        var config = SpectorConfig.DEFAULT
-                .withDimensions(DIM)
-                .withCapacity(numDocs)
-                .withSvasq();
-
-        try (var engine = new DefaultSpectorEngine(config)) {
-            Random rng = new Random(10);
-            float[] specialVec = randomVector(DIM, rng);
-            engine.ingest("special", "java programming language runtime", specialVec);
-
-            for (int i = 1; i < numDocs; i++) {
-                engine.ingest("doc-" + i, "unrelated document content " + i, randomVector(DIM, rng));
-            }
-
-            // Keyword search should find "special" by text
-            SearchResponse kwResp = engine.keywordSearch("java programming", 5);
-            assertThat(kwResp.results()).isNotEmpty();
-            assertThat(kwResp.results()[0].id()).isEqualTo("special");
-
-            // Vector search should find "special" by nearest vector
-            SearchResponse vecResp = engine.vectorSearch(specialVec, 5);
-            assertThat(vecResp.results()).isNotEmpty();
-        }
-    }
-
-    @Test
-    void svasq_withExplicitOversampling_configuredCorrectly() {
-        var config = SpectorConfig.DEFAULT
-                .withDimensions(64)
-                .withCapacity(500)
-                .withSvasq(5);
-
-        assertThat(config.effectiveOversamplingFactor()).isEqualTo(5);
-    }
-
-    @Test
-    void svasq_diskPersistence_savesAndLoads(@org.junit.jupiter.api.io.TempDir java.nio.file.Path tempDir) throws java.io.IOException {
-        int numDocs = 50;
-        var config = SpectorConfig.DEFAULT
-                .withDimensions(DIM)
-                .withCapacity(numDocs)
-                .withQuantization(com.spectrayan.spector.core.quantization.QuantizationType.SCALAR_INT8)
-                .withPersistence(com.spectrayan.spector.config.PersistenceMode.DISK, tempDir);
-
-        // 1. Ingest and save
-        try (var engine = new DefaultSpectorEngine(config)) {
-            Random rng = new Random(42);
-            for (int i = 0; i < numDocs; i++) {
-                engine.ingest("doc-" + i, "document content " + i, randomVector(DIM, rng));
-            }
-            assertThat(engine.documentCount()).isEqualTo(numDocs);
-            // Engine close() is triggered via try-with-resources, saving the index.bin and documents.bin
-        }
-
-        // Verify sharded index directory exists (engine now uses ShardedDiskHnswWriter)
-        java.nio.file.Path shardDir = tempDir.resolve("index_shards");
-        assertThat(java.nio.file.Files.exists(shardDir)).isTrue();
-
-        // 2. Load and verify search
-        try (var engine = new DefaultSpectorEngine(config)) {
-            assertThat(engine.documentCount()).isEqualTo(numDocs);
-            
-            Random rng = new Random(42);
-            SearchResponse response = engine.vectorSearch(randomVector(DIM, rng), 5);
-            assertThat(response.results()).isNotEmpty();
-            assertThat(response.results().length).isLessThanOrEqualTo(5);
-        }
-    }
-
-    @Test
-    void spectrum_diskPersistence_savesAndLoads(@org.junit.jupiter.api.io.TempDir java.nio.file.Path tempDir) throws java.io.IOException {
-        int numDocs = 300;
-        var config = SpectorConfig.DEFAULT
-                .withDimensions(DIM)
-                .withCapacity(500)
-                .withSpectrum(4, 2, 10) // 4 centroids, probe 2, promote HNSW at 10 residuals
-                .withPersistence(com.spectrayan.spector.config.PersistenceMode.DISK, tempDir);
-
-        // 1. Ingest and save
-        try (var engine = new DefaultSpectorEngine(config)) {
-            Random rng = new Random(42);
-            for (int i = 0; i < numDocs; i++) {
-                engine.ingest("doc-" + i, "document content " + i, randomVector(DIM, rng));
-            }
-            assertThat(engine.documentCount()).isEqualTo(numDocs);
-            // Engine close() saves the index
-        }
-
-        // Verify index files exist
-        java.nio.file.Path indexDir = tempDir.resolve("index_spectrum");
-        assertThat(java.nio.file.Files.exists(indexDir)).isTrue();
-        assertThat(java.nio.file.Files.exists(indexDir.resolve("meta.properties"))).isTrue();
-        assertThat(java.nio.file.Files.exists(indexDir.resolve("centroids.bin"))).isTrue();
-
-        // 2. Load and verify search
-        try (var engine = new DefaultSpectorEngine(config)) {
-            assertThat(engine.documentCount()).isEqualTo(numDocs);
-            
-            Random rng = new Random(42);
-            SearchResponse response = engine.vectorSearch(randomVector(DIM, rng), 5);
-            assertThat(response.results()).isNotEmpty();
-            assertThat(response.results().length).isLessThanOrEqualTo(5);
-        }
-    }
-
     // ─────────────── Helpers ───────────────
 
     private static float[] randomVector(int dim, long seed) {
diff --git a/spector-index/src/test/java/com/spectrayan/spector/index/VectorIndexFactoryGpuFallbackTest.java b/spector-engine/src/test/java/com/spectrayan/spector/engine/VectorIndexFactoryGpuFallbackTest.java
similarity index 85%
rename from spector-index/src/test/java/com/spectrayan/spector/index/VectorIndexFactoryGpuFallbackTest.java
rename to spector-engine/src/test/java/com/spectrayan/spector/engine/VectorIndexFactoryGpuFallbackTest.java
index b97f1b2..6ca7d54 100644
--- a/spector-index/src/test/java/com/spectrayan/spector/index/VectorIndexFactoryGpuFallbackTest.java
+++ b/spector-engine/src/test/java/com/spectrayan/spector/engine/VectorIndexFactoryGpuFallbackTest.java
@@ -1,28 +1,11 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.index;
-
+package com.spectrayan.spector.engine;
 
-import com.spectrayan.spector.config.SpectorConfig;
 import static org.assertj.core.api.Assertions.assertThat;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.ValueSource;
 
-import com.spectrayan.spector.core.quantization.QuantizationType;
+import com.spectrayan.spector.core.QuantizationType;
 
 /**
  * Unit tests for GPU fallback logic in {@link VectorIndexFactory}.
diff --git a/spector-rag/src/test/java/com/spectrayan/spector/rag/ContextBuilderTest.java b/spector-engine/src/test/java/com/spectrayan/spector/engine/rag/ContextBuilderTest.java
similarity index 86%
rename from spector-rag/src/test/java/com/spectrayan/spector/rag/ContextBuilderTest.java
rename to spector-engine/src/test/java/com/spectrayan/spector/engine/rag/ContextBuilderTest.java
index db9ffb5..dcbd0b9 100644
--- a/spector-rag/src/test/java/com/spectrayan/spector/rag/ContextBuilderTest.java
+++ b/spector-engine/src/test/java/com/spectrayan/spector/engine/rag/ContextBuilderTest.java
@@ -1,21 +1,4 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.rag;
-
-import com.spectrayan.spector.commons.error.SpectorValidationException;
+package com.spectrayan.spector.engine.rag;
 
 import java.util.List;
 
@@ -150,14 +133,14 @@ void noChunksFitReturnsEmptyResult() {
     @Test
     void tokenLimitBelowMinimumThrowsException() {
         assertThatThrownBy(() -> builder.build(List.of(), 100))
-                .isInstanceOf(SpectorValidationException.class)
+                .isInstanceOf(IllegalArgumentException.class)
                 .hasMessageContaining("256");
     }
 
     @Test
     void tokenLimitAboveMaximumThrowsException() {
         assertThatThrownBy(() -> builder.build(List.of(), 200_000))
-                .isInstanceOf(SpectorValidationException.class)
+                .isInstanceOf(IllegalArgumentException.class)
                 .hasMessageContaining("131072");
     }
 
@@ -201,23 +184,23 @@ void contextResultEmptyFactoryMethod() {
     @Test
     void chunkAttributionRejectsInvalidInput() {
         assertThatThrownBy(() -> new ChunkAttribution(null, 0))
-                .isInstanceOf(SpectorValidationException.class);
+                .isInstanceOf(IllegalArgumentException.class);
         assertThatThrownBy(() -> new ChunkAttribution("", 0))
-                .isInstanceOf(SpectorValidationException.class);
+                .isInstanceOf(IllegalArgumentException.class);
         assertThatThrownBy(() -> new ChunkAttribution("doc", -1))
-                .isInstanceOf(SpectorValidationException.class);
+                .isInstanceOf(IllegalArgumentException.class);
     }
 
     @Test
     void scoredChunkRejectsNullChunk() {
         assertThatThrownBy(() -> new ScoredChunk(null, 0.5f))
-                .isInstanceOf(SpectorValidationException.class);
+                .isInstanceOf(IllegalArgumentException.class);
     }
 
     @Test
     void scoredChunkRejectsNanScore() {
         TextChunk chunk = new TextChunk("hello", 1, 0, 5, "doc");
         assertThatThrownBy(() -> new ScoredChunk(chunk, Float.NaN))
-                .isInstanceOf(SpectorValidationException.class);
+                .isInstanceOf(IllegalArgumentException.class);
     }
 }
diff --git a/spector-gpu/README.md b/spector-gpu/README.md
deleted file mode 100644
index cbc76a9..0000000
--- a/spector-gpu/README.md
+++ /dev/null
@@ -1,30 +0,0 @@
-# spector-gpu 🖥️
-
-> **GPU acceleration for Spector using JNI-free Panama FFM interop with CUDA.**
-
-`spector-gpu` accelerates batch vector similarity calculations by offloading distance calculations to NVIDIA GPUs. Using Project Panama's Foreign Function & Memory (FFM) API, it loads CUDA dynamic libraries (`nvcuda.dll` or `libcuda.so`) and binds memory buffers directly to GPU contexts without writing any JNI C++ code.
-
----
-
-## 🏗️ Core Architecture & Roles
-
-1. **CUDA Kernel Loader (`CudaKernelLoader`):** Loads compiled CUDA PTX/SASS kernels and runs JNI-free host/device FFM commands.
-2. **GPU Vector Store (`GpuVectorStore`):** Allocates page-locked host memory (pinned RAM) and copies vector blocks directly to device memory (VRAM).
-3. **Batch Similarity (`GpuSimilarityKernel`):** Executes parallel matrix-multiplication kernels on GPU cores, achieving up to 4× speedups over AVX-512 for batch queries of size $N \geq 100{,}000$.
-
----
-
-## 🚀 Key APIs
-
-### GPU Initialization & Context Allocation
-```java
-if (GpuContext.isAvailable()) {
-    System.out.println("CUDA Toolkit detected! Allocating GPU resources...");
-    
-    try (GpuContext ctx = GpuContext.create()) {
-        // Allocate pinned host/device buffers
-        GpuVectorStore store = new GpuVectorStore(ctx, dimensions, capacity);
-        store.put(0, vector);
-    }
-}
-```
diff --git a/spector-gpu/pom.xml b/spector-gpu/pom.xml
index 7c53baa..2456e21 100644
--- a/spector-gpu/pom.xml
+++ b/spector-gpu/pom.xml
@@ -6,7 +6,7 @@
 
     <parent>
         <groupId>com.spectrayan</groupId>
-        <artifactId>spector</artifactId>
+        <artifactId>spector-search</artifactId>
         <version>0.1.0-SNAPSHOT</version>
     </parent>
 
@@ -23,10 +23,6 @@
             <groupId>com.spectrayan</groupId>
             <artifactId>spector-storage</artifactId>
         </dependency>
-        <dependency>
-            <groupId>com.spectrayan</groupId>
-            <artifactId>spector-commons</artifactId>
-        </dependency>
     </dependencies>
 
 </project>
diff --git a/spector-gpu/src/main/java/com/spectrayan/spector/gpu/AllocationMetrics.java b/spector-gpu/src/main/java/com/spectrayan/spector/gpu/AllocationMetrics.java
index 9cb7ad7..36a0898 100644
--- a/spector-gpu/src/main/java/com/spectrayan/spector/gpu/AllocationMetrics.java
+++ b/spector-gpu/src/main/java/com/spectrayan/spector/gpu/AllocationMetrics.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.gpu;
 
 /**
diff --git a/spector-gpu/src/main/java/com/spectrayan/spector/gpu/BatchGpuSearcher.java b/spector-gpu/src/main/java/com/spectrayan/spector/gpu/BatchGpuSearcher.java
index 6667dc7..836638a 100644
--- a/spector-gpu/src/main/java/com/spectrayan/spector/gpu/BatchGpuSearcher.java
+++ b/spector-gpu/src/main/java/com/spectrayan/spector/gpu/BatchGpuSearcher.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.gpu;
 
 import java.time.Duration;
@@ -24,10 +9,6 @@
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-import com.spectrayan.spector.commons.error.SpectorServerException;
-import com.spectrayan.spector.storage.error.SpectorSegmentClosedException;
-import com.spectrayan.spector.commons.error.ErrorCode;
 
 /**
  * Batches multiple similarity queries into single GPU kernel launches for maximum throughput.
@@ -99,15 +80,15 @@ public BatchGpuSearcher(SimilarityKernel kernel, GpuMemoryManager memoryManager)
      * @param memoryManager  the GPU memory manager for memory tracking
      * @param batchingWindow the time window to collect queries before launching (1–100ms)
      * @param maxBatchSize   the maximum number of queries per batch (1–1024)
-     * @throws SpectorValidationException if parameters are out of valid range
+     * @throws IllegalArgumentException if parameters are out of valid range
      */
     public BatchGpuSearcher(SimilarityKernel kernel, GpuMemoryManager memoryManager,
                             Duration batchingWindow, int maxBatchSize) {
         if (kernel == null) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_NULL, "Kernel");
+            throw new IllegalArgumentException("Kernel must not be null");
         }
         if (memoryManager == null) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_NULL, "Memory manager");
+            throw new IllegalArgumentException("Memory manager must not be null");
         }
         validateBatchingWindow(batchingWindow);
         validateMaxBatchSize(maxBatchSize);
@@ -136,8 +117,8 @@ public BatchGpuSearcher(SimilarityKernel kernel, GpuMemoryManager memoryManager,
      * @param dimensions vector dimensionality
      * @param topK       number of top results per query (1–1000)
      * @return map of query index to its individual result (top-K or error)
-     * @throws SpectorGpuException    if the searcher is closed
-     * @throws SpectorValidationException if parameters are invalid
+     * @throws IllegalStateException    if the searcher is closed
+     * @throws IllegalArgumentException if parameters are invalid
      */
     public Map<Integer, BatchQueryResult> batchSearch(
             List<float[]> queries, float[] database, int numVectors, int dimensions, int topK) {
@@ -154,8 +135,8 @@ public Map<Integer, BatchQueryResult> batchSearch(
      * @param topK           number of top results per query (1–1000)
      * @param batchingWindow the batching window for this invocation
      * @return map of query index to its individual result (top-K or error)
-     * @throws SpectorGpuException    if the searcher is closed
-     * @throws SpectorValidationException if parameters are invalid
+     * @throws IllegalStateException    if the searcher is closed
+     * @throws IllegalArgumentException if parameters are invalid
      */
     public Map<Integer, BatchQueryResult> batchSearch(
             List<float[]> queries, float[] database, int numVectors, int dimensions,
@@ -427,45 +408,51 @@ private void siftDown(float[] scores, int[] indices, int i, int size) {
 
     private void validateBatchingWindow(Duration window) {
         if (window == null) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_NULL, "Batching window");
+            throw new IllegalArgumentException("Batching window must not be null");
         }
         long ms = window.toMillis();
         if (ms < MIN_WINDOW_MS || ms > MAX_WINDOW_MS) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_OUT_OF_RANGE, "Batching window must be between %d and %dms, got: %dms" .formatted(MIN_WINDOW_MS, MAX_WINDOW_MS, ms));
+            throw new IllegalArgumentException(
+                    "Batching window must be between %d and %dms, got: %dms"
+                            .formatted(MIN_WINDOW_MS, MAX_WINDOW_MS, ms));
         }
     }
 
     private void validateMaxBatchSize(int batchSize) {
         if (batchSize < 1 || batchSize > MAX_BATCH_SIZE) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_OUT_OF_RANGE, "Max batch size must be between 1 and %d, got: %d" .formatted(MAX_BATCH_SIZE, batchSize));
+            throw new IllegalArgumentException(
+                    "Max batch size must be between 1 and %d, got: %d"
+                            .formatted(MAX_BATCH_SIZE, batchSize));
         }
     }
 
     private void validateSearchInputs(List<float[]> queries, float[] database,
                                        int numVectors, int dimensions, int topK) {
         if (queries == null) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_NULL, "Queries list");
+            throw new IllegalArgumentException("Queries list must not be null");
         }
         if (database == null) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_NULL, "Database array");
+            throw new IllegalArgumentException("Database array must not be null");
         }
         if (numVectors < 0) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_NEGATIVE, "numVectors", numVectors);
+            throw new IllegalArgumentException("Number of vectors must be non-negative, got: " + numVectors);
         }
         if (dimensions <= 0) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_OUT_OF_RANGE, "Dimensions", 1, Integer.MAX_VALUE, dimensions);
+            throw new IllegalArgumentException("Dimensions must be positive, got: " + dimensions);
         }
         if (topK < 1 || topK > 1000) {
-            throw new SpectorValidationException(ErrorCode.TOP_K_INVALID, 1, topK);
+            throw new IllegalArgumentException("topK must be between 1 and 1000, got: " + topK);
         }
         if (numVectors > 0 && database.length < (long) numVectors * dimensions) {
-            throw new SpectorValidationException(ErrorCode.DIMENSIONS_MISMATCH, "Database array length (%d) is less than required (%d)" .formatted(database.length, (long) numVectors * dimensions));
+            throw new IllegalArgumentException(
+                    "Database array length (%d) is less than required (%d)"
+                            .formatted(database.length, (long) numVectors * dimensions));
         }
     }
 
     private void ensureOpen() {
         if (closed) {
-            throw new SpectorSegmentClosedException();
+            throw new IllegalStateException("BatchGpuSearcher is closed");
         }
     }
-}
\ No newline at end of file
+}
diff --git a/spector-gpu/src/main/java/com/spectrayan/spector/gpu/BatchQueryResult.java b/spector-gpu/src/main/java/com/spectrayan/spector/gpu/BatchQueryResult.java
index 1b20099..34af0fd 100644
--- a/spector-gpu/src/main/java/com/spectrayan/spector/gpu/BatchQueryResult.java
+++ b/spector-gpu/src/main/java/com/spectrayan/spector/gpu/BatchQueryResult.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.gpu;
 
 import java.util.List;
diff --git a/spector-gpu/src/main/java/com/spectrayan/spector/gpu/BatchSearchResult.java b/spector-gpu/src/main/java/com/spectrayan/spector/gpu/BatchSearchResult.java
index dd621d1..c1a300b 100644
--- a/spector-gpu/src/main/java/com/spectrayan/spector/gpu/BatchSearchResult.java
+++ b/spector-gpu/src/main/java/com/spectrayan/spector/gpu/BatchSearchResult.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.gpu;
 
 /**
diff --git a/spector-gpu/src/main/java/com/spectrayan/spector/gpu/CudaCosineKernel.java b/spector-gpu/src/main/java/com/spectrayan/spector/gpu/CudaCosineKernel.java
index 7d8c0fc..3f67a48 100644
--- a/spector-gpu/src/main/java/com/spectrayan/spector/gpu/CudaCosineKernel.java
+++ b/spector-gpu/src/main/java/com/spectrayan/spector/gpu/CudaCosineKernel.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.gpu;
 
 import java.util.Arrays;
@@ -24,8 +9,6 @@
 import jdk.incubator.vector.FloatVector;
 import jdk.incubator.vector.VectorOperators;
 import jdk.incubator.vector.VectorSpecies;
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-import com.spectrayan.spector.commons.error.ErrorCode;
 
 /**
  * CUDA-accelerated cosine similarity kernel with CPU SIMD fallback.
@@ -161,18 +144,11 @@ public void clearNormCache() {
     // ─────────────────────────────────────────────────────────────────────────────
 
     private float[] computeGpu(float[] query, float[] database, int numVectors, int dimensions) {
-        // Use the kernel launcher for actual GPU dispatch
-        try {
-            CudaKernelLauncher launcher = new CudaKernelLauncher();
-            try {
-                return launcher.batchCosine(query, database, numVectors, dimensions);
-            } finally {
-                launcher.close();
-            }
-        } catch (Exception e) {
-            log.debug("GPU kernel launch failed, using CPU SIMD: {}", e.getMessage());
-            return computeCpuSimd(query, database, numVectors, dimensions);
-        }
+        // In a full implementation, this would load CUDA PTX and execute on GPU.
+        // For now, we use the CPU SIMD path as the GPU kernel launcher handles
+        // actual CUDA operations. The architecture supports swapping in real GPU
+        // execution when the PTX kernels are compiled and loaded.
+        return computeCpuSimd(query, database, numVectors, dimensions);
     }
 
     // ─────────────────────────────────────────────────────────────────────────────
@@ -321,19 +297,24 @@ private boolean arePreNormalized(float[] norms) {
 
     private void validateInputs(float[] query, float[] database, int numVectors, int dimensions) {
         if (dimensions < MIN_DIMENSIONS || dimensions > MAX_DIMENSIONS) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_OUT_OF_RANGE, "dimensions", MIN_DIMENSIONS, MAX_DIMENSIONS, dimensions);
+            throw new IllegalArgumentException(
+                    "Dimensions must be between " + MIN_DIMENSIONS + " and " + MAX_DIMENSIONS +
+                    ", got: " + dimensions);
         }
         if (dimensions % 32 != 0) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_INVALID, "dimensions (must be multiple of 32)", dimensions);
+            throw new IllegalArgumentException(
+                    "Dimensions must be a multiple of 32, got: " + dimensions);
         }
         if (numVectors < 0) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_NEGATIVE, "numVectors", numVectors);
+            throw new IllegalArgumentException("numVectors must be non-negative, got: " + numVectors);
         }
         if (query == null || query.length < dimensions) {
-            throw new SpectorValidationException(ErrorCode.VECTOR_LENGTH_MISMATCH, 0, dimensions);
+            throw new IllegalArgumentException(
+                    "Query vector must have at least " + dimensions + " elements");
         }
         if (numVectors > 0 && (database == null || database.length < (long) numVectors * dimensions)) {
-            throw new SpectorValidationException(ErrorCode.DIMENSIONS_MISMATCH, "Database must have at least " + ((long) numVectors * dimensions) + " elements");
+            throw new IllegalArgumentException(
+                    "Database must have at least " + ((long) numVectors * dimensions) + " elements");
         }
     }
 
@@ -354,4 +335,4 @@ private static boolean containsNanOrInfinity(float[] vector, int offset, int len
     // ─────────────────────────────────────────────────────────────────────────────
 
     private record NormCacheKey(int arrayIdentityHash, int numVectors, int dimensions) {}
-}
\ No newline at end of file
+}
diff --git a/spector-gpu/src/main/java/com/spectrayan/spector/gpu/CudaDotProductKernel.java b/spector-gpu/src/main/java/com/spectrayan/spector/gpu/CudaDotProductKernel.java
index ba0ac98..56ec470 100644
--- a/spector-gpu/src/main/java/com/spectrayan/spector/gpu/CudaDotProductKernel.java
+++ b/spector-gpu/src/main/java/com/spectrayan/spector/gpu/CudaDotProductKernel.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.gpu;
 
 import java.lang.foreign.Arena;
@@ -28,13 +13,7 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import com.spectrayan.spector.core.similarity.DotProduct;
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-import com.spectrayan.spector.commons.error.SpectorServerException;
-import com.spectrayan.spector.commons.error.SpectorGpuException;
-import com.spectrayan.spector.storage.error.SpectorSegmentClosedException;
-import com.spectrayan.spector.commons.error.ErrorCode;
-import com.spectrayan.spector.commons.error.SpectorInternalException;
+import com.spectrayan.spector.core.DotProduct;
 
 /**
  * CUDA-accelerated dot-product similarity kernel via Panama FFM.
@@ -314,13 +293,13 @@ private float[] computeGpu(float[] query, float[] database, int numVectors, int
             MemorySegment querySegment = localArena.allocateFrom(ValueLayout.JAVA_FLOAT, query);
             int htodResult = (int) cuMemcpyHtoD.invoke(dQuery, querySegment, queryBytes);
             if (htodResult != 0) {
-                throw new SpectorGpuException(ErrorCode.GPU_DEVICE_ERROR, "cuMemcpyHtoD (query) failed", htodResult);
+                throw new RuntimeException("cuMemcpyHtoD (query) failed: " + htodResult);
             }
 
             MemorySegment dbSegment = localArena.allocateFrom(ValueLayout.JAVA_FLOAT, database);
             htodResult = (int) cuMemcpyHtoD.invoke(dDatabase, dbSegment, dbBytes);
             if (htodResult != 0) {
-                throw new SpectorGpuException(ErrorCode.GPU_DEVICE_ERROR, "cuMemcpyHtoD (database) failed", htodResult);
+                throw new RuntimeException("cuMemcpyHtoD (database) failed: " + htodResult);
             }
 
             // Set up kernel parameters:
@@ -360,20 +339,20 @@ private float[] computeGpu(float[] query, float[] database, int numVectors, int
                     MemorySegment.NULL  // extra (null)
             );
             if (launchResult != 0) {
-                throw new SpectorGpuException(ErrorCode.GPU_DEVICE_ERROR, "cuLaunchKernel failed", launchResult);
+                throw new RuntimeException("cuLaunchKernel failed: " + launchResult);
             }
 
             // Synchronize
             int syncResult = (int) cuCtxSynchronize.invoke();
             if (syncResult != 0) {
-                throw new SpectorGpuException(ErrorCode.GPU_DEVICE_ERROR, "cuCtxSynchronize failed", syncResult);
+                throw new RuntimeException("cuCtxSynchronize failed: " + syncResult);
             }
 
             // Copy results back
             MemorySegment resultSegment = localArena.allocate(ValueLayout.JAVA_FLOAT, numVectors);
             int dtohResult = (int) cuMemcpyDtoH.invoke(resultSegment, dResults, resultBytes);
             if (dtohResult != 0) {
-                throw new SpectorGpuException(ErrorCode.GPU_DEVICE_ERROR, "cuMemcpyDtoH failed", dtohResult);
+                throw new RuntimeException("cuMemcpyDtoH failed: " + dtohResult);
             }
 
             // Extract results
@@ -390,7 +369,7 @@ private float[] computeGpu(float[] query, float[] database, int numVectors, int
         } catch (Throwable e) {
             // Release device memory on failure
             freeDeviceMemory(devicePtrs);
-            throw new SpectorGpuException(ErrorCode.GPU_DEVICE_ERROR, e, "dot-product failed", 0);
+            throw new RuntimeException("GPU dot-product computation failed", e);
         }
     }
 
@@ -398,7 +377,7 @@ private long deviceAlloc(long bytes, Arena localArena) throws Throwable {
         MemorySegment ptrHolder = localArena.allocate(ValueLayout.JAVA_LONG);
         int result = (int) cuMemAlloc.invoke(ptrHolder, bytes);
         if (result != 0) {
-            throw new SpectorGpuException(ErrorCode.GPU_DEVICE_ERROR, "cuMemAlloc failed", result);
+            throw new RuntimeException("cuMemAlloc failed: " + result + " (requested " + bytes + " bytes)");
         }
         return ptrHolder.get(ValueLayout.JAVA_LONG, 0);
     }
@@ -435,31 +414,38 @@ private float[] computeCpuSimd(float[] query, float[] database, int numVectors,
 
     private void validateInputs(float[] query, float[] database, int numVectors, int dimensions) {
         if (dimensions < MIN_DIMENSIONS || dimensions > MAX_DIMENSIONS) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_OUT_OF_RANGE, "dimensions", MIN_DIMENSIONS, MAX_DIMENSIONS, dimensions);
+            throw new IllegalArgumentException(
+                    "Dimensions must be between " + MIN_DIMENSIONS + " and " + MAX_DIMENSIONS
+                            + ", got: " + dimensions);
         }
         if (dimensions % 32 != 0) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_INVALID, "dimensions (must be multiple of 32)", dimensions);
+            throw new IllegalArgumentException(
+                    "Dimensions must be a multiple of 32, got: " + dimensions);
         }
         if (numVectors < 0 || numVectors > MAX_BATCH_SIZE) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_OUT_OF_RANGE, "batchSize", 0, MAX_BATCH_SIZE, numVectors);
+            throw new IllegalArgumentException(
+                    "Batch size must be between 0 and " + MAX_BATCH_SIZE + ", got: " + numVectors);
         }
         if (query == null) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_NULL, "Query vector");
+            throw new IllegalArgumentException("Query vector must not be null");
         }
         if (database == null) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_NULL, "Database array");
+            throw new IllegalArgumentException("Database array must not be null");
         }
         if (query.length < dimensions) {
-            throw new SpectorValidationException(ErrorCode.DIMENSIONS_MISMATCH, "Query vector length (" + query.length + ") is less than dimensions (" + dimensions + ")");
+            throw new IllegalArgumentException(
+                    "Query vector length (" + query.length + ") is less than dimensions (" + dimensions + ")");
         }
         if (numVectors > 0 && database.length < (long) numVectors * dimensions) {
-            throw new SpectorValidationException(ErrorCode.DIMENSIONS_MISMATCH, "Database array length (" + database.length + ") is less than required (" + ((long) numVectors * dimensions) + ")");
+            throw new IllegalArgumentException(
+                    "Database array length (" + database.length + ") is less than required ("
+                            + ((long) numVectors * dimensions) + ")");
         }
     }
 
     private void ensureOpen() {
         if (closed) {
-            throw new SpectorSegmentClosedException();
+            throw new IllegalStateException("CudaDotProductKernel is closed");
         }
     }
-}
\ No newline at end of file
+}
diff --git a/spector-gpu/src/main/java/com/spectrayan/spector/gpu/CudaKernelLauncher.java b/spector-gpu/src/main/java/com/spectrayan/spector/gpu/CudaKernelLauncher.java
index 055617e..f9d334b 100644
--- a/spector-gpu/src/main/java/com/spectrayan/spector/gpu/CudaKernelLauncher.java
+++ b/spector-gpu/src/main/java/com/spectrayan/spector/gpu/CudaKernelLauncher.java
@@ -1,304 +1,228 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.gpu;
 
-import java.lang.foreign.Arena;
-import java.lang.foreign.FunctionDescriptor;
-import java.lang.foreign.Linker;
-import java.lang.foreign.MemorySegment;
-import java.lang.foreign.SymbolLookup;
-import java.lang.foreign.ValueLayout;
-import java.lang.invoke.MethodHandle;
-
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
-import com.spectrayan.spector.commons.error.SpectorServerException;
-import com.spectrayan.spector.commons.error.SpectorGpuException;
-import com.spectrayan.spector.storage.error.SpectorSegmentClosedException;
-import com.spectrayan.spector.commons.error.ErrorCode;
+
+import java.lang.foreign.*;
+import java.lang.invoke.MethodHandle;
+import java.nio.file.Files;
+import java.nio.file.Path;
 
 /**
- * CUDA kernel launcher via Panama FFM.
+ * CUDA kernel loader and executor via Panama FFM.
  *
- * <p>Loads a PTX kernel string into a CUDA module and provides methods to
- * launch batch similarity computations on the GPU. Handles device memory
- * allocation, host↔device transfers, and kernel dispatch.</p>
+ * <p>Loads PTX (CUDA compiled) kernels at runtime and provides methods to
+ * launch them with typed arguments. This is the low-level bridge between
+ * Java and custom GPU code.</p>
  *
- * <h3>Architecture</h3>
- * <pre>
- *   Host (Java)              Device (GPU)
- *   ─────────────            ────────────────
- *   float[] query    ──HtoD──▶  d_query
- *   float[] database ──HtoD──▶  d_database
- *                               │
- *                         cuLaunchKernel
- *                               │
- *   float[] results  ◀──DtoH──  d_results
- * </pre>
+ * <h3>Kernel Lifecycle</h3>
+ * <ol>
+ *   <li>Load PTX from file or resource</li>
+ *   <li>Create a CUDA module from the PTX</li>
+ *   <li>Get function handles from the module</li>
+ *   <li>Launch kernels with grid/block dimensions</li>
+ *   <li>Close to free GPU resources</li>
+ * </ol>
  *
- * <h3>Thread Safety</h3>
- * <p>Each launcher instance owns its CUDA module and is NOT thread-safe.
- * For concurrent use, create one launcher per thread or synchronize externally.</p>
+ * <h3>Bundled Kernels</h3>
+ * <ul>
+ *   <li><b>batch_cosine</b>: Computes N cosine similarities in parallel</li>
+ *   <li><b>batch_dot</b>: Computes N dot products in parallel</li>
+ *   <li><b>batch_l2</b>: Computes N L2 distances in parallel</li>
+ * </ul>
+ *
+ * @see GpuBatchSimilarity
+ * @see GpuCapability
  */
-public final class CudaKernelLauncher implements AutoCloseable {
+public class CudaKernelLauncher implements AutoCloseable {
 
     private static final Logger log = LoggerFactory.getLogger(CudaKernelLauncher.class);
 
-    /**
-     * PTX kernel for batch cosine similarity, loaded from validated resource file.
-     * Compiled with ptxas for sm_89 (Ada Lovelace, RTX 40 series).
-     */
-    private static final String BATCH_COSINE_PTX;
-
-    static {
-        try (var is = CudaKernelLauncher.class.getResourceAsStream("/kernels/batch_cosine.ptx")) {
-            if (is == null) throw new SpectorServerException(ErrorCode.INTERNAL_ERROR, "batch_cosine.ptx not found in resources");
-            BATCH_COSINE_PTX = new String(is.readAllBytes(), java.nio.charset.StandardCharsets.UTF_8);
-        } catch (java.io.IOException e) {
-            throw new SpectorServerException(ErrorCode.INTERNAL_ERROR, e, "Failed to load PTX kernel");
-        }
-    }
-
     private final Arena arena;
     private final SymbolLookup cudaLib;
     private final Linker linker;
-    private final long cuModule;
-    private final long cuFunction;
-
-    // Cached method handles
-    private final MethodHandle cuMemAlloc;
-    private final MethodHandle cuMemcpyHtoD;
-    private final MethodHandle cuMemcpyDtoH;
-    private final MethodHandle cuMemFree;
-    private final MethodHandle cuLaunchKernel;
-    private final MethodHandle cuCtxSynchronize;
 
+    private MemorySegment cuModule;
     private volatile boolean closed;
 
     /**
-     * Creates and initializes the CUDA kernel launcher.
-     * Loads the PTX kernel and extracts the function handle.
-     *
-     * <p>Requires the CUDA Toolkit to be installed (provides the PTX JIT compiler
-     * in the driver). Without it, cuModuleLoadData will fail with error 218.</p>
+     * Creates a CUDA kernel launcher.
      *
-     * @throws SpectorValidationException if CUDA initialization or PTX loading fails
+     * @throws IllegalStateException if CUDA is not available
      */
     public CudaKernelLauncher() {
         if (!GpuCapability.isAvailable()) {
-            throw new SpectorServerException(ErrorCode.GPU_NOT_AVAILABLE);
+            throw new IllegalStateException("CUDA GPU not available");
         }
 
         this.arena = Arena.ofShared();
         this.linker = Linker.nativeLinker();
         this.closed = false;
 
+        String libName = System.getProperty("os.name").toLowerCase().contains("win")
+                ? "nvcuda" : "cuda";
+        this.cudaLib = SymbolLookup.libraryLookup(libName, arena);
+
+        log.info("CudaKernelLauncher initialized");
+    }
+
+    /**
+     * Loads a PTX kernel module from a file.
+     *
+     * @param ptxPath path to the .ptx file
+     * @return this launcher for chaining
+     * @throws RuntimeException if loading fails
+     */
+    public CudaKernelLauncher loadModule(Path ptxPath) {
+        ensureOpen();
         try {
-            String libName = System.getProperty("os.name").toLowerCase().contains("win")
-                    ? "nvcuda" : "cuda";
-            this.cudaLib = SymbolLookup.libraryLookup(libName, arena);
+            String ptxSource = Files.readString(ptxPath);
+            return loadModuleFromSource(ptxSource);
+        } catch (Exception e) {
+            throw new RuntimeException("Failed to load PTX from: " + ptxPath, e);
+        }
+    }
 
-            // Load PTX module
-            MemorySegment ptxBytes = arena.allocateFrom(BATCH_COSINE_PTX);
+    /**
+     * Loads a PTX kernel module from a source string.
+     *
+     * @param ptxSource PTX source code
+     * @return this launcher for chaining
+     */
+    public CudaKernelLauncher loadModuleFromSource(String ptxSource) {
+        ensureOpen();
+        try {
             MemorySegment modulePtr = arena.allocate(ValueLayout.ADDRESS);
+            MemorySegment ptxData = arena.allocateFrom(ptxSource);
 
             MethodHandle cuModuleLoadData = linker.downcallHandle(
                     cudaLib.find("cuModuleLoadData").orElseThrow(),
                     FunctionDescriptor.of(ValueLayout.JAVA_INT,
                             ValueLayout.ADDRESS, ValueLayout.ADDRESS));
-            int result = (int) cuModuleLoadData.invoke(modulePtr, ptxBytes);
+
+            int result = (int) cuModuleLoadData.invoke(modulePtr, ptxData);
             if (result != 0) {
-                throw new SpectorGpuException(ErrorCode.GPU_DEVICE_ERROR, "cuModuleLoadData failed", result);
+                throw new RuntimeException("cuModuleLoadData failed: " + result);
             }
-            this.cuModule = modulePtr.get(ValueLayout.ADDRESS, 0).address();
 
-            // Get function handle
+            this.cuModule = modulePtr.get(ValueLayout.ADDRESS, 0);
+            log.info("CUDA module loaded ({} bytes PTX)", ptxSource.length());
+            return this;
+        } catch (Throwable e) {
+            throw new RuntimeException("Failed to load CUDA module", e);
+        }
+    }
+
+    /**
+     * Gets a function handle from the loaded module.
+     *
+     * @param functionName name of the kernel function
+     * @return device function pointer
+     */
+    public MemorySegment getFunction(String functionName) {
+        ensureOpen();
+        if (cuModule == null) {
+            throw new IllegalStateException("No module loaded. Call loadModule() first.");
+        }
+
+        try {
             MemorySegment funcPtr = arena.allocate(ValueLayout.ADDRESS);
-            MemorySegment funcName = arena.allocateFrom("batch_cosine");
+            MemorySegment nameStr = arena.allocateFrom(functionName);
+
             MethodHandle cuModuleGetFunction = linker.downcallHandle(
                     cudaLib.find("cuModuleGetFunction").orElseThrow(),
                     FunctionDescriptor.of(ValueLayout.JAVA_INT,
                             ValueLayout.ADDRESS, ValueLayout.ADDRESS, ValueLayout.ADDRESS));
-            result = (int) cuModuleGetFunction.invoke(funcPtr,
-                    MemorySegment.ofAddress(cuModule), funcName);
+
+            int result = (int) cuModuleGetFunction.invoke(funcPtr, cuModule, nameStr);
             if (result != 0) {
-                throw new SpectorGpuException(ErrorCode.GPU_DEVICE_ERROR, "cuModuleGetFunction failed", result);
+                throw new RuntimeException("cuModuleGetFunction('" + functionName + "') failed: " + result);
             }
-            this.cuFunction = funcPtr.get(ValueLayout.ADDRESS, 0).address();
-
-            // Cache method handles
-            this.cuMemAlloc = linker.downcallHandle(
-                    cudaLib.find("cuMemAlloc_v2").orElseThrow(),
-                    FunctionDescriptor.of(ValueLayout.JAVA_INT,
-                            ValueLayout.ADDRESS, ValueLayout.JAVA_LONG));
-            this.cuMemcpyHtoD = linker.downcallHandle(
-                    cudaLib.find("cuMemcpyHtoD_v2").orElseThrow(),
-                    FunctionDescriptor.of(ValueLayout.JAVA_INT,
-                            ValueLayout.JAVA_LONG, ValueLayout.ADDRESS, ValueLayout.JAVA_LONG));
-            this.cuMemcpyDtoH = linker.downcallHandle(
-                    cudaLib.find("cuMemcpyDtoH_v2").orElseThrow(),
-                    FunctionDescriptor.of(ValueLayout.JAVA_INT,
-                            ValueLayout.ADDRESS, ValueLayout.JAVA_LONG, ValueLayout.JAVA_LONG));
-            this.cuMemFree = linker.downcallHandle(
-                    cudaLib.find("cuMemFree_v2").orElseThrow(),
-                    FunctionDescriptor.of(ValueLayout.JAVA_INT, ValueLayout.JAVA_LONG));
-            this.cuLaunchKernel = linker.downcallHandle(
-                    cudaLib.find("cuLaunchKernel").orElseThrow(),
-                    FunctionDescriptor.of(ValueLayout.JAVA_INT,
-                            ValueLayout.ADDRESS,           // function
-                            ValueLayout.JAVA_INT,          // gridDimX
-                            ValueLayout.JAVA_INT,          // gridDimY
-                            ValueLayout.JAVA_INT,          // gridDimZ
-                            ValueLayout.JAVA_INT,          // blockDimX
-                            ValueLayout.JAVA_INT,          // blockDimY
-                            ValueLayout.JAVA_INT,          // blockDimZ
-                            ValueLayout.JAVA_INT,          // sharedMemBytes
-                            ValueLayout.ADDRESS,           // stream (null = default)
-                            ValueLayout.ADDRESS,           // kernelParams
-                            ValueLayout.ADDRESS));         // extra (null)
-            this.cuCtxSynchronize = linker.downcallHandle(
-                    cudaLib.find("cuCtxSynchronize").orElseThrow(),
-                    FunctionDescriptor.of(ValueLayout.JAVA_INT));
-
-            log.info("CudaKernelLauncher initialized: PTX loaded, function 'batch_cosine' ready");
 
+            return funcPtr.get(ValueLayout.ADDRESS, 0);
         } catch (Throwable e) {
-            throw new SpectorServerException(ErrorCode.INTERNAL_ERROR, e, "Failed to initialize CUDA kernel launcher");
+            throw new RuntimeException("Failed to get function: " + functionName, e);
         }
     }
 
     /**
-     * Launches the batch cosine similarity kernel on the GPU.
+     * Launches a kernel with the specified grid and block dimensions.
      *
-     * <p>Transfers query and database vectors to device memory, launches the kernel
-     * with one thread per database vector, and copies results back to host.</p>
-     *
-     * @param query    query vector (length = dims)
-     * @param database flat database vectors (n × dims)
-     * @param n        number of database vectors
-     * @param dims     vector dimensionality
-     * @return array of n cosine similarity scores
+     * @param function      function handle from {@link #getFunction}
+     * @param gridDimX      grid dimension X (number of blocks)
+     * @param gridDimY      grid dimension Y
+     * @param gridDimZ      grid dimension Z
+     * @param blockDimX     block dimension X (threads per block)
+     * @param blockDimY     block dimension Y
+     * @param blockDimZ     block dimension Z
+     * @param sharedMemBytes shared memory per block
+     * @param kernelParams  pointer to kernel parameter array
      */
-    public float[] batchCosine(float[] query, float[] database, int n, int dims) {
-        if (closed) throw new SpectorSegmentClosedException();
-        if (n == 0) return new float[0];
-
-        try (Arena local = Arena.ofConfined()) {
-            long queryBytes = (long) dims * Float.BYTES;
-            long dbBytes = (long) n * dims * Float.BYTES;
-            long resultBytes = (long) n * Float.BYTES;
-
-            // Allocate device memory
-            long dQuery = deviceAlloc(local, queryBytes);
-            long dDatabase = deviceAlloc(local, dbBytes);
-            long dResults = deviceAlloc(local, resultBytes);
-
-            try {
-                // Copy host → device
-                MemorySegment querySegment = local.allocateFrom(ValueLayout.JAVA_FLOAT, query);
-                MemorySegment dbSegment = local.allocateFrom(ValueLayout.JAVA_FLOAT, database);
-
-                check((int) cuMemcpyHtoD.invoke(dQuery, querySegment, queryBytes));
-                check((int) cuMemcpyHtoD.invoke(dDatabase, dbSegment, dbBytes));
-
-                // Set up kernel parameters
-                // params: query_ptr, database_ptr, results_ptr, n, dims
-                MemorySegment paramsArray = local.allocate(ValueLayout.ADDRESS, 5);
-                MemorySegment pQuery = local.allocate(ValueLayout.JAVA_LONG);
-                pQuery.set(ValueLayout.JAVA_LONG, 0, dQuery);
-                MemorySegment pDb = local.allocate(ValueLayout.JAVA_LONG);
-                pDb.set(ValueLayout.JAVA_LONG, 0, dDatabase);
-                MemorySegment pRes = local.allocate(ValueLayout.JAVA_LONG);
-                pRes.set(ValueLayout.JAVA_LONG, 0, dResults);
-                MemorySegment pN = local.allocate(ValueLayout.JAVA_INT);
-                pN.set(ValueLayout.JAVA_INT, 0, n);
-                MemorySegment pDims = local.allocate(ValueLayout.JAVA_INT);
-                pDims.set(ValueLayout.JAVA_INT, 0, dims);
-
-                paramsArray.setAtIndex(ValueLayout.ADDRESS, 0, pQuery);
-                paramsArray.setAtIndex(ValueLayout.ADDRESS, 1, pDb);
-                paramsArray.setAtIndex(ValueLayout.ADDRESS, 2, pRes);
-                paramsArray.setAtIndex(ValueLayout.ADDRESS, 3, pN);
-                paramsArray.setAtIndex(ValueLayout.ADDRESS, 4, pDims);
-
-                // Launch kernel
-                int blockSize = 256;
-                int gridSize = (n + blockSize - 1) / blockSize;
-
-                int launchResult = (int) cuLaunchKernel.invoke(
-                        MemorySegment.ofAddress(cuFunction),
-                        gridSize, 1, 1,      // grid dims
-                        blockSize, 1, 1,     // block dims
-                        0,                   // shared memory
-                        MemorySegment.NULL,  // stream (default)
-                        paramsArray,         // kernel params
-                        MemorySegment.NULL); // extra
-                check(launchResult);
-
-                // Synchronize
-                check((int) cuCtxSynchronize.invoke());
-
-                // Copy results device → host
-                MemorySegment resultSegment = local.allocate(ValueLayout.JAVA_FLOAT, n);
-                check((int) cuMemcpyDtoH.invoke(resultSegment, dResults, resultBytes));
-
-                float[] results = new float[n];
-                MemorySegment.copy(resultSegment, ValueLayout.JAVA_FLOAT, 0, results, 0, n);
-                return results;
+    public void launchKernel(MemorySegment function,
+                             int gridDimX, int gridDimY, int gridDimZ,
+                             int blockDimX, int blockDimY, int blockDimZ,
+                             int sharedMemBytes,
+                             MemorySegment kernelParams) {
+        ensureOpen();
+        try {
+            MethodHandle cuLaunchKernel = linker.downcallHandle(
+                    cudaLib.find("cuLaunchKernel").orElseThrow(),
+                    FunctionDescriptor.of(ValueLayout.JAVA_INT,
+                            ValueLayout.ADDRESS,
+                            ValueLayout.JAVA_INT, ValueLayout.JAVA_INT, ValueLayout.JAVA_INT,
+                            ValueLayout.JAVA_INT, ValueLayout.JAVA_INT, ValueLayout.JAVA_INT,
+                            ValueLayout.JAVA_INT,
+                            ValueLayout.ADDRESS,  // stream (0 = default)
+                            ValueLayout.ADDRESS,  // kernelParams
+                            ValueLayout.ADDRESS   // extra (null)
+                    ));
+
+            int result = (int) cuLaunchKernel.invoke(function,
+                    gridDimX, gridDimY, gridDimZ,
+                    blockDimX, blockDimY, blockDimZ,
+                    sharedMemBytes,
+                    MemorySegment.NULL,   // default stream
+                    kernelParams,
+                    MemorySegment.NULL);  // no extra
 
-            } finally {
-                // Free device memory
-                try { cuMemFree.invoke(dQuery); } catch (Throwable ignored) {}
-                try { cuMemFree.invoke(dDatabase); } catch (Throwable ignored) {}
-                try { cuMemFree.invoke(dResults); } catch (Throwable ignored) {}
+            if (result != 0) {
+                throw new RuntimeException("cuLaunchKernel failed: " + result);
             }
 
-        } catch (RuntimeException e) {
-            throw e;
+            // Synchronize
+            MethodHandle cuCtxSync = linker.downcallHandle(
+                    cudaLib.find("cuCtxSynchronize").orElseThrow(),
+                    FunctionDescriptor.of(ValueLayout.JAVA_INT));
+            cuCtxSync.invoke();
+
         } catch (Throwable e) {
-            throw new SpectorGpuException(ErrorCode.GPU_DEVICE_ERROR, e, "Kernel launch failed", 0);
+            throw new RuntimeException("Kernel launch failed", e);
         }
     }
 
-    private long deviceAlloc(Arena local, long bytes) throws Throwable {
-        MemorySegment ptr = local.allocate(ValueLayout.JAVA_LONG);
-        check((int) cuMemAlloc.invoke(ptr, bytes));
-        return ptr.get(ValueLayout.JAVA_LONG, 0);
-    }
-
-    private void check(int cudaResult) {
-        if (cudaResult != 0) {
-            throw new SpectorGpuException(ErrorCode.GPU_DEVICE_ERROR, "CUDA error", cudaResult);
-        }
-    }
+    /** Returns whether a module is loaded. */
+    public boolean isModuleLoaded() { return cuModule != null; }
 
     @Override
     public void close() {
         if (!closed) {
             closed = true;
-            try {
-                MethodHandle cuModuleUnload = linker.downcallHandle(
-                        cudaLib.find("cuModuleUnload").orElseThrow(),
-                        FunctionDescriptor.of(ValueLayout.JAVA_INT, ValueLayout.ADDRESS));
-                cuModuleUnload.invoke(MemorySegment.ofAddress(cuModule));
-            } catch (Throwable e) {
-                log.warn("Error unloading CUDA module", e);
+            if (cuModule != null) {
+                try {
+                    MethodHandle cuModuleUnload = linker.downcallHandle(
+                            cudaLib.find("cuModuleUnload").orElseThrow(),
+                            FunctionDescriptor.of(ValueLayout.JAVA_INT, ValueLayout.ADDRESS));
+                    cuModuleUnload.invoke(cuModule);
+                } catch (Throwable e) {
+                    log.warn("cuModuleUnload failed", e);
+                }
             }
             arena.close();
             log.info("CudaKernelLauncher closed");
         }
     }
+
+    private void ensureOpen() {
+        if (closed) throw new IllegalStateException("CudaKernelLauncher is closed");
+    }
 }
diff --git a/spector-gpu/src/main/java/com/spectrayan/spector/gpu/GpuAllocation.java b/spector-gpu/src/main/java/com/spectrayan/spector/gpu/GpuAllocation.java
index 630a087..9f387e4 100644
--- a/spector-gpu/src/main/java/com/spectrayan/spector/gpu/GpuAllocation.java
+++ b/spector-gpu/src/main/java/com/spectrayan/spector/gpu/GpuAllocation.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.gpu;
 
 import java.lang.foreign.Arena;
diff --git a/spector-gpu/src/main/java/com/spectrayan/spector/gpu/GpuBatchSimilarity.java b/spector-gpu/src/main/java/com/spectrayan/spector/gpu/GpuBatchSimilarity.java
index baffc1e..b29a264 100644
--- a/spector-gpu/src/main/java/com/spectrayan/spector/gpu/GpuBatchSimilarity.java
+++ b/spector-gpu/src/main/java/com/spectrayan/spector/gpu/GpuBatchSimilarity.java
@@ -1,38 +1,14 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.gpu;
 
-import java.lang.foreign.Arena;
-import java.lang.foreign.FunctionDescriptor;
-import java.lang.foreign.Linker;
-import java.lang.foreign.MemorySegment;
-import java.lang.foreign.SymbolLookup;
-import java.lang.foreign.ValueLayout;
-import java.lang.invoke.MethodHandle;
+import jdk.incubator.vector.FloatVector;
+import jdk.incubator.vector.VectorOperators;
+import jdk.incubator.vector.VectorSpecies;
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import jdk.incubator.vector.FloatVector;
-import jdk.incubator.vector.VectorOperators;
-import jdk.incubator.vector.VectorSpecies;
-import com.spectrayan.spector.commons.error.SpectorServerException;
-import com.spectrayan.spector.commons.error.SpectorGpuException;
-import com.spectrayan.spector.storage.error.SpectorSegmentClosedException;
-import com.spectrayan.spector.commons.error.ErrorCode;
+import java.lang.foreign.*;
+import java.lang.invoke.MethodHandle;
 
 /**
  * GPU-accelerated batch similarity computation via CUDA.
@@ -69,7 +45,6 @@ public final class GpuBatchSimilarity implements AutoCloseable {
 
     // CUDA handles
     private final MemorySegment cuContext;
-    private final CudaKernelLauncher kernelLauncher; // actual GPU compute
 
     // Method handles for CUDA driver API
     private final MethodHandle cuMemAlloc;
@@ -82,11 +57,11 @@ public final class GpuBatchSimilarity implements AutoCloseable {
     /**
      * Creates a GPU batch similarity engine.
      *
-     * @throws SpectorGpuException if CUDA is not available
+     * @throws IllegalStateException if CUDA is not available
      */
     public GpuBatchSimilarity() {
         if (!GpuCapability.isAvailable()) {
-            throw new SpectorServerException(ErrorCode.GPU_NOT_AVAILABLE);
+            throw new IllegalStateException("CUDA GPU not available: " + GpuCapability.detect().report());
         }
 
         this.arena = Arena.ofShared();
@@ -106,7 +81,7 @@ public GpuBatchSimilarity() {
                             ValueLayout.ADDRESS, ValueLayout.JAVA_INT, ValueLayout.JAVA_INT));
             int result = (int) cuCtxCreate.invoke(ctxPtr, 0, 0);
             if (result != 0) {
-                throw new SpectorGpuException(ErrorCode.GPU_DEVICE_ERROR, "cuCtxCreate failed", result);
+                throw new RuntimeException("cuCtxCreate failed: " + result);
             }
             this.cuContext = ctxPtr.get(ValueLayout.ADDRESS, 0);
 
@@ -133,19 +108,8 @@ public GpuBatchSimilarity() {
             log.info("GpuBatchSimilarity initialized: {}", GpuCapability.detect().report());
 
         } catch (Throwable e) {
-            throw new SpectorServerException(ErrorCode.INTERNAL_ERROR, e, "Failed to initialize CUDA context");
+            throw new RuntimeException("Failed to initialize CUDA context", e);
         }
-
-        // Initialize kernel launcher for actual GPU compute
-        CudaKernelLauncher launcher = null;
-        try {
-            launcher = new CudaKernelLauncher();
-        } catch (Exception e) {
-            log.warn("CUDA kernel launcher init failed, will use CPU SIMD fallback: {}",
-                    e.getMessage());
-            log.debug("CUDA kernel launcher failure details", e);
-        }
-        this.kernelLauncher = launcher;
     }
 
     /**
@@ -193,8 +157,15 @@ public float[] batchDotProduct(float[] query, float[] database, int n, int dims)
     /**
      * Computes batch cosine similarities between a query and database vectors.
      *
-     * <p>For large batches (≥64 vectors), dispatches to the GPU CUDA kernel.
-     * For small batches or when the kernel is unavailable, uses CPU SIMD.</p>
+     * <p>Optimized with SIMD (Java Vector API) for maximum throughput:</p>
+     * <ul>
+     *   <li>Query norm is precomputed once (single SIMD pass)</li>
+     *   <li>Each database vector computes dot-product and norm in a single fused SIMD pass</li>
+     *   <li>Uses FMA (fused multiply-add) for numerical precision and throughput</li>
+     * </ul>
+     *
+     * <p>This reduces the original 3-loop structure to 2 passes (1 for query norm,
+     * 1 fused pass per database vector), with full SIMD utilization.</p>
      *
      * @param query    the query vector (length D)
      * @param database the database vectors (N × D), stored as flat array [N*D]
@@ -206,27 +177,6 @@ public float[] batchCosineSimilarity(float[] query, float[] database, int n, int
         ensureOpen();
         if (n == 0) return new float[0];
 
-        // Use GPU for very large batches where compute dominates transfer overhead
-        // At 384-dim, breakeven is ~10K+ vectors due to PCIe transfer cost
-        if (kernelLauncher != null && n >= 10_000) {
-            try {
-                return kernelLauncher.batchCosine(query, database, n, dims);
-            } catch (Exception e) {
-                log.debug("GPU kernel failed, falling back to CPU SIMD: {}", e.getMessage());
-            }
-        }
-
-        // CPU SIMD path (small batches or fallback)
-        return batchCosineSimilarityCpu(query, database, n, dims);
-    }
-
-    /**
-     * CPU SIMD implementation of batch cosine similarity.
-     */
-    private float[] batchCosineSimilarityCpu(float[] query, float[] database, int n, int dims) {
-        ensureOpen();
-        if (n == 0) return new float[0];
-
         int vectorLen = SPECIES.length();
         int simdBound = dims - (dims % vectorLen);
 
@@ -285,11 +235,11 @@ public long deviceMalloc(long bytes) {
             MemorySegment ptrHolder = localArena.allocate(ValueLayout.JAVA_LONG);
             int result = (int) cuMemAlloc.invoke(ptrHolder, bytes);
             if (result != 0) {
-                throw new SpectorGpuException(ErrorCode.GPU_DEVICE_ERROR, "cuMemAlloc failed", result);
+                throw new RuntimeException("cuMemAlloc failed: " + result);
             }
             return ptrHolder.get(ValueLayout.JAVA_LONG, 0);
         } catch (Throwable e) {
-            throw new SpectorGpuException(ErrorCode.GPU_MEMORY_ALLOC_FAILED, e, 0);
+            throw new RuntimeException("Device memory allocation failed", e);
         }
     }
 
@@ -312,7 +262,6 @@ public void close() {
         if (!closed) {
             closed = true;
             try {
-                if (kernelLauncher != null) kernelLauncher.close();
                 // Destroy CUDA context
                 MethodHandle cuCtxDestroy = linker.downcallHandle(
                         cudaLib.find("cuCtxDestroy_v2").orElseThrow(),
@@ -327,6 +276,6 @@ public void close() {
     }
 
     private void ensureOpen() {
-        if (closed) throw new SpectorSegmentClosedException();
+        if (closed) throw new IllegalStateException("GpuBatchSimilarity is closed");
     }
 }
diff --git a/spector-gpu/src/main/java/com/spectrayan/spector/gpu/GpuCapability.java b/spector-gpu/src/main/java/com/spectrayan/spector/gpu/GpuCapability.java
index 18b0ce9..939cfb4 100644
--- a/spector-gpu/src/main/java/com/spectrayan/spector/gpu/GpuCapability.java
+++ b/spector-gpu/src/main/java/com/spectrayan/spector/gpu/GpuCapability.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.gpu;
 
 import org.slf4j.Logger;
diff --git a/spector-gpu/src/main/java/com/spectrayan/spector/gpu/error/SpectorGpuMemoryException.java b/spector-gpu/src/main/java/com/spectrayan/spector/gpu/GpuMemoryException.java
similarity index 55%
rename from spector-gpu/src/main/java/com/spectrayan/spector/gpu/error/SpectorGpuMemoryException.java
rename to spector-gpu/src/main/java/com/spectrayan/spector/gpu/GpuMemoryException.java
index 01f5df4..922fcdd 100644
--- a/spector-gpu/src/main/java/com/spectrayan/spector/gpu/error/SpectorGpuMemoryException.java
+++ b/spector-gpu/src/main/java/com/spectrayan/spector/gpu/GpuMemoryException.java
@@ -1,21 +1,4 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.gpu.error;
-
-import com.spectrayan.spector.commons.error.*;
+package com.spectrayan.spector.gpu;
 
 /**
  * Exception thrown when a GPU memory operation fails.
@@ -23,10 +6,8 @@
  * <p>Contains information about the requested allocation size and
  * the currently available device memory, enabling callers to make
  * informed decisions about memory management.</p>
- *
- * @see SpectorGpuException
  */
-public class SpectorGpuMemoryException extends SpectorGpuException {
+public class GpuMemoryException extends RuntimeException {
 
     private final long requestedBytes;
     private final long availableBytes;
@@ -38,8 +19,8 @@ public class SpectorGpuMemoryException extends SpectorGpuException {
      * @param requestedBytes the number of bytes that were requested
      * @param availableBytes the number of bytes available (or budget remaining)
      */
-    public SpectorGpuMemoryException(String message, long requestedBytes, long availableBytes) {
-        super(ErrorCode.GPU_MEMORY_EXHAUSTED, requestedBytes, availableBytes);
+    public GpuMemoryException(String message, long requestedBytes, long availableBytes) {
+        super(message);
         this.requestedBytes = requestedBytes;
         this.availableBytes = availableBytes;
     }
@@ -52,8 +33,8 @@ public SpectorGpuMemoryException(String message, long requestedBytes, long avail
      * @param requestedBytes the number of bytes that were requested
      * @param availableBytes the number of bytes available (or budget remaining)
      */
-    public SpectorGpuMemoryException(String message, Throwable cause, long requestedBytes, long availableBytes) {
-        super(ErrorCode.GPU_MEMORY_EXHAUSTED, cause, requestedBytes, availableBytes);
+    public GpuMemoryException(String message, Throwable cause, long requestedBytes, long availableBytes) {
+        super(message, cause);
         this.requestedBytes = requestedBytes;
         this.availableBytes = availableBytes;
     }
diff --git a/spector-gpu/src/main/java/com/spectrayan/spector/gpu/GpuMemoryManager.java b/spector-gpu/src/main/java/com/spectrayan/spector/gpu/GpuMemoryManager.java
index 9e7b5b5..1b188d2 100644
--- a/spector-gpu/src/main/java/com/spectrayan/spector/gpu/GpuMemoryManager.java
+++ b/spector-gpu/src/main/java/com/spectrayan/spector/gpu/GpuMemoryManager.java
@@ -1,22 +1,5 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.gpu;
 
-import com.spectrayan.spector.gpu.error.SpectorGpuMemoryException;
-
 import java.lang.foreign.Arena;
 import java.lang.foreign.FunctionDescriptor;
 import java.lang.foreign.Linker;
@@ -32,11 +15,6 @@
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-import com.spectrayan.spector.commons.error.SpectorServerException;
-import com.spectrayan.spector.commons.error.SpectorGpuException;
-import com.spectrayan.spector.storage.error.SpectorSegmentClosedException;
-import com.spectrayan.spector.commons.error.ErrorCode;
 
 /**
  * Manages GPU device memory allocation and lifecycle via Panama FFM.
@@ -105,7 +83,7 @@ public class GpuMemoryManager implements AutoCloseable {
      * and CPU-fallback scenarios).</p>
      *
      * @param maxBudgetBytes maximum device memory budget in bytes (minimum 256MB)
-     * @throws SpectorValidationException if budget is below 256MB
+     * @throws IllegalArgumentException if budget is below 256MB
      */
     public GpuMemoryManager(long maxBudgetBytes) {
         this(maxBudgetBytes, !GpuCapability.isAvailable());
@@ -116,11 +94,13 @@ public GpuMemoryManager(long maxBudgetBytes) {
      *
      * @param maxBudgetBytes maximum device memory budget in bytes (minimum 256MB)
      * @param simulatedMode  if true, operates without real GPU memory (for testing)
-     * @throws SpectorValidationException if budget is below 256MB
+     * @throws IllegalArgumentException if budget is below 256MB
      */
     public GpuMemoryManager(long maxBudgetBytes, boolean simulatedMode) {
         if (maxBudgetBytes < MIN_BUDGET_BYTES) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_OUT_OF_RANGE, "Memory budget must be at least 256MB, got: %d bytes (%d MB)" .formatted(maxBudgetBytes, maxBudgetBytes / (1024 * 1024)));
+            throw new IllegalArgumentException(
+                    "Memory budget must be at least 256MB, got: %d bytes (%d MB)"
+                            .formatted(maxBudgetBytes, maxBudgetBytes / (1024 * 1024)));
         }
 
         this.maxBudgetBytes = maxBudgetBytes;
@@ -144,7 +124,7 @@ public GpuMemoryManager(long maxBudgetBytes, boolean simulatedMode) {
                                 ValueLayout.ADDRESS, ValueLayout.JAVA_INT, ValueLayout.JAVA_INT));
                 int ctxResult = (int) cuCtxCreate.invoke(ctxPtr, 0, 0);
                 if (ctxResult != 0) {
-                    throw new SpectorGpuException(ErrorCode.GPU_DEVICE_ERROR, "cuCtxCreate failed", ctxResult);
+                    throw new RuntimeException("cuCtxCreate failed: " + ctxResult);
                 }
                 this.cuContext = ctxPtr.get(ValueLayout.ADDRESS, 0);
 
@@ -170,7 +150,7 @@ public GpuMemoryManager(long maxBudgetBytes, boolean simulatedMode) {
                 log.info("GpuMemoryManager initialized: budget={}MB, GPU={}",
                         maxBudgetBytes / (1024 * 1024), GpuCapability.detect().deviceName());
             } catch (Throwable e) {
-                throw new SpectorServerException(ErrorCode.INTERNAL_ERROR, e, "Failed to initialize CUDA memory handles");
+                throw new RuntimeException("Failed to initialize CUDA memory handles", e);
             }
         } else {
             // Simulated mode — no actual GPU, but track allocations for testing
@@ -196,8 +176,8 @@ public GpuMemoryManager(long maxBudgetBytes, boolean simulatedMode) {
      * @param size  number of bytes to allocate on the device
      * @param arena the Arena scope that determines the allocation's lifetime
      * @return a MemorySegment representing the device allocation
-     * @throws SpectorGpuMemoryException if allocation fails or would exceed budget
-     * @throws SpectorGpuException if the manager is closed
+     * @throws GpuMemoryException if allocation fails or would exceed budget
+     * @throws IllegalStateException if the manager is closed
      */
     public MemorySegment allocateDevice(long size, Arena arena) {
         ensureOpen();
@@ -243,8 +223,8 @@ public MemorySegment allocateDevice(long size, Arena arena) {
      * @param size  number of bytes to allocate as pinned host memory
      * @param arena the Arena scope that determines the allocation's lifetime
      * @return a MemorySegment backed by pinned host memory
-     * @throws SpectorGpuMemoryException if allocation fails or would exceed budget
-     * @throws SpectorGpuException if the manager is closed
+     * @throws GpuMemoryException if allocation fails or would exceed budget
+     * @throws IllegalStateException if the manager is closed
      */
     public MemorySegment allocatePinned(long size, Arena arena) {
         ensureOpen();
@@ -352,13 +332,13 @@ public void close() {
 
     private void ensureOpen() {
         if (closed) {
-            throw new SpectorSegmentClosedException();
+            throw new IllegalStateException("GpuMemoryManager is closed");
         }
     }
 
     private void validateSize(long size) {
         if (size <= 0) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_OUT_OF_RANGE, "size", 1, Integer.MAX_VALUE, size);
+            throw new IllegalArgumentException("Allocation size must be positive, got: " + size);
         }
     }
 
@@ -367,7 +347,7 @@ private void enforceBudget(long requestedSize) {
         long available = maxBudgetBytes - currentUsage;
 
         if (requestedSize > available) {
-            throw new SpectorGpuMemoryException(
+            throw new GpuMemoryException(
                     "Allocation of %d bytes would exceed budget. Budget: %d bytes, Used: %d bytes, Available: %d bytes"
                             .formatted(requestedSize, maxBudgetBytes, currentUsage, available),
                     requestedSize,
@@ -382,7 +362,7 @@ private long cudaAllocDevice(long size) {
             int result = (int) cuMemAlloc.invoke(ptrHolder, size);
             if (result != 0) {
                 long available = queryAvailableDeviceMemory();
-                throw new SpectorGpuMemoryException(
+                throw new GpuMemoryException(
                         "cuMemAlloc failed (error %d) for %d bytes. Available device memory: %d bytes"
                                 .formatted(result, size, available),
                         size,
@@ -390,10 +370,10 @@ private long cudaAllocDevice(long size) {
                 );
             }
             return ptrHolder.get(ValueLayout.JAVA_LONG, 0);
-        } catch (SpectorGpuMemoryException e) {
+        } catch (GpuMemoryException e) {
             throw e;
         } catch (Throwable e) {
-            throw new SpectorGpuMemoryException(
+            throw new GpuMemoryException(
                     "Device memory allocation failed: " + e.getMessage(),
                     e, size, -1
             );
@@ -405,7 +385,7 @@ private MemorySegment cudaAllocPinned(long size, Arena arena) {
             MemorySegment ptrHolder = localArena.allocate(ValueLayout.ADDRESS);
             int result = (int) cuMemAllocHost.invoke(ptrHolder, size);
             if (result != 0) {
-                throw new SpectorGpuMemoryException(
+                throw new GpuMemoryException(
                         "cuMemAllocHost failed (error %d) for %d bytes".formatted(result, size),
                         size,
                         getAvailableBytes()
@@ -414,10 +394,10 @@ private MemorySegment cudaAllocPinned(long size, Arena arena) {
             MemorySegment hostPtr = ptrHolder.get(ValueLayout.ADDRESS, 0);
             // Reinterpret with the caller's arena scope and desired size
             return hostPtr.reinterpret(size, arena, null);
-        } catch (SpectorGpuMemoryException e) {
+        } catch (GpuMemoryException e) {
             throw e;
         } catch (Throwable e) {
-            throw new SpectorGpuMemoryException(
+            throw new GpuMemoryException(
                     "Pinned memory allocation failed: " + e.getMessage(),
                     e, size, -1
             );
@@ -506,4 +486,4 @@ private long queryAvailableDeviceMemory() {
         }
         return -1;
     }
-}
\ No newline at end of file
+}
diff --git a/spector-gpu/src/main/java/com/spectrayan/spector/gpu/GpuMemoryMetrics.java b/spector-gpu/src/main/java/com/spectrayan/spector/gpu/GpuMemoryMetrics.java
index c0d176e..76ef776 100644
--- a/spector-gpu/src/main/java/com/spectrayan/spector/gpu/GpuMemoryMetrics.java
+++ b/spector-gpu/src/main/java/com/spectrayan/spector/gpu/GpuMemoryMetrics.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.gpu;
 
 import java.util.Map;
diff --git a/spector-gpu/src/main/java/com/spectrayan/spector/gpu/GpuVectorIndex.java b/spector-gpu/src/main/java/com/spectrayan/spector/gpu/GpuVectorIndex.java
deleted file mode 100644
index b6ecebe..0000000
--- a/spector-gpu/src/main/java/com/spectrayan/spector/gpu/GpuVectorIndex.java
+++ /dev/null
@@ -1,393 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.gpu;
-
-import java.lang.foreign.Arena;
-import java.lang.foreign.FunctionDescriptor;
-import java.lang.foreign.Linker;
-import java.lang.foreign.MemorySegment;
-import java.lang.foreign.SymbolLookup;
-import java.lang.foreign.ValueLayout;
-import java.lang.invoke.MethodHandle;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import jdk.incubator.vector.FloatVector;
-import jdk.incubator.vector.VectorOperators;
-import jdk.incubator.vector.VectorSpecies;
-import com.spectrayan.spector.commons.error.SpectorServerException;
-import com.spectrayan.spector.commons.error.SpectorGpuException;
-import com.spectrayan.spector.storage.error.SpectorSegmentClosedException;
-import com.spectrayan.spector.commons.error.ErrorCode;
-
-/**
- * GPU-resident vector index for brute-force similarity search.
- *
- * <p>Uploads the entire vector database to GPU VRAM once at construction,
- * then each search only transfers the query vector (tiny) and retrieves
- * the results. This amortizes the PCIe transfer cost over many queries.</p>
- *
- * <h3>Usage Pattern</h3>
- * <pre>{@code
- *   // Upload database to GPU (one-time cost)
- *   var gpuIndex = GpuVectorIndex.create(database, numVectors, dims);
- *
- *   // Each search only transfers query (384 floats = 1.5KB)
- *   float[] scores = gpuIndex.search(queryVector);
- *   // scores[i] = cosine(query, database[i])
- *
- *   // Cleanup
- *   gpuIndex.close();
- * }</pre>
- *
- * <h3>Fallback Behavior</h3>
- * <ul>
- *   <li>If GPU flag is false → never attempts GPU, uses CPU SIMD</li>
- *   <li>If GPU hardware unavailable → logs warning, falls back to CPU SIMD</li>
- *   <li>If GPU allocation fails (OOM) → logs warning, falls back to CPU SIMD</li>
- *   <li>If kernel launch fails → logs warning, falls back to CPU SIMD for that query</li>
- *   <li>Never throws exceptions to the caller — always returns valid results</li>
- * </ul>
- */
-public final class GpuVectorIndex implements AutoCloseable {
-
-    private static final Logger log = LoggerFactory.getLogger(GpuVectorIndex.class);
-    private static final VectorSpecies<Float> SPECIES = FloatVector.SPECIES_PREFERRED;
-
-    private final int numVectors;
-    private final int dimensions;
-    private final float[] cpuDatabase; // kept for CPU fallback
-    private final boolean gpuActive;
-
-    // GPU state (null if GPU unavailable or failed)
-    private final Arena arena;
-    private final long dDatabase;      // device pointer to database vectors
-    private final long dResults;       // device pointer to results buffer
-    private final long dQuery;         // device pointer to query buffer
-    private final MethodHandle cuMemcpyHtoD;
-    private final MethodHandle cuMemcpyDtoH;
-    private final MethodHandle cuLaunchKernel;
-    private final MethodHandle cuCtxSynchronize;
-    private final long cuFunction;     // kernel function handle
-
-    private volatile boolean closed;
-
-    private GpuVectorIndex(int numVectors, int dimensions, float[] cpuDatabase,
-                           boolean gpuActive, Arena arena, long dDatabase,
-                           long dResults, long dQuery,
-                           MethodHandle cuMemcpyHtoD, MethodHandle cuMemcpyDtoH,
-                           MethodHandle cuLaunchKernel, MethodHandle cuCtxSynchronize,
-                           long cuFunction) {
-        this.numVectors = numVectors;
-        this.dimensions = dimensions;
-        this.cpuDatabase = cpuDatabase;
-        this.gpuActive = gpuActive;
-        this.arena = arena;
-        this.dDatabase = dDatabase;
-        this.dResults = dResults;
-        this.dQuery = dQuery;
-        this.cuMemcpyHtoD = cuMemcpyHtoD;
-        this.cuMemcpyDtoH = cuMemcpyDtoH;
-        this.cuLaunchKernel = cuLaunchKernel;
-        this.cuCtxSynchronize = cuCtxSynchronize;
-        this.cuFunction = cuFunction;
-        this.closed = false;
-    }
-
-    /**
-     * Creates a GPU vector index. Uploads database to VRAM if GPU is available.
-     *
-     * @param database   flat database vectors (numVectors × dims)
-     * @param numVectors number of vectors
-     * @param dims       vector dimensionality
-     * @param gpuEnabled whether to attempt GPU acceleration
-     * @return a GpuVectorIndex (always succeeds — falls back to CPU if needed)
-     */
-    public static GpuVectorIndex create(float[] database, int numVectors, int dims, boolean gpuEnabled) {
-        if (!gpuEnabled) {
-            log.info("GPU disabled by config — using CPU SIMD for brute-force search");
-            return cpuOnly(database, numVectors, dims);
-        }
-
-        if (!GpuCapability.isAvailable()) {
-            log.warn("GPU enabled but hardware not available — falling back to CPU SIMD. {}",
-                    GpuCapability.detect().report());
-            return cpuOnly(database, numVectors, dims);
-        }
-
-        try {
-            return createGpu(database, numVectors, dims);
-        } catch (Throwable e) {
-            log.warn("GPU initialization failed — falling back to CPU SIMD: {}", e.getMessage());
-            return cpuOnly(database, numVectors, dims);
-        }
-    }
-
-    private static GpuVectorIndex cpuOnly(float[] database, int numVectors, int dims) {
-        return new GpuVectorIndex(numVectors, dims, database, false,
-                null, 0, 0, 0, null, null, null, null, 0);
-    }
-
-    private static GpuVectorIndex createGpu(float[] database, int numVectors, int dims) throws Throwable {
-        Arena arena = Arena.ofShared();
-        Linker linker = Linker.nativeLinker();
-        String libName = System.getProperty("os.name").toLowerCase().contains("win") ? "nvcuda" : "cuda";
-        SymbolLookup cudaLib = SymbolLookup.libraryLookup(libName, arena);
-
-        // Create CUDA context first
-        MethodHandle cuCtxCreate = linker.downcallHandle(
-                cudaLib.find("cuCtxCreate_v2").orElseThrow(),
-                FunctionDescriptor.of(ValueLayout.JAVA_INT,
-                        ValueLayout.ADDRESS, ValueLayout.JAVA_INT, ValueLayout.JAVA_INT));
-        MemorySegment ctxPtr = arena.allocate(ValueLayout.ADDRESS);
-        int result = (int) cuCtxCreate.invoke(ctxPtr, 0, 0);
-        if (result != 0) throw new SpectorGpuException(ErrorCode.GPU_DEVICE_ERROR, "cuCtxCreate failed", result);
-
-        long dbBytes = (long) numVectors * dims * Float.BYTES;
-        long resultBytes = (long) numVectors * Float.BYTES;
-        long queryBytes = (long) dims * Float.BYTES;
-
-        log.info("Uploading {} vectors ({} MB) to GPU VRAM...",
-                numVectors, dbBytes / (1024 * 1024));
-
-        // Allocate device memory
-        MethodHandle cuMemAlloc = linker.downcallHandle(
-                cudaLib.find("cuMemAlloc_v2").orElseThrow(),
-                FunctionDescriptor.of(ValueLayout.JAVA_INT, ValueLayout.ADDRESS, ValueLayout.JAVA_LONG));
-
-        long dDatabase = deviceAlloc(arena, cuMemAlloc, dbBytes);
-        long dResults = deviceAlloc(arena, cuMemAlloc, resultBytes);
-        long dQuery = deviceAlloc(arena, cuMemAlloc, queryBytes);
-
-        // Upload database to GPU (one-time)
-        MethodHandle cuMemcpyHtoD = linker.downcallHandle(
-                cudaLib.find("cuMemcpyHtoD_v2").orElseThrow(),
-                FunctionDescriptor.of(ValueLayout.JAVA_INT,
-                        ValueLayout.JAVA_LONG, ValueLayout.ADDRESS, ValueLayout.JAVA_LONG));
-
-        MemorySegment dbSegment = arena.allocateFrom(ValueLayout.JAVA_FLOAT, database);
-        int r = (int) cuMemcpyHtoD.invoke(dDatabase, dbSegment, dbBytes);
-        if (r != 0) throw new SpectorGpuException(ErrorCode.GPU_DEVICE_ERROR, "cuMemcpyHtoD failed", r);
-
-        log.info("Database uploaded to GPU successfully");
-
-        // Load PTX kernel
-        try (var ptxStream = GpuVectorIndex.class.getResourceAsStream("/kernels/batch_cosine.ptx")) {
-            if (ptxStream == null) throw new SpectorServerException(ErrorCode.INTERNAL_ERROR, "batch_cosine.ptx not found");
-            String ptx = new String(ptxStream.readAllBytes(), java.nio.charset.StandardCharsets.UTF_8);
-            MemorySegment ptxBytes = arena.allocateFrom(ptx);
-
-            MemorySegment modulePtr = arena.allocate(ValueLayout.ADDRESS);
-            MethodHandle cuModuleLoadData = linker.downcallHandle(
-                    cudaLib.find("cuModuleLoadData").orElseThrow(),
-                    FunctionDescriptor.of(ValueLayout.JAVA_INT, ValueLayout.ADDRESS, ValueLayout.ADDRESS));
-            result = (int) cuModuleLoadData.invoke(modulePtr, ptxBytes);
-            if (result != 0) throw new SpectorGpuException(ErrorCode.GPU_DEVICE_ERROR, "cuModuleLoadData failed", result);
-
-            long module = modulePtr.get(ValueLayout.ADDRESS, 0).address();
-
-            MemorySegment funcPtr = arena.allocate(ValueLayout.ADDRESS);
-            MemorySegment funcName = arena.allocateFrom("batch_cosine");
-            MethodHandle cuModuleGetFunction = linker.downcallHandle(
-                    cudaLib.find("cuModuleGetFunction").orElseThrow(),
-                    FunctionDescriptor.of(ValueLayout.JAVA_INT,
-                            ValueLayout.ADDRESS, ValueLayout.ADDRESS, ValueLayout.ADDRESS));
-            result = (int) cuModuleGetFunction.invoke(funcPtr, MemorySegment.ofAddress(module), funcName);
-            if (result != 0) throw new SpectorGpuException(ErrorCode.GPU_DEVICE_ERROR, "cuModuleGetFunction failed", result);
-
-            long cuFunction = funcPtr.get(ValueLayout.ADDRESS, 0).address();
-
-            MethodHandle cuMemcpyDtoH = linker.downcallHandle(
-                    cudaLib.find("cuMemcpyDtoH_v2").orElseThrow(),
-                    FunctionDescriptor.of(ValueLayout.JAVA_INT,
-                            ValueLayout.ADDRESS, ValueLayout.JAVA_LONG, ValueLayout.JAVA_LONG));
-
-            MethodHandle cuLaunchKernel = linker.downcallHandle(
-                    cudaLib.find("cuLaunchKernel").orElseThrow(),
-                    FunctionDescriptor.of(ValueLayout.JAVA_INT,
-                            ValueLayout.ADDRESS, ValueLayout.JAVA_INT, ValueLayout.JAVA_INT,
-                            ValueLayout.JAVA_INT, ValueLayout.JAVA_INT, ValueLayout.JAVA_INT,
-                            ValueLayout.JAVA_INT, ValueLayout.JAVA_INT, ValueLayout.ADDRESS,
-                            ValueLayout.ADDRESS, ValueLayout.ADDRESS));
-
-            MethodHandle cuCtxSynchronize = linker.downcallHandle(
-                    cudaLib.find("cuCtxSynchronize").orElseThrow(),
-                    FunctionDescriptor.of(ValueLayout.JAVA_INT));
-
-            log.info("GPU kernel loaded — ready for search ({} vectors resident in VRAM)", numVectors);
-
-            return new GpuVectorIndex(numVectors, dims, database, true, arena,
-                    dDatabase, dResults, dQuery,
-                    cuMemcpyHtoD, cuMemcpyDtoH, cuLaunchKernel, cuCtxSynchronize, cuFunction);
-        }
-    }
-
-    private static long deviceAlloc(Arena arena, MethodHandle cuMemAlloc, long bytes) throws Throwable {
-        MemorySegment ptr = arena.allocate(ValueLayout.JAVA_LONG);
-        int result = (int) cuMemAlloc.invoke(ptr, bytes);
-        if (result != 0) throw new SpectorGpuException(ErrorCode.GPU_DEVICE_ERROR, "cuMemAlloc failed", result);
-        return ptr.get(ValueLayout.JAVA_LONG, 0);
-    }
-
-    /**
-     * Computes cosine similarity between the query and ALL database vectors.
-     * GPU path: only transfers query (tiny) since database is already resident.
-     * Falls back to CPU SIMD on any GPU error.
-     *
-     * @param query query vector (length = dimensions)
-     * @return array of numVectors similarity scores
-     */
-    public float[] search(float[] query) {
-        if (closed) throw new SpectorSegmentClosedException();
-
-        if (gpuActive) {
-            try {
-                return searchGpu(query);
-            } catch (Throwable e) {
-                log.warn("GPU search failed, falling back to CPU SIMD: {}", e.getMessage());
-            }
-        }
-        return searchCpu(query);
-    }
-
-    private float[] searchGpu(float[] query) throws Throwable {
-        long queryBytes = (long) dimensions * Float.BYTES;
-        long resultBytes = (long) numVectors * Float.BYTES;
-
-        // Upload query to device (only 1.5KB for 384-dim)
-        try (Arena local = Arena.ofConfined()) {
-            MemorySegment querySegment = local.allocateFrom(ValueLayout.JAVA_FLOAT, query);
-            int r = (int) cuMemcpyHtoD.invoke(dQuery, querySegment, queryBytes);
-            if (r != 0) throw new SpectorGpuException(ErrorCode.GPU_DEVICE_ERROR, "Query upload failed", r);
-
-            // Set up kernel params
-            MemorySegment paramsArray = local.allocate(ValueLayout.ADDRESS, 5);
-            MemorySegment pQuery = local.allocate(ValueLayout.JAVA_LONG);
-            pQuery.set(ValueLayout.JAVA_LONG, 0, dQuery);
-            MemorySegment pDb = local.allocate(ValueLayout.JAVA_LONG);
-            pDb.set(ValueLayout.JAVA_LONG, 0, dDatabase);
-            MemorySegment pRes = local.allocate(ValueLayout.JAVA_LONG);
-            pRes.set(ValueLayout.JAVA_LONG, 0, dResults);
-            MemorySegment pN = local.allocate(ValueLayout.JAVA_INT);
-            pN.set(ValueLayout.JAVA_INT, 0, numVectors);
-            MemorySegment pDims = local.allocate(ValueLayout.JAVA_INT);
-            pDims.set(ValueLayout.JAVA_INT, 0, dimensions);
-
-            paramsArray.setAtIndex(ValueLayout.ADDRESS, 0, pQuery);
-            paramsArray.setAtIndex(ValueLayout.ADDRESS, 1, pDb);
-            paramsArray.setAtIndex(ValueLayout.ADDRESS, 2, pRes);
-            paramsArray.setAtIndex(ValueLayout.ADDRESS, 3, pN);
-            paramsArray.setAtIndex(ValueLayout.ADDRESS, 4, pDims);
-
-            // Launch kernel
-            int blockSize = 256;
-            int gridSize = (numVectors + blockSize - 1) / blockSize;
-
-            r = (int) cuLaunchKernel.invoke(
-                    MemorySegment.ofAddress(cuFunction),
-                    gridSize, 1, 1, blockSize, 1, 1,
-                    0, MemorySegment.NULL, paramsArray, MemorySegment.NULL);
-            if (r != 0) throw new SpectorGpuException(ErrorCode.GPU_DEVICE_ERROR, "Kernel launch failed", r);
-
-            r = (int) cuCtxSynchronize.invoke();
-            if (r != 0) throw new SpectorGpuException(ErrorCode.GPU_DEVICE_ERROR, "Sync failed", r);
-
-            // Download results
-            MemorySegment resultSegment = local.allocate(ValueLayout.JAVA_FLOAT, numVectors);
-            r = (int) cuMemcpyDtoH.invoke(resultSegment, dResults, resultBytes);
-            if (r != 0) throw new SpectorGpuException(ErrorCode.GPU_DEVICE_ERROR, "Result download failed", r);
-
-            float[] results = new float[numVectors];
-            MemorySegment.copy(resultSegment, ValueLayout.JAVA_FLOAT, 0, results, 0, numVectors);
-            return results;
-        }
-    }
-
-    /** CPU SIMD brute-force fallback. */
-    private float[] searchCpu(float[] query) {
-        float[] results = new float[numVectors];
-        int laneCount = SPECIES.length();
-        int simdBound = SPECIES.loopBound(dimensions);
-
-        // Precompute query norm
-        FloatVector qNormAcc = FloatVector.zero(SPECIES);
-        int d = 0;
-        for (; d < simdBound; d += laneCount) {
-            FloatVector qv = FloatVector.fromArray(SPECIES, query, d);
-            qNormAcc = qv.fma(qv, qNormAcc);
-        }
-        float queryNormSq = qNormAcc.reduceLanes(VectorOperators.ADD);
-        for (; d < dimensions; d++) queryNormSq += query[d] * query[d];
-        float queryNorm = (float) Math.sqrt(queryNormSq);
-        if (queryNorm == 0) return results;
-
-        for (int i = 0; i < numVectors; i++) {
-            int offset = i * dimensions;
-            FloatVector dotAcc = FloatVector.zero(SPECIES);
-            FloatVector normAcc = FloatVector.zero(SPECIES);
-            d = 0;
-            for (; d < simdBound; d += laneCount) {
-                FloatVector qv = FloatVector.fromArray(SPECIES, query, d);
-                FloatVector dv = FloatVector.fromArray(SPECIES, cpuDatabase, offset + d);
-                dotAcc = qv.fma(dv, dotAcc);
-                normAcc = dv.fma(dv, normAcc);
-            }
-            float dot = dotAcc.reduceLanes(VectorOperators.ADD);
-            float docNormSq = normAcc.reduceLanes(VectorOperators.ADD);
-            for (; d < dimensions; d++) {
-                dot += query[d] * cpuDatabase[offset + d];
-                docNormSq += cpuDatabase[offset + d] * cpuDatabase[offset + d];
-            }
-            float docNorm = (float) Math.sqrt(docNormSq);
-            results[i] = docNorm > 0 ? dot / (queryNorm * docNorm) : 0;
-        }
-        return results;
-    }
-
-    /** Returns true if GPU is active for this index. */
-    public boolean isGpuActive() { return gpuActive; }
-
-    /** Returns the number of vectors stored. */
-    public int size() { return numVectors; }
-
-    @Override
-    public void close() {
-        if (!closed) {
-            closed = true;
-            if (gpuActive && arena != null) {
-                try {
-                    // Free device memory via cuMemFree
-                    Linker linker = Linker.nativeLinker();
-                    String libName = System.getProperty("os.name").toLowerCase().contains("win") ? "nvcuda" : "cuda";
-                    try (Arena localArena = Arena.ofConfined()) {
-                        SymbolLookup lib = SymbolLookup.libraryLookup(libName, localArena);
-                        MethodHandle cuMemFree = linker.downcallHandle(
-                                lib.find("cuMemFree_v2").orElseThrow(),
-                                FunctionDescriptor.of(ValueLayout.JAVA_INT, ValueLayout.JAVA_LONG));
-                        cuMemFree.invoke(dDatabase);
-                        cuMemFree.invoke(dResults);
-                        cuMemFree.invoke(dQuery);
-                    }
-                } catch (Throwable e) {
-                    log.warn("Error freeing GPU memory: {}", e.getMessage());
-                }
-                arena.close();
-                log.info("GpuVectorIndex closed — {} vectors freed from VRAM", numVectors);
-            }
-        }
-    }
-}
diff --git a/spector-gpu/src/main/java/com/spectrayan/spector/gpu/LeakCandidate.java b/spector-gpu/src/main/java/com/spectrayan/spector/gpu/LeakCandidate.java
index 3e53eee..a6be430 100644
--- a/spector-gpu/src/main/java/com/spectrayan/spector/gpu/LeakCandidate.java
+++ b/spector-gpu/src/main/java/com/spectrayan/spector/gpu/LeakCandidate.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.gpu;
 
 import java.time.Duration;
diff --git a/spector-gpu/src/main/java/com/spectrayan/spector/gpu/PanamaMemoryDetector.java b/spector-gpu/src/main/java/com/spectrayan/spector/gpu/PanamaMemoryDetector.java
index efa886a..c1ad505 100644
--- a/spector-gpu/src/main/java/com/spectrayan/spector/gpu/PanamaMemoryDetector.java
+++ b/spector-gpu/src/main/java/com/spectrayan/spector/gpu/PanamaMemoryDetector.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.gpu;
 
 import java.lang.foreign.MemorySegment;
@@ -25,8 +10,6 @@
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-import com.spectrayan.spector.commons.error.ErrorCode;
 
 /**
  * Detects potential memory leaks in Panama FFM MemorySegment allocations by
@@ -89,11 +72,12 @@ public PanamaMemoryDetector() {
      *
      * @param lifetimeThreshold threshold beyond which a segment is reported as a leak candidate;
      *                          minimum value is 1 second
-     * @throws SpectorValidationException if threshold is less than 1 second
+     * @throws IllegalArgumentException if threshold is less than 1 second
      */
     public PanamaMemoryDetector(Duration lifetimeThreshold) {
         if (lifetimeThreshold == null || lifetimeThreshold.compareTo(MIN_THRESHOLD) < 0) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_OUT_OF_RANGE, "lifetimeThreshold", 1, Integer.MAX_VALUE, lifetimeThreshold);
+            throw new IllegalArgumentException(
+                    "Lifetime threshold must be at least 1 second, got: " + lifetimeThreshold);
         }
         this.lifetimeThreshold = lifetimeThreshold;
         this.activeSegments = new ConcurrentHashMap<>();
diff --git a/spector-gpu/src/main/java/com/spectrayan/spector/gpu/SimilarityKernel.java b/spector-gpu/src/main/java/com/spectrayan/spector/gpu/SimilarityKernel.java
index 53761c7..07ad28d 100644
--- a/spector-gpu/src/main/java/com/spectrayan/spector/gpu/SimilarityKernel.java
+++ b/spector-gpu/src/main/java/com/spectrayan/spector/gpu/SimilarityKernel.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.gpu;
 
 /**
@@ -41,7 +26,7 @@ public interface SimilarityKernel {
      * @param numVectors number of database vectors (batch size)
      * @param dimensions vector dimensionality (must be a multiple of 32, range 32–2048)
      * @return array of {@code numVectors} similarity scores
-     * @throws SpectorValidationException if dimensions or batch size are invalid
+     * @throws IllegalArgumentException if dimensions or batch size are invalid
      */
     float[] compute(float[] query, float[] database, int numVectors, int dimensions);
 
diff --git a/spector-gpu/src/main/resources/kernels/batch_cosine.cu b/spector-gpu/src/main/resources/kernels/batch_cosine.cu
deleted file mode 100644
index 3a477c4..0000000
--- a/spector-gpu/src/main/resources/kernels/batch_cosine.cu
+++ /dev/null
@@ -1,33 +0,0 @@
-/**
- * CUDA kernel for batch cosine similarity computation.
- * Each thread computes cosine(query, database[tid]) for one database vector.
- *
- * Compile: nvcc -ptx -arch=sm_80 batch_cosine.cu -o batch_cosine.ptx
- */
-extern "C" __global__ void batch_cosine(
-    const float* __restrict__ query,
-    const float* __restrict__ database,
-    float* __restrict__ results,
-    int numVectors,
-    int dimensions
-) {
-    int tid = blockIdx.x * blockDim.x + threadIdx.x;
-    if (tid >= numVectors) return;
-
-    const float* dbVec = database + (long long)tid * dimensions;
-
-    float dot = 0.0f;
-    float normQ = 0.0f;
-    float normD = 0.0f;
-
-    for (int d = 0; d < dimensions; d++) {
-        float q = query[d];
-        float v = dbVec[d];
-        dot += q * v;
-        normQ += q * q;
-        normD += v * v;
-    }
-
-    float denom = sqrtf(normQ * normD);
-    results[tid] = (denom > 0.0f) ? (dot / denom) : 0.0f;
-}
diff --git a/spector-gpu/src/main/resources/kernels/batch_cosine.cubin b/spector-gpu/src/main/resources/kernels/batch_cosine.cubin
deleted file mode 100644
index aa0cfb2..0000000
Binary files a/spector-gpu/src/main/resources/kernels/batch_cosine.cubin and /dev/null differ
diff --git a/spector-gpu/src/main/resources/kernels/batch_cosine.ptx b/spector-gpu/src/main/resources/kernels/batch_cosine.ptx
deleted file mode 100644
index ca790ef..0000000
--- a/spector-gpu/src/main/resources/kernels/batch_cosine.ptx
+++ /dev/null
@@ -1,87 +0,0 @@
-.version 8.5
-.target sm_89
-.address_size 64
-
-.visible .entry batch_cosine(
-    .param .u64 param_query,
-    .param .u64 param_database,
-    .param .u64 param_results,
-    .param .u32 param_n,
-    .param .u32 param_dims
-)
-{
-    .reg .pred %p<2>;
-    .reg .f32 %f<8>;
-    .reg .b32 %r<8>;
-    .reg .b64 %rd<9>;
-
-    // tid = blockIdx.x * blockDim.x + threadIdx.x
-    mov.u32 %r0, %ctaid.x;
-    mov.u32 %r1, %ntid.x;
-    mov.u32 %r2, %tid.x;
-    mad.lo.s32 %r3, %r0, %r1, %r2;
-
-    // Load n, bounds check
-    ld.param.u32 %r4, [param_n];
-    setp.ge.u32 %p0, %r3, %r4;
-    @%p0 bra $L_end;
-
-    // Load pointers and dims
-    ld.param.u64 %rd0, [param_query];
-    ld.param.u64 %rd1, [param_database];
-    ld.param.u64 %rd2, [param_results];
-    ld.param.u32 %r5, [param_dims];
-
-    // db_ptr = database + tid * dims * 4
-    mul.lo.s32 %r6, %r3, %r5;
-    mul.wide.s32 %rd3, %r6, 4;
-    add.s64 %rd1, %rd1, %rd3;
-
-    // Init accumulators: dot=0, normQ=0, normD=0
-    mov.f32 %f0, 0f00000000;
-    mov.f32 %f1, 0f00000000;
-    mov.f32 %f2, 0f00000000;
-
-    // Loop: d = 0 .. dims-1
-    mov.u32 %r7, 0;
-$L_loop:
-    setp.ge.u32 %p1, %r7, %r5;
-    @%p1 bra $L_done;
-
-    // offset = d * 4
-    mul.wide.u32 %rd4, %r7, 4;
-
-    // Load query[d]
-    add.s64 %rd5, %rd0, %rd4;
-    ld.global.f32 %f3, [%rd5];
-
-    // Load database[tid*dims + d]
-    add.s64 %rd6, %rd1, %rd4;
-    ld.global.f32 %f4, [%rd6];
-
-    // dot += q*d, normQ += q*q, normD += d*d
-    fma.rn.f32 %f0, %f3, %f4, %f0;
-    fma.rn.f32 %f1, %f3, %f3, %f1;
-    fma.rn.f32 %f2, %f4, %f4, %f2;
-
-    add.u32 %r7, %r7, 1;
-    bra.uni $L_loop;
-
-$L_done:
-    // denom = sqrt(normQ * normD)
-    mul.f32 %f5, %f1, %f2;
-    sqrt.approx.f32 %f6, %f5;
-
-    // result = (denom > 0) ? dot/denom : 0
-    setp.gt.f32 %p1, %f6, 0f00000000;
-    mov.f32 %f7, 0f00000000;
-    @%p1 div.approx.f32 %f7, %f0, %f6;
-
-    // Store results[tid]
-    mul.wide.u32 %rd7, %r3, 4;
-    add.s64 %rd8, %rd2, %rd7;
-    st.global.f32 [%rd8], %f7;
-
-$L_end:
-    ret;
-}
diff --git a/spector-gpu/src/test/java/com/spectrayan/spector/gpu/BatchGpuSearcherTest.java b/spector-gpu/src/test/java/com/spectrayan/spector/gpu/BatchGpuSearcherTest.java
index 465c210..456925a 100644
--- a/spector-gpu/src/test/java/com/spectrayan/spector/gpu/BatchGpuSearcherTest.java
+++ b/spector-gpu/src/test/java/com/spectrayan/spector/gpu/BatchGpuSearcherTest.java
@@ -1,24 +1,5 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.gpu;
 
-import com.spectrayan.spector.commons.error.SpectorException;
-
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-
 import java.time.Duration;
 import java.util.ArrayList;
 import java.util.List;
@@ -66,37 +47,37 @@ void tearDown() {
 
     @Test
     void constructor_rejectsNullKernel() {
-        assertThrows(SpectorValidationException.class, () ->
+        assertThrows(IllegalArgumentException.class, () ->
                 new BatchGpuSearcher(null, memoryManager, Duration.ofMillis(10), 1024));
     }
 
     @Test
     void constructor_rejectsNullMemoryManager() {
-        assertThrows(SpectorValidationException.class, () ->
+        assertThrows(IllegalArgumentException.class, () ->
                 new BatchGpuSearcher(stubKernel, null, Duration.ofMillis(10), 1024));
     }
 
     @Test
     void constructor_rejectsWindowBelowMinimum() {
-        assertThrows(SpectorValidationException.class, () ->
+        assertThrows(IllegalArgumentException.class, () ->
                 new BatchGpuSearcher(stubKernel, memoryManager, Duration.ofMillis(0), 1024));
     }
 
     @Test
     void constructor_rejectsWindowAboveMaximum() {
-        assertThrows(SpectorValidationException.class, () ->
+        assertThrows(IllegalArgumentException.class, () ->
                 new BatchGpuSearcher(stubKernel, memoryManager, Duration.ofMillis(101), 1024));
     }
 
     @Test
     void constructor_rejectsBatchSizeZero() {
-        assertThrows(SpectorValidationException.class, () ->
+        assertThrows(IllegalArgumentException.class, () ->
                 new BatchGpuSearcher(stubKernel, memoryManager, Duration.ofMillis(10), 0));
     }
 
     @Test
     void constructor_rejectsBatchSizeAboveMax() {
-        assertThrows(SpectorValidationException.class, () ->
+        assertThrows(IllegalArgumentException.class, () ->
                 new BatchGpuSearcher(stubKernel, memoryManager, Duration.ofMillis(10), 1025));
     }
 
@@ -282,7 +263,7 @@ void batchSearch_throwsWhenClosed() {
         float[] database = createDatabase(NUM_VECTORS, DIMENSIONS);
         float[] query = createQuery(DIMENSIONS, 1.0f);
 
-        assertThrows(SpectorException.class, () ->
+        assertThrows(IllegalStateException.class, () ->
                 searcher.batchSearch(List.of(query), database, NUM_VECTORS, DIMENSIONS, 5));
     }
 
@@ -291,14 +272,14 @@ void batchSearch_throwsWhenClosed() {
     @Test
     void batchSearch_rejectsNullQueries() {
         float[] database = createDatabase(NUM_VECTORS, DIMENSIONS);
-        assertThrows(SpectorValidationException.class, () ->
+        assertThrows(IllegalArgumentException.class, () ->
                 searcher.batchSearch(null, database, NUM_VECTORS, DIMENSIONS, 5));
     }
 
     @Test
     void batchSearch_rejectsNullDatabase() {
         float[] query = createQuery(DIMENSIONS, 1.0f);
-        assertThrows(SpectorValidationException.class, () ->
+        assertThrows(IllegalArgumentException.class, () ->
                 searcher.batchSearch(List.of(query), null, NUM_VECTORS, DIMENSIONS, 5));
     }
 
@@ -307,9 +288,9 @@ void batchSearch_rejectsInvalidTopK() {
         float[] database = createDatabase(NUM_VECTORS, DIMENSIONS);
         float[] query = createQuery(DIMENSIONS, 1.0f);
 
-        assertThrows(SpectorValidationException.class, () ->
+        assertThrows(IllegalArgumentException.class, () ->
                 searcher.batchSearch(List.of(query), database, NUM_VECTORS, DIMENSIONS, 0));
-        assertThrows(SpectorValidationException.class, () ->
+        assertThrows(IllegalArgumentException.class, () ->
                 searcher.batchSearch(List.of(query), database, NUM_VECTORS, DIMENSIONS, 1001));
     }
 
@@ -317,7 +298,7 @@ void batchSearch_rejectsInvalidTopK() {
     void batchSearch_rejectsNegativeDimensions() {
         float[] database = createDatabase(NUM_VECTORS, DIMENSIONS);
         float[] query = createQuery(DIMENSIONS, 1.0f);
-        assertThrows(SpectorValidationException.class, () ->
+        assertThrows(IllegalArgumentException.class, () ->
                 searcher.batchSearch(List.of(query), database, NUM_VECTORS, -1, 5));
     }
 
diff --git a/spector-gpu/src/test/java/com/spectrayan/spector/gpu/CudaCosineKernelTest.java b/spector-gpu/src/test/java/com/spectrayan/spector/gpu/CudaCosineKernelTest.java
index dd52a2d..80769fc 100644
--- a/spector-gpu/src/test/java/com/spectrayan/spector/gpu/CudaCosineKernelTest.java
+++ b/spector-gpu/src/test/java/com/spectrayan/spector/gpu/CudaCosineKernelTest.java
@@ -1,22 +1,5 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.gpu;
 
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertInstanceOf;
@@ -241,7 +224,7 @@ void compute_dimensionsTooSmall_throws() {
         float[] query = new float[16];
         float[] database = new float[16];
 
-        assertThrows(SpectorValidationException.class,
+        assertThrows(IllegalArgumentException.class,
                 () -> kernel.compute(query, database, 1, 16));
     }
 
@@ -250,7 +233,7 @@ void compute_dimensionsTooLarge_throws() {
         float[] query = new float[4096];
         float[] database = new float[4096];
 
-        assertThrows(SpectorValidationException.class,
+        assertThrows(IllegalArgumentException.class,
                 () -> kernel.compute(query, database, 1, 4096));
     }
 
@@ -259,13 +242,13 @@ void compute_dimensionsNotMultipleOf32_throws() {
         float[] query = new float[64];
         float[] database = new float[64];
 
-        assertThrows(SpectorValidationException.class,
+        assertThrows(IllegalArgumentException.class,
                 () -> kernel.compute(query, database, 1, 48));
     }
 
     @Test
     void compute_nullQuery_throws() {
-        assertThrows(SpectorValidationException.class,
+        assertThrows(IllegalArgumentException.class,
                 () -> kernel.compute(null, new float[32], 1, 32));
     }
 
diff --git a/spector-gpu/src/test/java/com/spectrayan/spector/gpu/CudaDotProductKernelTest.java b/spector-gpu/src/test/java/com/spectrayan/spector/gpu/CudaDotProductKernelTest.java
index 0e7ed5b..bf6ef8f 100644
--- a/spector-gpu/src/test/java/com/spectrayan/spector/gpu/CudaDotProductKernelTest.java
+++ b/spector-gpu/src/test/java/com/spectrayan/spector/gpu/CudaDotProductKernelTest.java
@@ -1,24 +1,5 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.gpu;
 
-import com.spectrayan.spector.commons.error.SpectorException;
-
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-
 import org.junit.jupiter.api.AfterEach;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
@@ -130,7 +111,7 @@ void compute_dimensionsTooSmall_throws() {
         float[] query = new float[16];
         float[] database = new float[16];
 
-        assertThrows(SpectorValidationException.class,
+        assertThrows(IllegalArgumentException.class,
                 () -> kernel.compute(query, database, 1, 16));
     }
 
@@ -139,7 +120,7 @@ void compute_dimensionsTooLarge_throws() {
         float[] query = new float[4096];
         float[] database = new float[4096];
 
-        assertThrows(SpectorValidationException.class,
+        assertThrows(IllegalArgumentException.class,
                 () -> kernel.compute(query, database, 1, 4096));
     }
 
@@ -148,31 +129,31 @@ void compute_dimensionsNotMultipleOf32_throws() {
         float[] query = new float[64];
         float[] database = new float[64];
 
-        assertThrows(SpectorValidationException.class,
+        assertThrows(IllegalArgumentException.class,
                 () -> kernel.compute(query, database, 1, 48));
     }
 
     @Test
     void compute_nullQuery_throws() {
-        assertThrows(SpectorValidationException.class,
+        assertThrows(IllegalArgumentException.class,
                 () -> kernel.compute(null, new float[32], 1, 32));
     }
 
     @Test
     void compute_nullDatabase_throws() {
-        assertThrows(SpectorValidationException.class,
+        assertThrows(IllegalArgumentException.class,
                 () -> kernel.compute(new float[32], null, 1, 32));
     }
 
     @Test
     void compute_negativeBatchSize_throws() {
-        assertThrows(SpectorValidationException.class,
+        assertThrows(IllegalArgumentException.class,
                 () -> kernel.compute(new float[32], new float[32], -1, 32));
     }
 
     @Test
     void compute_batchSizeTooLarge_throws() {
-        assertThrows(SpectorValidationException.class,
+        assertThrows(IllegalArgumentException.class,
                 () -> kernel.compute(new float[32], new float[32], 1_000_001, 32));
     }
 
@@ -181,7 +162,7 @@ void compute_queryTooShort_throws() {
         float[] query = new float[16]; // shorter than dims=32
         float[] database = new float[32];
 
-        assertThrows(SpectorValidationException.class,
+        assertThrows(IllegalArgumentException.class,
                 () -> kernel.compute(query, database, 1, 32));
     }
 
@@ -190,7 +171,7 @@ void compute_databaseTooShort_throws() {
         float[] query = new float[32];
         float[] database = new float[32]; // 1 vector, but asking for 2
 
-        assertThrows(SpectorValidationException.class,
+        assertThrows(IllegalArgumentException.class,
                 () -> kernel.compute(query, database, 2, 32));
     }
 
@@ -293,7 +274,7 @@ void implementsSimilarityKernel() {
     @Test
     void close_preventsSubsequentCompute() {
         kernel.close();
-        assertThrows(SpectorException.class,
+        assertThrows(IllegalStateException.class,
                 () -> kernel.compute(new float[32], new float[32], 1, 32));
     }
 
diff --git a/spector-gpu/src/test/java/com/spectrayan/spector/gpu/CudaKernelLauncherTest.java b/spector-gpu/src/test/java/com/spectrayan/spector/gpu/CudaKernelLauncherTest.java
index 0fe9224..acf2dfa 100644
--- a/spector-gpu/src/test/java/com/spectrayan/spector/gpu/CudaKernelLauncherTest.java
+++ b/spector-gpu/src/test/java/com/spectrayan/spector/gpu/CudaKernelLauncherTest.java
@@ -1,90 +1,46 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.gpu;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertNotNull;
-import static org.junit.jupiter.api.Assumptions.assumeTrue;
 import org.junit.jupiter.api.Test;
 
+import static org.junit.jupiter.api.Assertions.*;
+
 /**
  * Tests for {@link CudaKernelLauncher}.
  *
- * <p>Tests that require a working GPU kernel pipeline are skipped when
- * CUDA is unavailable or when the PTX kernel cannot be loaded (e.g., wrong
- * compute capability, missing CUDA Toolkit). This ensures the tests pass
- * cleanly on CI runners without GPUs.</p>
+ * <p>Tests run regardless of CUDA availability —
+ * they validate the API contract and error handling.</p>
  */
 class CudaKernelLauncherTest {
 
-    /**
-     * Tries to create a launcher. Returns null if CUDA is unavailable or the PTX
-     * cannot be loaded (e.g., GPU architecture mismatch, missing CUDA Toolkit).
-     */
-    private static CudaKernelLauncher tryCreateLauncher() {
-        try {
-            return new CudaKernelLauncher();
-        } catch (RuntimeException e) {
-            return null;
-        }
-    }
-
     @Test
-    void constructor_throwsOrSucceeds() {
-        // If the GPU is reported as unavailable by capability detection,
-        // the constructor should throw. If the driver is present but the PTX
-        // can't load (architecture mismatch, no toolkit), it should also throw
-        // but with RuntimeException. Either way, the test validates the contract.
-        if (!GpuCapability.isAvailable()) {
-            // No CUDA driver at all — constructor should refuse early
-            try {
-                new CudaKernelLauncher().close();
-            } catch (RuntimeException expected) {
-                // Both are acceptable: ISE for "no CUDA", RE for initialization failure
+    void constructor_throwsWhenCudaUnavailable() {
+        if (GpuCapability.isAvailable()) {
+            // CUDA available — constructor should succeed
+            try (var launcher = new CudaKernelLauncher()) {
+                assertFalse(launcher.isModuleLoaded());
             }
         } else {
-            // CUDA driver present — constructor may succeed or fail with RE
-            // if PTX doesn't match the GPU architecture
-            CudaKernelLauncher launcher = tryCreateLauncher();
-            if (launcher != null) {
-                assertNotNull(launcher);
-                launcher.close();
-            }
-            // If null, the PTX couldn't load — not a test failure
+            // CUDA unavailable — constructor should throw
+            assertThrows(IllegalStateException.class, CudaKernelLauncher::new);
         }
     }
 
     @Test
-    void batchCosine_emptyInput() {
-        CudaKernelLauncher launcher = tryCreateLauncher();
-        assumeTrue(launcher != null, "Skipping: CUDA kernel pipeline not available");
+    void moduleLoaded_falseByDefault() {
+        if (!GpuCapability.isAvailable()) return; // skip if no CUDA
 
-        try (launcher) {
-            float[] result = launcher.batchCosine(new float[384], new float[0], 0, 384);
-            assertNotNull(result);
-            assertEquals(0, result.length);
+        try (var launcher = new CudaKernelLauncher()) {
+            assertFalse(launcher.isModuleLoaded());
         }
     }
 
     @Test
-    void close_isIdempotent() {
-        CudaKernelLauncher launcher = tryCreateLauncher();
-        assumeTrue(launcher != null, "Skipping: CUDA kernel pipeline not available");
+    void getFunction_throwsWithoutModule() {
+        if (!GpuCapability.isAvailable()) return; // skip if no CUDA
 
-        launcher.close();
-        launcher.close(); // should not throw
+        try (var launcher = new CudaKernelLauncher()) {
+            assertThrows(IllegalStateException.class,
+                    () -> launcher.getFunction("nonexistent"));
+        }
     }
 }
diff --git a/spector-gpu/src/test/java/com/spectrayan/spector/gpu/GpuBatchSimilarityTest.java b/spector-gpu/src/test/java/com/spectrayan/spector/gpu/GpuBatchSimilarityTest.java
index 66af72a..f77e49d 100644
--- a/spector-gpu/src/test/java/com/spectrayan/spector/gpu/GpuBatchSimilarityTest.java
+++ b/spector-gpu/src/test/java/com/spectrayan/spector/gpu/GpuBatchSimilarityTest.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.gpu;
 
 import org.junit.jupiter.api.Test;
diff --git a/spector-gpu/src/test/java/com/spectrayan/spector/gpu/GpuCapabilityTest.java b/spector-gpu/src/test/java/com/spectrayan/spector/gpu/GpuCapabilityTest.java
index b0318e2..b01ab24 100644
--- a/spector-gpu/src/test/java/com/spectrayan/spector/gpu/GpuCapabilityTest.java
+++ b/spector-gpu/src/test/java/com/spectrayan/spector/gpu/GpuCapabilityTest.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.gpu;
 
 import org.junit.jupiter.api.Test;
diff --git a/spector-gpu/src/test/java/com/spectrayan/spector/gpu/GpuMemoryManagerTest.java b/spector-gpu/src/test/java/com/spectrayan/spector/gpu/GpuMemoryManagerTest.java
index 18111d1..5a8f16a 100644
--- a/spector-gpu/src/test/java/com/spectrayan/spector/gpu/GpuMemoryManagerTest.java
+++ b/spector-gpu/src/test/java/com/spectrayan/spector/gpu/GpuMemoryManagerTest.java
@@ -1,26 +1,5 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.gpu;
 
-import com.spectrayan.spector.commons.error.SpectorException;
-
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-
-import com.spectrayan.spector.gpu.error.SpectorGpuMemoryException;
-
 import java.lang.foreign.Arena;
 import java.lang.foreign.MemorySegment;
 
@@ -60,7 +39,7 @@ void tearDown() {
 
     @Test
     void constructor_rejectsBudgetBelowMinimum() {
-        assertThrows(SpectorValidationException.class, () ->
+        assertThrows(IllegalArgumentException.class, () ->
                 new GpuMemoryManager(100L * 1024 * 1024)); // 100MB < 256MB minimum
     }
 
@@ -105,7 +84,7 @@ void allocateDevice_multipleAllocationsAccumulate() {
     @Test
     void allocateDevice_rejectsZeroSize() {
         try (Arena arena = Arena.ofConfined()) {
-            assertThrows(SpectorValidationException.class, () ->
+            assertThrows(IllegalArgumentException.class, () ->
                     manager.allocateDevice(0, arena));
         }
     }
@@ -113,7 +92,7 @@ void allocateDevice_rejectsZeroSize() {
     @Test
     void allocateDevice_rejectsNegativeSize() {
         try (Arena arena = Arena.ofConfined()) {
-            assertThrows(SpectorValidationException.class, () ->
+            assertThrows(IllegalArgumentException.class, () ->
                     manager.allocateDevice(-1, arena));
         }
     }
@@ -125,7 +104,7 @@ void allocateDevice_enforceBudget() {
             manager.allocateDevice(500L * 1024 * 1024, arena);
 
             // This should exceed budget
-            assertThrows(SpectorGpuMemoryException.class, () ->
+            assertThrows(GpuMemoryException.class, () ->
                     manager.allocateDevice(50L * 1024 * 1024, arena));
         }
     }
@@ -135,7 +114,7 @@ void allocateDevice_budgetExceptionContainsDetails() {
         try (Arena arena = Arena.ofConfined()) {
             manager.allocateDevice(500L * 1024 * 1024, arena);
 
-            SpectorGpuMemoryException ex = assertThrows(SpectorGpuMemoryException.class, () ->
+            GpuMemoryException ex = assertThrows(GpuMemoryException.class, () ->
                     manager.allocateDevice(50L * 1024 * 1024, arena));
 
             assertEquals(50L * 1024 * 1024, ex.getRequestedBytes());
@@ -181,7 +160,7 @@ void allocatePinned_enforceBudget() {
         try (Arena arena = Arena.ofConfined()) {
             manager.allocateDevice(500L * 1024 * 1024, arena);
 
-            assertThrows(SpectorGpuMemoryException.class, () ->
+            assertThrows(GpuMemoryException.class, () ->
                     manager.allocatePinned(50L * 1024 * 1024, arena));
         }
     }
@@ -233,7 +212,7 @@ void close_releasesAllAllocations() {
     void close_rejectsSubsequentAllocations() {
         manager.close();
         try (Arena arena = Arena.ofConfined()) {
-            assertThrows(SpectorException.class, () ->
+            assertThrows(IllegalStateException.class, () ->
                     manager.allocateDevice(1024, arena));
         }
     }
diff --git a/spector-gpu/src/test/java/com/spectrayan/spector/gpu/PanamaMemoryDetectorTest.java b/spector-gpu/src/test/java/com/spectrayan/spector/gpu/PanamaMemoryDetectorTest.java
index e3b350e..08ea368 100644
--- a/spector-gpu/src/test/java/com/spectrayan/spector/gpu/PanamaMemoryDetectorTest.java
+++ b/spector-gpu/src/test/java/com/spectrayan/spector/gpu/PanamaMemoryDetectorTest.java
@@ -1,22 +1,5 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.gpu;
 
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-
 import java.lang.foreign.Arena;
 import java.lang.foreign.MemorySegment;
 import java.time.Duration;
@@ -40,14 +23,14 @@ void defaultThresholdIs300Seconds() {
     @Test
     void rejectsThresholdBelowOneSecond() {
         assertThatThrownBy(() -> new PanamaMemoryDetector(Duration.ofMillis(500)))
-                .isInstanceOf(SpectorValidationException.class)
-                .hasMessageContaining("lifetimeThreshold");
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessageContaining("at least 1 second");
     }
 
     @Test
     void rejectsNullThreshold() {
         assertThatThrownBy(() -> new PanamaMemoryDetector(null))
-                .isInstanceOf(SpectorValidationException.class);
+                .isInstanceOf(IllegalArgumentException.class);
     }
 
     @Test
diff --git a/spector-index/README.md b/spector-index/README.md
deleted file mode 100644
index 8cf3072..0000000
--- a/spector-index/README.md
+++ /dev/null
@@ -1,52 +0,0 @@
-# spector-index 🔢
-
-> **Core indexing engine of Spector: HNSW, IVF, Product Quantization (PQ), and BM25.**
-
-`spector-index` houses the algorithmic core of both keyword and semantic searches. It includes standard and quantized HNSW graphs, coarse Centroid Voronoi Partitioners (IVF), Product Quantizers, and a pure-Java high-speed BM25 postings index.
-
----
-
-## 🏗️ Core Architecture & Packages
-
-### 1. `com.spectrayan.spector.index.hnsw` 🕸️
-Implements Hierarchical Navigable Small World (HNSW) graphs. Supports:
-- **Standard HNSW:** Float32 exact search.
-- **Quantized HNSW:** Asymmetric Distance Computation (ADC) graph traversal using low-level bit-packed INT8, INT4, and INT2 scalar quantization strategy bindings.
-
-### 2. `com.spectrayan.spector.index.spectrum` 🌀
-Home of **SpectorIndex**, our flagship adaptive shard index. It implements a multi-level coarse-routing structure:
-- **Level 1 (IVF):** centoids learned via K-Means++. Routings computed in absolute coordinate space.
-- **Level 2 (SpectorShard):** Each Voronoi cell is flat when small, automatically promoted to a local quantized HNSW graph once it exceeds a size threshold. Stores vectors as tight high-precision residual coordinates (`r = x - c`) quantized with 132-bit SVASQ.
-
-### 3. `com.spectrayan.spector.index.ivf` & `pq` 🗜️
-Product Quantization algorithms that divide vector dimensions into orthogonal subspaces and learn codebooks via K-Means++, enabling **32× memory compression** for billion-scale datasets.
-
-### 4. `com.spectrayan.spector.index.text` 📄
-A pure Java, concurrent BM25 keyword search index utilizing lock-free posting lists, virtual threads, and advanced term frequency saturation configurations.
-
----
-
-## 🚀 Key APIs
-
-### Creating a Quantized HNSW Index
-```java
-HnswParams params = new HnswParams(16, 200, 50); // M, efConstruction, efSearch
-QuantizedHnswIndex index = new QuantizedHnswIndex(dimensions, capacity, params, QuantizationType.SCALAR_INT8);
-
-index.add("doc-123", 123, vector);
-ScoredResult[] results = index.search(queryVector, 10);
-```
-
-### SpectorIndex (IVF-HNSW-SVASQ) builder
-```java
-SpectorIndex spector = SpectorIndex.builder()
-    .dimensions(384)
-    .nCentroids(256)
-    .nProbe(16)
-    .shardThreshold(10_000)
-    .similarityFunction(SimilarityFunction.COSINE)
-    .build();
-
-spector.train(trainingSample);
-spector.add("doc-1", 1, vector);
-```
diff --git a/spector-index/pom.xml b/spector-index/pom.xml
index 679e799..8a3a11a 100644
--- a/spector-index/pom.xml
+++ b/spector-index/pom.xml
@@ -6,7 +6,7 @@
 
     <parent>
         <groupId>com.spectrayan</groupId>
-        <artifactId>spector</artifactId>
+        <artifactId>spector-search</artifactId>
         <version>0.1.0-SNAPSHOT</version>
     </parent>
 
@@ -19,10 +19,6 @@
             <groupId>com.spectrayan</groupId>
             <artifactId>spector-core</artifactId>
         </dependency>
-        <dependency>
-            <groupId>com.spectrayan</groupId>
-            <artifactId>spector-config</artifactId>
-        </dependency>
         <dependency>
             <groupId>com.spectrayan</groupId>
             <artifactId>spector-storage</artifactId>
@@ -31,11 +27,6 @@
             <groupId>com.spectrayan</groupId>
             <artifactId>spector-commons</artifactId>
         </dependency>
-        <dependency>
-            <groupId>com.spectrayan</groupId>
-            <artifactId>spector-embed-ollama</artifactId>
-            <scope>test</scope>
-        </dependency>
     </dependencies>
 
 </project>
diff --git a/spector-index/src/main/java/com/spectrayan/spector/index/ScoredResult.java b/spector-index/src/main/java/com/spectrayan/spector/index/ScoredResult.java
index f075fe3..15e46ff 100644
--- a/spector-index/src/main/java/com/spectrayan/spector/index/ScoredResult.java
+++ b/spector-index/src/main/java/com/spectrayan/spector/index/ScoredResult.java
@@ -1,21 +1,6 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.index;
 
-import com.spectrayan.spector.core.similarity.SimilarityFunction;
+import com.spectrayan.spector.core.SimilarityFunction;
 
 /**
  * A scored search result from a vector or keyword index.
diff --git a/spector-index/src/main/java/com/spectrayan/spector/index/VectorIndex.java b/spector-index/src/main/java/com/spectrayan/spector/index/VectorIndex.java
index 1dbd59a..9bcf10e 100644
--- a/spector-index/src/main/java/com/spectrayan/spector/index/VectorIndex.java
+++ b/spector-index/src/main/java/com/spectrayan/spector/index/VectorIndex.java
@@ -1,21 +1,6 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.index;
 
-import com.spectrayan.spector.core.similarity.SimilarityFunction;
+import com.spectrayan.spector.core.SimilarityFunction;
 
 /**
  * Interface for a vector similarity index.
diff --git a/spector-index/src/main/java/com/spectrayan/spector/index/VectorIndexFactory.java b/spector-index/src/main/java/com/spectrayan/spector/index/VectorIndexFactory.java
deleted file mode 100644
index 091e3db..0000000
--- a/spector-index/src/main/java/com/spectrayan/spector/index/VectorIndexFactory.java
+++ /dev/null
@@ -1,209 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.index;
-
-import com.spectrayan.spector.config.HnswParams;
-import com.spectrayan.spector.config.IndexType;
-import com.spectrayan.spector.config.SpectorConfig;
-import com.spectrayan.spector.core.quantization.QuantizationType;
-import com.spectrayan.spector.index.ivf.IvfPqIndex;
-import com.spectrayan.spector.index.spectrum.SpectorIndex;
-import com.spectrayan.spector.storage.VectorStore;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-/**
- * Factory Method pattern for creating {@link VectorIndex} instances.
- *
- * <p>Centralizes the index creation logic. New index types can be added
- * by extending this class or adding a case to the factory method —
- * without modifying the engine itself (Open/Closed Principle).</p>
- *
- * <h3>Supported Index Types</h3>
- * <ul>
- *   <li>{@link IndexType#HNSW} — Standard or quantized HNSW graph index</li>
- *   <li>{@link IndexType#IVF_PQ} — Inverted file with product quantization</li>
- *   <li>{@link IndexType#SPECTRUM} — Adaptive IVF + SVASQ-HNSW hybrid index</li>
- * </ul>
- */
-public class VectorIndexFactory {
-
-    private static final Logger log = LoggerFactory.getLogger(VectorIndexFactory.class);
-
-    /**
-     * Creates a {@link VectorIndex} based on the engine configuration.
-     *
-     * <p>If GPU is enabled with INT4 or INT2 quantization but the vector dimensions
-     * are not a multiple of 32, GPU acceleration is disabled for this index and a
-     * warning is logged. The index will fall back to CPU/SIMD computation.</p>
-     *
-     * @param config the engine configuration
-     * @return a new, empty vector index
-     */
-    public VectorIndex create(SpectorConfig config) {
-        return create(config, null);
-    }
-
-    /**
-     * Creates a {@link VectorIndex} with an optional {@link VectorStore} backing.
-     *
-     * <p>When a VectorStore is provided, HNSW indexes will read vectors from it
-     * during graph traversal instead of keeping heap-resident copies. This
-     * eliminates O(capacity × dims × 4) bytes of heap overhead.</p>
-     *
-     * @param config      the engine configuration
-     * @param vectorStore optional off-heap vector store (null = inline mode)
-     * @return a new, empty vector index
-     */
-    public VectorIndex create(SpectorConfig config, VectorStore vectorStore) {
-        SpectorConfig effectiveConfig = applyGpuFallbackIfNeeded(config);
-        return switch (effectiveConfig.indexType()) {
-            case HNSW -> createHnsw(effectiveConfig, vectorStore);
-            case IVF_PQ -> createIvfPq(effectiveConfig);
-            case SPECTRUM -> createSpectrum(effectiveConfig);
-        };
-    }
-
-    /**
-     * Checks whether GPU must be disabled due to non-aligned dimensions for INT4/INT2.
-     *
-     * <p>GPU-accelerated distance computation for INT4 and INT2 packed formats requires
-     * vector dimensions to be a multiple of 32. When this alignment requirement is not met,
-     * this method disables GPU and returns a modified config that falls back to CPU/SIMD.</p>
-     *
-     * @param config the original engine configuration
-     * @return the config with GPU disabled if fallback is needed, otherwise the original config
-     */
-    SpectorConfig applyGpuFallbackIfNeeded(SpectorConfig config) {
-        if (!config.gpuEnabled()) {
-            return config;
-        }
-
-        QuantizationType quantization = config.quantization();
-        if (quantization != QuantizationType.SCALAR_INT4 && quantization != QuantizationType.SCALAR_INT2) {
-            return config;
-        }
-
-        if (config.dimensions() % 32 != 0) {
-            log.warn("GPU acceleration disabled for {} quantization: vector dimensions {} "
-                            + "are not a multiple of 32. Falling back to CPU/SIMD computation.",
-                    quantization, config.dimensions());
-            return config.withGpu(false);
-        }
-
-        return config;
-    }
-
-    /**
-     * Creates an HNSW-based index, optionally with scalar quantization.
-     */
-    private VectorIndex createHnsw(SpectorConfig config, VectorStore vectorStore) {
-        QuantizationType qt = config.quantization();
-
-        if (qt == QuantizationType.SVASQ) {
-            int oversampling = config.effectiveOversamplingFactor();
-            log.info("Creating QuantizedHnswIndex (SVASQ): dims={}, capacity={}, oversampling={}",
-                    config.dimensions(), config.capacity(), oversampling);
-            return QuantizedHnswIndex.svasq(
-                    config.dimensions(), config.capacity(),
-                    config.similarityFunction(), config.hnswParams(), oversampling);
-        }
-
-        if (qt == QuantizationType.SVASQ_4) {
-            int oversampling = config.effectiveOversamplingFactor();
-            log.info("Creating QuantizedHnswIndex (SVASQ-4): dims={}, capacity={}, oversampling={}",
-                    config.dimensions(), config.capacity(), oversampling);
-            return QuantizedHnswIndex.svasq4(
-                    config.dimensions(), config.capacity(),
-                    config.similarityFunction(), config.hnswParams(), oversampling);
-        }
-
-        if (qt == QuantizationType.SCALAR_INT8) {
-            log.info("Creating QuantizedHnswIndex (SQ8): dims={}, capacity={}",
-                    config.dimensions(), config.capacity());
-            return new QuantizedHnswIndex(
-                    config.dimensions(), config.capacity(),
-                    config.similarityFunction(), config.hnswParams());
-        }
-
-        if (qt == QuantizationType.SCALAR_INT4 || qt == QuantizationType.SCALAR_INT2) {
-            int effectiveOversampling = config.effectiveOversamplingFactor();
-            log.info("Creating QuantizedHnswIndex ({}): dims={}, capacity={}, oversampling={}",
-                    qt, config.dimensions(), config.capacity(), effectiveOversampling);
-            return new QuantizedHnswIndex(
-                    config.dimensions(), config.capacity(),
-                    config.similarityFunction(), config.hnswParams(),
-                    null, qt, null, effectiveOversampling);
-        }
-
-        if (vectorStore != null) {
-            log.info("Creating HnswIndex (store-backed): dims={}, capacity={}",
-                    config.dimensions(), config.capacity());
-            return new HnswIndex(
-                    config.dimensions(), config.capacity(),
-                    config.similarityFunction(), config.hnswParams(), vectorStore);
-        }
-
-        log.info("Creating HnswIndex: dims={}, capacity={}", config.dimensions(), config.capacity());
-        return new HnswIndex(
-                config.dimensions(), config.capacity(),
-                config.similarityFunction(), config.hnswParams());
-    }
-
-    /**
-     * Creates an IVF-PQ index (untrained — training happens during ingestion).
-     */
-    private VectorIndex createIvfPq(SpectorConfig config) {
-        log.info("Creating IvfPqIndex: dims={}, nlist={}, nprobe={}, M={}",
-                config.dimensions(), config.effectiveNlist(),
-                config.effectiveNprobe(), config.effectivePqSubspaces());
-        return new IvfPqIndex(
-                config.dimensions(),
-                config.effectiveNlist(),
-                config.effectiveNprobe(),
-                config.effectivePqSubspaces(),
-                config.similarityFunction());
-    }
-
-    /**
-     * Creates a Spectrum index (untrained — training happens during ingestion).
-     *
-     * <p>Spectrum is the adaptive IVF + SVASQ-HNSW hybrid. It requires a training step
-     * with representative vectors before use (like IVF-PQ). The engine's ingestion
-     * pipeline should call {@link SpectorIndex#train(float[][])} before adding vectors.</p>
-     */
-    private VectorIndex createSpectrum(SpectorConfig config) {
-        int nCentroids = config.effectiveSpectrumNCentroids();
-        int nProbe = config.effectiveSpectrumNProbe();
-        int shardThreshold = config.effectiveSpectrumShardThreshold();
-        int oversampling = config.effectiveOversamplingFactor();
-
-        log.info("Creating SpectorIndex (Spectrum): dims={}, nCentroids={}, nProbe={}, "
-                        + "shardThreshold={}, oversampling={}",
-                config.dimensions(), nCentroids, nProbe, shardThreshold, oversampling);
-
-        return SpectorIndex.builder()
-                .dimensions(config.dimensions())
-                .nCentroids(nCentroids)
-                .nProbe(nProbe)
-                .shardThreshold(shardThreshold)
-                .oversamplingFactor(oversampling)
-                .similarityFunction(config.similarityFunction())
-                .hnswParams(config.hnswParams())
-                .build();
-    }
-}
diff --git a/spector-index/src/main/java/com/spectrayan/spector/index/error/SpectorBm25TokenizationException.java b/spector-index/src/main/java/com/spectrayan/spector/index/error/SpectorBm25TokenizationException.java
deleted file mode 100644
index e5369a9..0000000
--- a/spector-index/src/main/java/com/spectrayan/spector/index/error/SpectorBm25TokenizationException.java
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.index.error;
-
-import com.spectrayan.spector.commons.error.*;
-
-/**
- * Exception thrown when BM25 text tokenization fails.
- *
- * @see SpectorIndexException
- */
-public class SpectorBm25TokenizationException extends SpectorIndexException {
-
-    private final String details;
-
-    public SpectorBm25TokenizationException(String details) {
-        super(ErrorCode.BM25_TOKENIZATION_FAILED, details);
-        this.details = details;
-    }
-
-    public SpectorBm25TokenizationException(String details, Throwable cause) {
-        super(ErrorCode.BM25_TOKENIZATION_FAILED, cause, details);
-        this.details = details;
-    }
-
-    /** Returns the details of the tokenization failure. */
-    public String getDetails() {
-        return details;
-    }
-}
diff --git a/spector-index/src/main/java/com/spectrayan/spector/index/error/SpectorHnswBuildException.java b/spector-index/src/main/java/com/spectrayan/spector/index/error/SpectorHnswBuildException.java
deleted file mode 100644
index d30b94b..0000000
--- a/spector-index/src/main/java/com/spectrayan/spector/index/error/SpectorHnswBuildException.java
+++ /dev/null
@@ -1,48 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.index.error;
-
-import com.spectrayan.spector.commons.error.*;
-
-/**
- * Exception thrown when parallel HNSW index construction fails.
- *
- * <p>This indicates that a virtual thread encountered an unrecoverable error
- * during parallel construction. The partial graph is discarded.</p>
- *
- * @see SpectorIndexException
- */
-public class SpectorHnswBuildException extends SpectorIndexException {
-
-    /**
-     * Creates a new build exception.
-     *
-     * @param message description of the failure
-     */
-    public SpectorHnswBuildException(String message) {
-        super(ErrorCode.HNSW_BUILD_FAILED, message);
-    }
-
-    /**
-     * Creates a new build exception with a cause.
-     *
-     * @param message description of the failure
-     * @param cause   the underlying cause
-     */
-    public SpectorHnswBuildException(String message, Throwable cause) {
-        super(ErrorCode.HNSW_BUILD_FAILED, cause, message);
-    }
-}
diff --git a/spector-index/src/main/java/com/spectrayan/spector/index/error/SpectorIndexFullException.java b/spector-index/src/main/java/com/spectrayan/spector/index/error/SpectorIndexFullException.java
deleted file mode 100644
index f0457a7..0000000
--- a/spector-index/src/main/java/com/spectrayan/spector/index/error/SpectorIndexFullException.java
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.index.error;
-
-import com.spectrayan.spector.commons.error.*;
-
-/**
- * Exception thrown when the index has reached its maximum document capacity.
- *
- * @see SpectorIndexException
- */
-public class SpectorIndexFullException extends SpectorIndexException {
-
-    private final int maxCapacity;
-
-    public SpectorIndexFullException(int maxCapacity) {
-        super(ErrorCode.INDEX_FULL, maxCapacity);
-        this.maxCapacity = maxCapacity;
-    }
-
-    public SpectorIndexFullException(int maxCapacity, Throwable cause) {
-        super(ErrorCode.INDEX_FULL, cause, maxCapacity);
-        this.maxCapacity = maxCapacity;
-    }
-
-    /** Returns the maximum capacity of the index. */
-    public int getMaxCapacity() {
-        return maxCapacity;
-    }
-}
diff --git a/spector-index/src/main/java/com/spectrayan/spector/index/error/SpectorIndexIntegrityException.java b/spector-index/src/main/java/com/spectrayan/spector/index/error/SpectorIndexIntegrityException.java
deleted file mode 100644
index 70166f7..0000000
--- a/spector-index/src/main/java/com/spectrayan/spector/index/error/SpectorIndexIntegrityException.java
+++ /dev/null
@@ -1,35 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.index.error;
-
-import com.spectrayan.spector.commons.error.*;
-
-/**
- * Exception thrown when an index integrity check detects corruption or
- * violation of structural invariants.
- *
- * @see SpectorIndexException
- */
-public class SpectorIndexIntegrityException extends SpectorIndexException {
-
-    public SpectorIndexIntegrityException(String message) {
-        super(ErrorCode.HNSW_GRAPH_CORRUPTED, message);
-    }
-
-    public SpectorIndexIntegrityException(String message, Throwable cause) {
-        super(ErrorCode.HNSW_GRAPH_CORRUPTED, cause, message);
-    }
-}
diff --git a/spector-index/src/main/java/com/spectrayan/spector/index/error/SpectorIndexReadOnlyException.java b/spector-index/src/main/java/com/spectrayan/spector/index/error/SpectorIndexReadOnlyException.java
deleted file mode 100644
index 41fdfd1..0000000
--- a/spector-index/src/main/java/com/spectrayan/spector/index/error/SpectorIndexReadOnlyException.java
+++ /dev/null
@@ -1,34 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.index.error;
-
-import com.spectrayan.spector.commons.error.*;
-
-/**
- * Exception thrown when a write operation is attempted on a read-only index.
- *
- * @see SpectorIndexException
- */
-public class SpectorIndexReadOnlyException extends SpectorIndexException {
-
-    public SpectorIndexReadOnlyException() {
-        super(ErrorCode.INDEX_READ_ONLY);
-    }
-
-    public SpectorIndexReadOnlyException(Throwable cause) {
-        super(ErrorCode.INDEX_READ_ONLY, cause);
-    }
-}
diff --git a/spector-index/src/main/java/com/spectrayan/spector/index/error/SpectorIvfTrainingException.java b/spector-index/src/main/java/com/spectrayan/spector/index/error/SpectorIvfTrainingException.java
deleted file mode 100644
index 70e0038..0000000
--- a/spector-index/src/main/java/com/spectrayan/spector/index/error/SpectorIvfTrainingException.java
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.index.error;
-
-import com.spectrayan.spector.commons.error.*;
-
-/**
- * Exception thrown when IVF centroid training fails during calibration.
- *
- * @see SpectorIndexException
- */
-public class SpectorIvfTrainingException extends SpectorIndexException {
-
-    private final String details;
-
-    public SpectorIvfTrainingException(String details) {
-        super(ErrorCode.IVF_TRAINING_FAILED, details);
-        this.details = details;
-    }
-
-    public SpectorIvfTrainingException(String details, Throwable cause) {
-        super(ErrorCode.IVF_TRAINING_FAILED, cause, details);
-        this.details = details;
-    }
-
-    /** Returns the details of the IVF training failure. */
-    public String getDetails() {
-        return details;
-    }
-}
diff --git a/spector-index/src/main/java/com/spectrayan/spector/index/fuzz/FuzzConfig.java b/spector-index/src/main/java/com/spectrayan/spector/index/fuzz/FuzzConfig.java
index db31fa1..2f63842 100644
--- a/spector-index/src/main/java/com/spectrayan/spector/index/fuzz/FuzzConfig.java
+++ b/spector-index/src/main/java/com/spectrayan/spector/index/fuzz/FuzzConfig.java
@@ -1,24 +1,7 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.index.fuzz;
 
 import java.nio.file.Path;
 import java.util.List;
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-import com.spectrayan.spector.commons.error.ErrorCode;
 
 /**
  * Configuration for an index fuzz testing run.
@@ -38,13 +21,13 @@ public record FuzzConfig(
 ) {
     public FuzzConfig {
         if (minOperations < 10_000) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_OUT_OF_RANGE, "minOperations", 10000, Integer.MAX_VALUE, minOperations);
+            throw new IllegalArgumentException("minOperations must be at least 10,000, got " + minOperations);
         }
         if (targetIndexes == null || targetIndexes.isEmpty()) {
-            throw new SpectorValidationException(ErrorCode.EMPTY_COLLECTION, "targetIndexes");
+            throw new IllegalArgumentException("targetIndexes must not be empty");
         }
         if (dimensions < 2) {
-            throw new SpectorValidationException(ErrorCode.DIMENSIONS_INVALID, dimensions);
+            throw new IllegalArgumentException("dimensions must be at least 2, got " + dimensions);
         }
     }
 
diff --git a/spector-index/src/main/java/com/spectrayan/spector/index/fuzz/FuzzFailure.java b/spector-index/src/main/java/com/spectrayan/spector/index/fuzz/FuzzFailure.java
index 370ba86..60bd5a9 100644
--- a/spector-index/src/main/java/com/spectrayan/spector/index/fuzz/FuzzFailure.java
+++ b/spector-index/src/main/java/com/spectrayan/spector/index/fuzz/FuzzFailure.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.index.fuzz;
 
 /**
diff --git a/spector-index/src/main/java/com/spectrayan/spector/index/fuzz/FuzzOperation.java b/spector-index/src/main/java/com/spectrayan/spector/index/fuzz/FuzzOperation.java
index 036ae2e..2dd4e20 100644
--- a/spector-index/src/main/java/com/spectrayan/spector/index/fuzz/FuzzOperation.java
+++ b/spector-index/src/main/java/com/spectrayan/spector/index/fuzz/FuzzOperation.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.index.fuzz;
 
 /**
diff --git a/spector-index/src/main/java/com/spectrayan/spector/index/fuzz/FuzzReport.java b/spector-index/src/main/java/com/spectrayan/spector/index/fuzz/FuzzReport.java
index 7a3d4b1..f1addb9 100644
--- a/spector-index/src/main/java/com/spectrayan/spector/index/fuzz/FuzzReport.java
+++ b/spector-index/src/main/java/com/spectrayan/spector/index/fuzz/FuzzReport.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.index.fuzz;
 
 import java.time.Duration;
diff --git a/spector-index/src/main/java/com/spectrayan/spector/index/fuzz/IndexFuzzTester.java b/spector-index/src/main/java/com/spectrayan/spector/index/fuzz/IndexFuzzTester.java
index 079d9ef..0614784 100644
--- a/spector-index/src/main/java/com/spectrayan/spector/index/fuzz/IndexFuzzTester.java
+++ b/spector-index/src/main/java/com/spectrayan/spector/index/fuzz/IndexFuzzTester.java
@@ -1,22 +1,5 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.index.fuzz;
 
-import com.spectrayan.spector.index.error.SpectorIndexIntegrityException;
-
 import java.io.IOException;
 import java.io.PrintWriter;
 import java.io.StringWriter;
@@ -35,9 +18,9 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import com.spectrayan.spector.core.similarity.SimilarityFunction;
+import com.spectrayan.spector.core.SimilarityFunction;
 import com.spectrayan.spector.index.HnswIndex;
-import com.spectrayan.spector.config.HnswParams;
+import com.spectrayan.spector.index.HnswParams;
 import com.spectrayan.spector.index.ivf.IvfFlatIndex;
 
 /**
@@ -399,14 +382,14 @@ private void verifyHnswIntegrity() {
         for (int i = 0; i < nodeCount; i++) {
             int[] neighbors = hnswIndex.getNeighborsAtLayer(i, 0);
             if (neighbors == null || neighbors.length == 0) {
-                throw new SpectorIndexIntegrityException(
+                throw new IndexIntegrityException(
                         "HNSW node " + i + " has no neighbors at layer 0 (nodeCount=" + nodeCount + ")");
             }
 
             // Check neighbor indices are valid
             for (int neighbor : neighbors) {
                 if (neighbor < 0 || neighbor >= nodeCount) {
-                    throw new SpectorIndexIntegrityException(
+                    throw new IndexIntegrityException(
                             "HNSW node " + i + " has invalid neighbor index " + neighbor
                                     + " (nodeCount=" + nodeCount + ")");
                 }
@@ -415,7 +398,7 @@ private void verifyHnswIntegrity() {
             // Check max connections constraint
             int maxConn = hnswIndex.params().maxLevel0Connections();
             if (neighbors.length > maxConn) {
-                throw new SpectorIndexIntegrityException(
+                throw new IndexIntegrityException(
                         "HNSW node " + i + " has " + neighbors.length
                                 + " neighbors at layer 0, exceeding max " + maxConn);
             }
@@ -425,7 +408,7 @@ private void verifyHnswIntegrity() {
     private void verifyIvfIntegrity() {
         int reportedSize = ivfIndex.size();
         if (reportedSize != ivfInsertCount) {
-            throw new SpectorIndexIntegrityException(
+            throw new IndexIntegrityException(
                     "IVF reported size " + reportedSize + " != expected " + ivfInsertCount);
         }
     }
diff --git a/spector-index/src/main/java/com/spectrayan/spector/index/fuzz/IndexIntegrityException.java b/spector-index/src/main/java/com/spectrayan/spector/index/fuzz/IndexIntegrityException.java
new file mode 100644
index 0000000..209ba74
--- /dev/null
+++ b/spector-index/src/main/java/com/spectrayan/spector/index/fuzz/IndexIntegrityException.java
@@ -0,0 +1,16 @@
+package com.spectrayan.spector.index.fuzz;
+
+/**
+ * Exception thrown when an index integrity check detects corruption or
+ * violation of structural invariants.
+ */
+public class IndexIntegrityException extends RuntimeException {
+
+    public IndexIntegrityException(String message) {
+        super(message);
+    }
+
+    public IndexIntegrityException(String message, Throwable cause) {
+        super(message, cause);
+    }
+}
diff --git a/spector-index/src/main/java/com/spectrayan/spector/index/fuzz/IndexType.java b/spector-index/src/main/java/com/spectrayan/spector/index/fuzz/IndexType.java
index ad92698..f51ec62 100644
--- a/spector-index/src/main/java/com/spectrayan/spector/index/fuzz/IndexType.java
+++ b/spector-index/src/main/java/com/spectrayan/spector/index/fuzz/IndexType.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.index.fuzz;
 
 /**
diff --git a/spector-index/src/main/java/com/spectrayan/spector/index/hnsw/AbstractHnswIndex.java b/spector-index/src/main/java/com/spectrayan/spector/index/hnsw/AbstractHnswIndex.java
index a9efb31..bcf0594 100644
--- a/spector-index/src/main/java/com/spectrayan/spector/index/hnsw/AbstractHnswIndex.java
+++ b/spector-index/src/main/java/com/spectrayan/spector/index/hnsw/AbstractHnswIndex.java
@@ -1,35 +1,14 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.index;
 
+import com.spectrayan.spector.core.SimilarityFunction;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
-import com.spectrayan.spector.config.HnswParams;
 import java.util.Arrays;
 import java.util.BitSet;
 import java.util.concurrent.ThreadLocalRandom;
 import java.util.concurrent.locks.ReentrantLock;
-import java.util.concurrent.locks.ReentrantReadWriteLock;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import com.spectrayan.spector.core.similarity.SimilarityFunction;
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-import com.spectrayan.spector.index.error.SpectorIndexFullException;
-import com.spectrayan.spector.commons.error.ErrorCode;
 
 /**
  * Abstract base class for HNSW (Hierarchical Navigable Small World) indexes.
@@ -59,9 +38,6 @@ public abstract class AbstractHnswIndex implements VectorIndex {
 
     private static final Logger log = LoggerFactory.getLogger(AbstractHnswIndex.class);
 
-    /** Shared empty neighbor array — Flyweight to avoid per-call {@code new int[0]} allocations. */
-    private static final int[] EMPTY_NEIGHBORS = new int[0];
-
     protected final HnswParams params;
     protected final SimilarityFunction similarityFunction;
     protected final int dimensions;
@@ -80,38 +56,7 @@ public abstract class AbstractHnswIndex implements VectorIndex {
     protected volatile int maxLevel = -1;
 
     // ── Concurrency ──
-    protected final ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
-    protected final ReentrantReadWriteLock.WriteLock writeLock = rwLock.writeLock();
-    protected final ReentrantReadWriteLock.ReadLock readLock = rwLock.readLock();
-
-    // ── Pre-allocated scratch for addConnection() pruning (accessed under writeLock only) ──
-    //
-    // addConnection() is always called under writeLock (from add()), so only ONE thread
-    // accesses these arrays at a time. A plain instance field is correct — no ThreadLocal needed.
-    //
-    // Size = max(maxLevel0Connections, m) + 2 covers all pruning cases:
-    //   layer 0: at most maxLevel0Connections current neighbors + 1 new = maxLevel0Connections + 1
-    //   upper:   at most m current neighbors + 1 new = m + 1
-    private final float[] pruneScores;
-    private final int[]   pruneIndices;
-
-    // ── Pre-allocated unvisited buffer for searchLayer() (per-thread via ThreadLocal) ──
-    //
-    // searchLayer() is called from:
-    //   add()    — under writeLock (single writer, serialized)
-    //   search() — under readLock  (concurrent readers, each needs its own buffer)
-    //
-    // ThreadLocal gives each virtual thread its own buffer, eliminating the per-call
-    // allocation AND the Arrays.copyOf fallback that occurred when the buffer was too small.
-    // Buffer size = max(maxLevel0Connections, m) * 2 covers the realistic worst case.
-    private final ThreadLocal<int[]> unvisitedBufLocal;
-
-    // ── Per-thread BitSet for searchLayer() — avoids per-call allocation ──
-    //
-    // searchLayer() needs a visited set. BitSet internally allocates a long[nodeCount/64].
-    // By reusing a ThreadLocal BitSet (cleared between calls), we eliminate that allocation
-    // on every search. The BitSet auto-grows if nodeCount increases between calls.
-    protected final ThreadLocal<BitSet> visitedBitSetLocal = ThreadLocal.withInitial(BitSet::new);
+    protected final ReentrantLock writeLock = new ReentrantLock();
 
     /**
      * Creates the HNSW graph structure.
@@ -134,15 +79,6 @@ protected AbstractHnswIndex(int dimensions, int capacity,
         this.neighbors = new int[capacity][];
         this.upperNeighbors = new int[capacity][][];
         this.nodeLevels = new int[capacity];
-
-        // Pre-allocated pruning scratch for addConnection() — sized for the larger of the two maxConn values
-        int maxPruneSize = Math.max(params.maxLevel0Connections(), params.m()) + 2;
-        this.pruneScores  = new float[maxPruneSize];
-        this.pruneIndices = new int[maxPruneSize];
-
-        // Per-thread unvisited buffer for searchLayer() — prevents per-search allocation
-        final int unvisitedInitSize = Math.max(params.maxLevel0Connections(), params.m()) * 2;
-        this.unvisitedBufLocal = ThreadLocal.withInitial(() -> new int[unvisitedInitSize]);
     }
 
     // ─────────────── Template methods (subclass hooks) ───────────────
@@ -177,26 +113,18 @@ protected AbstractHnswIndex(int dimensions, int capacity,
      */
     protected abstract void storeVector(int nodeIdx, float[] vector);
 
-    /**
-     * Returns the float32 vector for the given node.
-     *
-     * @param nodeIdx the internal node index
-     * @return the stored float32 vector
-     */
-    public abstract float[] getVector(int nodeIdx);
-
     // ─────────────── VectorIndex implementation ───────────────
 
     @Override
     public void add(String id, int storeIndex, float[] vector) {
         if (vector.length != dimensions) {
-            throw new SpectorValidationException(ErrorCode.DIMENSIONS_MISMATCH, dimensions, vector.length);
+            throw new IllegalArgumentException("Expected " + dimensions + " dims, got " + vector.length);
         }
 
         writeLock.lock();
         try {
             if (nodeCount >= capacity) {
-                throw new SpectorIndexFullException(capacity);
+                throw new IllegalStateException("Index is full: capacity=" + capacity);
             }
 
             int nodeIdx = nodeCount;
@@ -206,11 +134,11 @@ public void add(String id, int storeIndex, float[] vector) {
             ids[nodeIdx] = id;
             storeIndices[nodeIdx] = storeIndex;
             nodeLevels[nodeIdx] = level;
-            neighbors[nodeIdx] = EMPTY_NEIGHBORS;
+            neighbors[nodeIdx] = new int[0];
             if (level > 0) {
                 upperNeighbors[nodeIdx] = new int[level][];
                 for (int l = 0; l < level; l++) {
-                    upperNeighbors[nodeIdx][l] = EMPTY_NEIGHBORS;
+                    upperNeighbors[nodeIdx][l] = new int[0];
                 }
             }
 
@@ -265,109 +193,35 @@ public void add(String id, int storeIndex, float[] vector) {
         }
     }
 
-    /**
-     * Bulk-loads a pre-built node with its existing graph connections.
-     *
-     * <p>Used for restoring a persisted HNSW index into writable mode.
-     * Unlike {@link #add}, this does <b>not</b> rebuild connections — it directly
-     * sets the neighbor arrays from the persisted graph structure. This is O(1)
-     * per node vs O(log N) for a normal add, enabling fast startup.</p>
-     *
-     * <p>Must be called in node-index order (0, 1, 2, ...) to preserve the graph
-     * structure. After all nodes are loaded, call {@link #restoreGraphState} to
-     * set the entry point and max level.</p>
-     *
-     * @param id                 document ID
-     * @param storeIndex         VectorStore index for this node
-     * @param vector             the float32 vector (stored via subclass hook)
-     * @param level              the HNSW level for this node
-     * @param layer0Neighbors    layer-0 neighbor indices
-     * @param upperLayerNeighbors upper-layer neighbor arrays (may be empty/null)
-     */
-    public void addPrebuilt(String id, int storeIndex, float[] vector,
-                            int level, int[] layer0Neighbors, int[][] upperLayerNeighbors) {
-        writeLock.lock();
-        try {
-            if (nodeCount >= capacity) {
-                throw new SpectorIndexFullException(capacity);
-            }
-
-            int nodeIdx = nodeCount;
-
-            // Store node metadata
-            ids[nodeIdx] = id;
-            storeIndices[nodeIdx] = storeIndex;
-            nodeLevels[nodeIdx] = level;
-            neighbors[nodeIdx] = layer0Neighbors != null ? layer0Neighbors : EMPTY_NEIGHBORS;
-            if (level > 0 && upperLayerNeighbors != null) {
-                this.upperNeighbors[nodeIdx] = upperLayerNeighbors;
-            } else if (level > 0) {
-                this.upperNeighbors[nodeIdx] = new int[level][];
-                for (int l = 0; l < level; l++) {
-                    this.upperNeighbors[nodeIdx][l] = EMPTY_NEIGHBORS;
-                }
-            }
-
-            // Delegate vector storage to subclass
-            storeVector(nodeIdx, vector);
-
-            nodeCount++;
-        } finally {
-            writeLock.unlock();
-        }
-    }
-
-    /**
-     * Restores the graph entry point and max level after bulk-loading via
-     * {@link #addPrebuilt}.
-     *
-     * @param entryPoint the HNSW entry point node index
-     * @param maxLevel   the HNSW maximum level
-     */
-    public void restoreGraphState(int entryPoint, int maxLevel) {
-        writeLock.lock();
-        try {
-            this.entryPoint = entryPoint;
-            this.maxLevel = maxLevel;
-        } finally {
-            writeLock.unlock();
-        }
-    }
-
     @Override
     public ScoredResult[] search(float[] query, int k) {
         if (query.length != dimensions) {
-            throw new SpectorValidationException(ErrorCode.DIMENSIONS_MISMATCH, dimensions, query.length);
+            throw new IllegalArgumentException("Expected " + dimensions + " dims, got " + query.length);
         }
         if (nodeCount == 0) {
             return new ScoredResult[0];
         }
 
-        readLock.lock();
-        try {
-            int ef = Math.max(k, params.efSearch());
-            int currentNode = entryPoint;
+        int ef = Math.max(k, params.efSearch());
+        int currentNode = entryPoint;
 
-            // Phase 1: Greedy descent through upper layers
-            for (int lc = maxLevel; lc > 0; lc--) {
-                currentNode = greedyClosest(query, currentNode, lc);
-            }
+        // Phase 1: Greedy descent through upper layers
+        for (int lc = maxLevel; lc > 0; lc--) {
+            currentNode = greedyClosest(query, currentNode, lc);
+        }
 
-            // Phase 2: Search at layer 0 with ef candidates
-            NeighborQueue candidates = searchLayer(query, currentNode, ef, 0);
+        // Phase 2: Search at layer 0 with ef candidates
+        NeighborQueue candidates = searchLayer(query, currentNode, ef, 0);
 
-            // Extract top-K results
-            boolean higherIsBetter = similarityFunction.higherIsBetter();
-            ScoredResult[] results = candidates.toSortedResults(ids, higherIsBetter);
+        // Extract top-K results
+        boolean higherIsBetter = similarityFunction.higherIsBetter();
+        ScoredResult[] results = candidates.toSortedResults(ids, higherIsBetter);
 
-            // Trim to k
-            if (results.length > k) {
-                results = Arrays.copyOf(results, k);
-            }
-            return results;
-        } finally {
-            readLock.unlock();
+        // Trim to k
+        if (results.length > k) {
+            results = Arrays.copyOf(results, k);
         }
+        return results;
     }
 
     @Override
@@ -413,15 +267,10 @@ protected int greedyClosest(float[] query, int startNode, int layer) {
     /**
      * Beam search at a specific layer — returns candidates as a max-heap
      * (worst score on top for bounded eviction).
-     *
-     * <p>Optimized: batches unvisited neighbor collection before computing
-     * distances, improving cache prefetch behavior for the vector store.</p>
      */
     protected NeighborQueue searchLayer(float[] query, int entryNode, int ef, int layer) {
-        // Reuse per-thread BitSet — clear() is O(size/64) which is fast, and avoids
-        // the long[] allocation that new BitSet(nodeCount) would trigger every call.
-        BitSet visited = visitedBitSetLocal.get();
-        visited.clear();
+        int currentNodeCount = nodeCount;
+        BitSet visited = new BitSet(currentNodeCount);
         NeighborQueue candidates = new NeighborQueue(ef + 1, ef, maxHeap());
         NeighborQueue workQueue = new NeighborQueue(ef + 1, minHeap());
 
@@ -430,11 +279,6 @@ protected NeighborQueue searchLayer(float[] query, int entryNode, int ef, int la
         workQueue.add(entryNode, entryDist);
         visited.set(entryNode);
 
-        // Use the pre-allocated per-thread buffer — no allocation per call.
-        // If a node somehow has more neighbors than the buffer size (extremely unlikely
-        // with well-configured params), we fall back to a local array just that once.
-        int[] unvisitedBuf = unvisitedBufLocal.get();
-
         while (!workQueue.isEmpty()) {
             float currentDist = workQueue.topScore();
             int current = workQueue.poll();
@@ -444,30 +288,14 @@ protected NeighborQueue searchLayer(float[] query, int entryNode, int ef, int la
             }
 
             int[] nbrs = getNeighbors(current, layer);
-
-            // Batch: collect unvisited neighbors first
-            int unvisitedCount = 0;
             for (int neighbor : nbrs) {
                 if (!visited.get(neighbor)) {
                     visited.set(neighbor);
-                    if (unvisitedCount >= unvisitedBuf.length) {
-                        // Rare: node has more neighbors than our buffer. Grow the ThreadLocal buffer.
-                        int[] grown = new int[unvisitedBuf.length * 2];
-                        System.arraycopy(unvisitedBuf, 0, grown, 0, unvisitedCount);
-                        unvisitedBufLocal.set(grown);
-                        unvisitedBuf = grown;
+                    float dist = computeDistance(query, neighbor);
+                    if (candidates.size() < ef || isBetter(dist, candidates.topScore())) {
+                        candidates.add(neighbor, dist);
+                        workQueue.add(neighbor, dist);
                     }
-                    unvisitedBuf[unvisitedCount++] = neighbor;
-                }
-            }
-
-            // Compute distances for all unvisited neighbors in a tight loop
-            for (int i = 0; i < unvisitedCount; i++) {
-                int neighbor = unvisitedBuf[i];
-                float dist = computeDistance(query, neighbor);
-                if (candidates.size() < ef || isBetter(dist, candidates.topScore())) {
-                    candidates.add(neighbor, dist);
-                    workQueue.add(neighbor, dist);
                 }
             }
         }
@@ -499,49 +327,24 @@ protected void addConnection(int fromNode, int toNode, int layer, int maxConn) {
         }
 
         if (currentNeighbors.length < maxConn) {
-            // Neighbor list not yet full — extend it by one.
-            // This allocation is structurally unavoidable: the graph stores int[] per node.
             int[] newNeighbors = new int[currentNeighbors.length + 1];
             System.arraycopy(currentNeighbors, 0, newNeighbors, 0, currentNeighbors.length);
             newNeighbors[currentNeighbors.length] = toNode;
             setNeighbors(fromNode, layer, newNeighbors);
         } else {
-            // Neighbor list full: must prune. Find the best maxConn from (currentNeighbors + toNode).
-            //
-            // Uses pre-allocated pruneScores/pruneIndices instance fields (safe under writeLock).
-            // In-place insertion sort over maxConn+1 elements (typically 17 or 33) — zero allocation,
-            // O(maxConn²) = O(289) for M=16 which is negligible vs distance computation.
             float[] fromVec = getNodeVector(fromNode);
-            boolean higherIsBetter = similarityFunction.higherIsBetter();
-
-            // Fill pre-allocated scratch: score each current neighbor and the new candidate
-            int pruneSize = 0;
+            NeighborQueue queue = new NeighborQueue(maxConn + 1, false);
             for (int n : currentNeighbors) {
-                pruneScores[pruneSize]  = similarityFunction.computeForRanking(fromVec, getNodeVector(n));
-                pruneIndices[pruneSize] = n;
-                pruneSize++;
-            }
-            pruneScores[pruneSize]  = similarityFunction.computeForRanking(fromVec, getNodeVector(toNode));
-            pruneIndices[pruneSize] = toNode;
-            pruneSize++;
-
-            // In-place insertion sort: best-first order (descending for similarity, ascending for distance)
-            for (int i = 1; i < pruneSize; i++) {
-                float sc  = pruneScores[i];
-                int   idx = pruneIndices[i];
-                int j = i - 1;
-                while (j >= 0 && (higherIsBetter ? pruneScores[j] < sc : pruneScores[j] > sc)) {
-                    pruneScores[j + 1]  = pruneScores[j];
-                    pruneIndices[j + 1] = pruneIndices[j];
-                    j--;
-                }
-                pruneScores[j + 1]  = sc;
-                pruneIndices[j + 1] = idx;
+                queue.add(n, similarityFunction.compute(fromVec, getNodeVector(n)));
             }
+            queue.add(toNode, similarityFunction.compute(fromVec, getNodeVector(toNode)));
 
-            // Keep the best maxConn (the sorted head of pruneIndices)
-            int[] pruned = new int[maxConn];  // unavoidable: graph structure requires a stored int[]
-            System.arraycopy(pruneIndices, 0, pruned, 0, maxConn);
+            ScoredResult[] best = queue.toSortedResults(null, similarityFunction.higherIsBetter());
+            int keepCount = Math.min(best.length, maxConn);
+            int[] pruned = new int[keepCount];
+            for (int i = 0; i < keepCount; i++) {
+                pruned[i] = best[i].index();
+            }
             setNeighbors(fromNode, layer, pruned);
         }
     }
@@ -551,12 +354,12 @@ protected void addConnection(int fromNode, int toNode, int layer, int maxConn) {
     protected int[] getNeighbors(int nodeIdx, int layer) {
         if (layer == 0) {
             int[] n = neighbors[nodeIdx];
-            return n != null ? n : EMPTY_NEIGHBORS;
+            return n != null ? n : new int[0];
         } else {
             int[][] upper = upperNeighbors[nodeIdx];
-            if (upper == null || layer - 1 >= upper.length) return EMPTY_NEIGHBORS;
+            if (upper == null || layer - 1 >= upper.length) return new int[0];
             int[] n = upper[layer - 1];
-            return n != null ? n : EMPTY_NEIGHBORS;
+            return n != null ? n : new int[0];
         }
     }
 
diff --git a/spector-index/src/main/java/com/spectrayan/spector/index/hnsw/DiskHnswIndex.java b/spector-index/src/main/java/com/spectrayan/spector/index/hnsw/DiskHnswIndex.java
index 93609dc..060d928 100644
--- a/spector-index/src/main/java/com/spectrayan/spector/index/hnsw/DiskHnswIndex.java
+++ b/spector-index/src/main/java/com/spectrayan/spector/index/hnsw/DiskHnswIndex.java
@@ -1,21 +1,6 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.index;
 
-import com.spectrayan.spector.core.similarity.SimilarityFunction;
+import com.spectrayan.spector.core.SimilarityFunction;
 import com.spectrayan.spector.storage.IndexFileFormat;
 
 import org.slf4j.Logger;
@@ -30,8 +15,6 @@
 import java.nio.charset.StandardCharsets;
 import java.nio.file.Path;
 import java.util.BitSet;
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-import com.spectrayan.spector.commons.error.ErrorCode;
 
 /**
  * Read-only HNSW index backed by a memory-mapped file.
@@ -63,7 +46,6 @@ public class DiskHnswIndex implements VectorIndex {
     private final String[] ids;
     private final SimilarityFunction similarityFunction;
     private volatile boolean closed;
-    private volatile long lastAccessed;
 
     private DiskHnswIndex(Path filePath, IndexFileFormat.Header header,
                            Arena arena, MemorySegment segment,
@@ -78,7 +60,6 @@ private DiskHnswIndex(Path filePath, IndexFileFormat.Header header,
         this.ids = ids;
         this.similarityFunction = header.similarityFunction();
         this.closed = false;
-        this.lastAccessed = System.currentTimeMillis();
     }
 
     /**
@@ -106,14 +87,13 @@ public static DiskHnswIndex open(Path indexPath) throws IOException {
         log.info("DiskHnswIndex opened: {} nodes, {} dims, file={} ({} bytes)",
                 header.nodeCount(), header.dimensions(), indexPath, fileSize);
 
-        DiskHnswIndex index = new DiskHnswIndex(indexPath, header, arena, segment, raf, channel, ids);
-        index.warmup(); // Warm up asynchronously on open
-        return index;
+        return new DiskHnswIndex(indexPath, header, arena, segment, raf, channel, ids);
     }
 
     @Override
     public void add(String id, int storeIndex, float[] vector) {
-        throw new SpectorValidationException(ErrorCode.ARGUMENT_INVALID, "DiskHnswIndex", "read-only; build with HnswIndex + DiskHnswWriter");
+        throw new UnsupportedOperationException(
+                "DiskHnswIndex is read-only. Build with HnswIndex → DiskHnswWriter.");
     }
 
     @Override
@@ -123,9 +103,9 @@ public boolean isReadOnly() {
 
     @Override
     public ScoredResult[] search(float[] query, int k) {
-        this.lastAccessed = System.currentTimeMillis();
         if (query.length != header.dimensions()) {
-            throw new SpectorValidationException(ErrorCode.DIMENSIONS_MISMATCH, header.dimensions(), query.length);
+            throw new IllegalArgumentException(
+                    "Expected " + header.dimensions() + " dims, got " + query.length);
         }
         if (header.nodeCount() == 0) {
             return new ScoredResult[0];
@@ -158,14 +138,10 @@ public ScoredResult[] search(float[] query, int k) {
     public SimilarityFunction similarityFunction() { return similarityFunction; }
 
     @Override
-    public synchronized void close() {
+    public void close() {
         if (!closed) {
             closed = true;
             try {
-                if (segment.isMapped()) {
-                    com.spectrayan.spector.commons.concurrent.MemoryPinning.unlock(segment);
-                    segment.unload();
-                }
                 arena.close();
                 channel.close();
                 raf.close();
@@ -176,52 +152,6 @@ public synchronized void close() {
         }
     }
 
-    /**
-     * Pre-touches and loads the mapped memory segment into physical memory
-     * to prevent cold-start page fault latency spikes during initial queries.
-     * Performs a best-effort asynchronous load using a virtual thread.
-     */
-    public void warmup() {
-        if (segment.isMapped()) {
-            Thread.startVirtualThread(() -> {
-                long start = System.nanoTime();
-                try {
-                    // Advise kernel to sequentially pre-read mapped segment pages
-                    com.spectrayan.spector.commons.concurrent.NativeOsMemory.advise(segment, com.spectrayan.spector.commons.concurrent.NativeOsMemory.MADV_WILLNEED);
-                    segment.load();
-                    boolean pinned = com.spectrayan.spector.commons.concurrent.MemoryPinning.lock(segment);
-                    long elapsedMs = (System.nanoTime() - start) / 1_000_000;
-                    log.info("DiskHnswIndex warmed up successfully (pinned={}) in {} ms (file={})",
-                            pinned, elapsedMs, filePath);
-                } catch (Exception e) {
-                    log.warn("Failed to warm up DiskHnswIndex: {}", e.getMessage());
-                }
-            });
-        }
-    }
-
-    /**
-     * Evicts the mapped segment pages from physical memory if it has been inactive
-     * for at least the specified grace period.
-     *
-     * @param gracePeriodMs threshold of inactivity in milliseconds
-     * @return true if successfully evicted, false if segment is active or not mapped
-     */
-    public synchronized boolean unloadIdle(long gracePeriodMs) {
-        if (!closed && segment.isMapped()) {
-            long idleMs = System.currentTimeMillis() - lastAccessed;
-            if (idleMs >= gracePeriodMs) {
-                com.spectrayan.spector.commons.concurrent.MemoryPinning.unlock(segment);
-                segment.unload();
-                // Advise kernel to immediately release the physical pages back to the system
-                com.spectrayan.spector.commons.concurrent.NativeOsMemory.advise(segment, com.spectrayan.spector.commons.concurrent.NativeOsMemory.MADV_DONTNEED);
-                log.info("DiskHnswIndex idle-evicted: file={} (idle for {} ms)", filePath, idleMs);
-                return true;
-            }
-        }
-        return false;
-    }
-
     /** Returns the file path. */
     public Path filePath() { return filePath; }
 
@@ -283,10 +213,10 @@ private NeighborQueue searchLayer(float[] query, int entryNode, int ef) {
         return candidates;
     }
 
-    // ─────────────── Mmap accessors (package-private for bulk copy) ───────────────
+    // ─────────────── Mmap accessors ───────────────
 
     /** Reads a vector from the mmap'd vector data region. */
-    public float[] readVector(int nodeIdx) {
+    private float[] readVector(int nodeIdx) {
         int dims = header.dimensions();
         float[] vector = new float[dims];
         long offset = header.vectorDataOffset() + (long) nodeIdx * dims * Float.BYTES;
@@ -295,7 +225,7 @@ public float[] readVector(int nodeIdx) {
     }
 
     /** Reads neighbor indices from the mmap'd graph data region. */
-    public int[] readNeighbors(int nodeIdx, int layer) {
+    private int[] readNeighbors(int nodeIdx, int layer) {
         long blockOffset = header.graphDataOffset()
                 + (long) nodeIdx * header.graphBlockSize();
 
@@ -329,28 +259,6 @@ public int[] readNeighbors(int nodeIdx, int layer) {
         return neighbors;
     }
 
-    /** Reads the HNSW level for the given node from the graph block. */
-    public int readLevel(int nodeIdx) {
-        long blockOffset = header.graphDataOffset()
-                + (long) nodeIdx * header.graphBlockSize();
-        return segment.get(IndexFileFormat.INT_U, blockOffset);
-    }
-
-    /** Returns the ID for the given node. */
-    public String getId(int nodeIdx) {
-        return ids[nodeIdx];
-    }
-
-    /** Returns the HNSW entry point node index. */
-    public int entryPoint() {
-        return header.entryPoint();
-    }
-
-    /** Returns the HNSW maximum level. */
-    public int maxLevel() {
-        return header.maxLevel();
-    }
-
     private float distance(float[] query, int nodeIdx) {
         float[] vector = readVector(nodeIdx);
         return similarityFunction.compute(query, vector);
diff --git a/spector-index/src/main/java/com/spectrayan/spector/index/hnsw/DiskHnswWriter.java b/spector-index/src/main/java/com/spectrayan/spector/index/hnsw/DiskHnswWriter.java
index b82d534..fb29b96 100644
--- a/spector-index/src/main/java/com/spectrayan/spector/index/hnsw/DiskHnswWriter.java
+++ b/spector-index/src/main/java/com/spectrayan/spector/index/hnsw/DiskHnswWriter.java
@@ -1,24 +1,7 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.index;
 
-
-import com.spectrayan.spector.config.HnswParams;
-import com.spectrayan.spector.core.quantization.QuantizationType;
-import com.spectrayan.spector.core.similarity.SimilarityFunction;
+import com.spectrayan.spector.core.QuantizationType;
+import com.spectrayan.spector.core.SimilarityFunction;
 import com.spectrayan.spector.storage.IndexFileFormat;
 
 import org.slf4j.Logger;
@@ -64,7 +47,7 @@ private DiskHnswWriter() {}
      * @param outputPath path to the output file (created or overwritten)
      * @throws IOException if writing fails
      */
-    public static void write(AbstractHnswIndex index, Path outputPath) throws IOException {
+    public static void write(HnswIndex index, Path outputPath) throws IOException {
         int nodeCount = index.size();
         int dimensions = index.dimensions();
         SimilarityFunction simFunc = index.similarityFunction();
diff --git a/spector-index/src/main/java/com/spectrayan/spector/index/hnsw/HnswBuildException.java b/spector-index/src/main/java/com/spectrayan/spector/index/hnsw/HnswBuildException.java
new file mode 100644
index 0000000..2af4e7c
--- /dev/null
+++ b/spector-index/src/main/java/com/spectrayan/spector/index/hnsw/HnswBuildException.java
@@ -0,0 +1,29 @@
+package com.spectrayan.spector.index;
+
+/**
+ * Exception thrown when parallel HNSW index construction fails.
+ *
+ * <p>This indicates that a virtual thread encountered an unrecoverable error
+ * during parallel construction. The partial graph is discarded.</p>
+ */
+public class HnswBuildException extends RuntimeException {
+
+    /**
+     * Creates a new build exception.
+     *
+     * @param message description of the failure
+     */
+    public HnswBuildException(String message) {
+        super(message);
+    }
+
+    /**
+     * Creates a new build exception with a cause.
+     *
+     * @param message description of the failure
+     * @param cause   the underlying cause
+     */
+    public HnswBuildException(String message, Throwable cause) {
+        super(message, cause);
+    }
+}
diff --git a/spector-index/src/main/java/com/spectrayan/spector/index/hnsw/HnswIndex.java b/spector-index/src/main/java/com/spectrayan/spector/index/hnsw/HnswIndex.java
index 37dd7c7..c3a07e5 100644
--- a/spector-index/src/main/java/com/spectrayan/spector/index/hnsw/HnswIndex.java
+++ b/spector-index/src/main/java/com/spectrayan/spector/index/hnsw/HnswIndex.java
@@ -1,24 +1,6 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.index;
 
-
-import com.spectrayan.spector.config.HnswParams;
-import com.spectrayan.spector.core.similarity.SimilarityFunction;
-import com.spectrayan.spector.storage.VectorStore;
+import com.spectrayan.spector.core.SimilarityFunction;
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -32,13 +14,8 @@
  * navigable small world graph. Distance computations delegate to the
  * SIMD-accelerated kernels in {@code spector-core}.</p>
  *
- * <h3>Vector Storage Modes</h3>
- * <ul>
- *   <li><b>VectorStore-backed</b> (preferred): vectors are read from an off-heap
- *       {@link VectorStore} during traversal — zero heap overhead per vector.</li>
- *   <li><b>Inline</b> (legacy/tests): full float32 copies stored in a heap-resident
- *       {@code float[][]} for fast distance computation.</li>
- * </ul>
+ * <p>This implementation stores full float32 vectors inline for fast
+ * distance computation during graph traversal and construction.</p>
  *
  * @see AbstractHnswIndex
  * @see QuantizedHnswIndex
@@ -47,19 +24,11 @@ public class HnswIndex extends AbstractHnswIndex {
 
     private static final Logger log = LoggerFactory.getLogger(HnswIndex.class);
 
-    // ── Vector storage: exactly one of these is non-null ──
-    private final float[][] vectors;       // inline mode (null when store-backed)
-    private final VectorStore vectorStore;  // store-backed mode (null when inline)
-
-    // ── Pre-allocated read buffer for store-backed mode (per-thread for concurrent reads) ──
-    private final ThreadLocal<float[]> readBuffer;
+    // ── Float32 vector storage (inline copy for fast distance computation) ──
+    private final float[][] vectors;
 
     /**
-     * Creates a new HNSW index with inline vector storage (original behavior).
-     *
-     * <p>Vectors are copied into a heap-resident {@code float[][]} for fast
-     * distance computation during graph traversal. Use this constructor for
-     * tests or when no VectorStore is available.</p>
+     * Creates a new HNSW index.
      *
      * @param dimensions         vector dimensionality
      * @param capacity           max number of vectors
@@ -69,41 +38,13 @@ public class HnswIndex extends AbstractHnswIndex {
     public HnswIndex(int dimensions, int capacity, SimilarityFunction similarityFunction, HnswParams params) {
         super(dimensions, capacity, similarityFunction, params);
         this.vectors = new float[capacity][];
-        this.vectorStore = null;
-        this.readBuffer = null;
-
-        log.info("HnswIndex created: dims={}, capacity={}, M={}, efC={}, efS={}, similarity={}, mode=inline",
-                dimensions, capacity, params.m(), params.efConstruction(), params.efSearch(),
-                similarityFunction);
-    }
-
-    /**
-     * Creates a new HNSW index backed by an off-heap {@link VectorStore}.
-     *
-     * <p>During graph traversal and construction, vectors are read directly from
-     * the store via {@code storeIndices[nodeIdx]} — no heap-resident vector copy
-     * is kept. This eliminates the {@code O(capacity × dims × 4)} heap overhead
-     * of the inline mode.</p>
-     *
-     * @param dimensions         vector dimensionality
-     * @param capacity           max number of vectors
-     * @param similarityFunction distance/similarity metric
-     * @param params             HNSW tuning parameters
-     * @param vectorStore        the off-heap vector store to read from
-     */
-    public HnswIndex(int dimensions, int capacity, SimilarityFunction similarityFunction,
-                     HnswParams params, VectorStore vectorStore) {
-        super(dimensions, capacity, similarityFunction, params);
-        this.vectors = null;
-        this.vectorStore = vectorStore;
-        this.readBuffer = ThreadLocal.withInitial(() -> new float[dimensions]);
 
-        log.info("HnswIndex created: dims={}, capacity={}, M={}, efC={}, efS={}, similarity={}, mode=store-backed",
+        log.info("HnswIndex created: dims={}, capacity={}, M={}, efC={}, efS={}, similarity={}",
                 dimensions, capacity, params.m(), params.efConstruction(), params.efSearch(),
                 similarityFunction);
     }
 
-    /** Creates with default params (inline mode). */
+    /** Creates with default params. */
     public HnswIndex(int dimensions, int capacity, SimilarityFunction similarityFunction) {
         this(dimensions, capacity, similarityFunction, HnswParams.DEFAULT);
     }
@@ -112,50 +53,21 @@ public HnswIndex(int dimensions, int capacity, SimilarityFunction similarityFunc
 
     @Override
     protected float computeDistance(float[] query, int nodeIdx) {
-        if (vectorStore != null) {
-            // Store-backed: read into per-thread buffer, compute distance
-            float[] buf = readBuffer.get();
-            vectorStore.getByIndex(storeIndices[nodeIdx], buf, 0);
-            return similarityFunction.compute(query, buf);
-        }
         return similarityFunction.compute(query, vectors[nodeIdx]);
     }
 
     @Override
     protected float[] getNodeVector(int nodeIdx) {
-        if (vectorStore != null) {
-            // Store-backed: must allocate since callers may hold the reference
-            return vectorStore.getByIndex(storeIndices[nodeIdx]);
-        }
         return vectors[nodeIdx];
     }
 
     @Override
     protected void storeVector(int nodeIdx, float[] vector) {
-        if (vectors != null) {
-            vectors[nodeIdx] = Arrays.copyOf(vector, vector.length);
-        }
-        // Store-backed: no-op — vector already lives in the VectorStore
+        vectors[nodeIdx] = Arrays.copyOf(vector, vector.length);
     }
 
     // ─────────────── Serialization accessor ───────────────
 
-    /**
-     * Returns the inline vector copy for the given node.
-     *
-     * <p>In store-backed mode, reads from the underlying VectorStore instead.</p>
-     */
-    public float[] getVector(int nodeIdx) {
-        if (vectorStore != null) {
-            return vectorStore.getByIndex(storeIndices[nodeIdx]);
-        }
-        return vectors[nodeIdx];
-    }
-
-    /**
-     * Returns whether this index uses store-backed vector storage (off-heap).
-     */
-    public boolean isStoreBacked() {
-        return vectorStore != null;
-    }
+    /** Returns the inline vector copy for the given node. */
+    public float[] getVector(int nodeIdx) { return vectors[nodeIdx]; }
 }
diff --git a/spector-config/src/main/java/com/spectrayan/spector/config/HnswParams.java b/spector-index/src/main/java/com/spectrayan/spector/index/hnsw/HnswParams.java
similarity index 54%
rename from spector-config/src/main/java/com/spectrayan/spector/config/HnswParams.java
rename to spector-index/src/main/java/com/spectrayan/spector/index/hnsw/HnswParams.java
index 47b2241..313db93 100644
--- a/spector-config/src/main/java/com/spectrayan/spector/config/HnswParams.java
+++ b/spector-index/src/main/java/com/spectrayan/spector/index/hnsw/HnswParams.java
@@ -1,22 +1,4 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.config;
-
-import com.spectrayan.spector.commons.error.ErrorCode;
-import com.spectrayan.spector.config.error.SpectorConfigValueException;
+package com.spectrayan.spector.index;
 
 /**
  * Configuration parameters for the HNSW (Hierarchical Navigable Small World) index.
@@ -45,9 +27,9 @@ public HnswParams(int m, int efConstruction, int efSearch) {
     }
 
     public HnswParams {
-        if (m < 2) throw new SpectorConfigValueException("m", m + " (must be >= 2)");
-        if (efConstruction < 1) throw new SpectorConfigValueException("efConstruction", efConstruction + " (must be >= 1)");
-        if (efSearch < 1) throw new SpectorConfigValueException("efSearch", efSearch + " (must be >= 1)");
+        if (m < 2) throw new IllegalArgumentException("m must be >= 2: " + m);
+        if (efConstruction < 1) throw new IllegalArgumentException("efConstruction must be >= 1");
+        if (efSearch < 1) throw new IllegalArgumentException("efSearch must be >= 1");
     }
 
     /**
diff --git a/spector-index/src/main/java/com/spectrayan/spector/index/hnsw/HnswPersistence.java b/spector-index/src/main/java/com/spectrayan/spector/index/hnsw/HnswPersistence.java
index be4c937..9a7354f 100644
--- a/spector-index/src/main/java/com/spectrayan/spector/index/hnsw/HnswPersistence.java
+++ b/spector-index/src/main/java/com/spectrayan/spector/index/hnsw/HnswPersistence.java
@@ -1,24 +1,9 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.index;
 
 import java.io.IOException;
 import java.nio.file.Path;
 
-import com.spectrayan.spector.core.similarity.SimilarityFunction;
+import com.spectrayan.spector.core.SimilarityFunction;
 
 /**
  * Interface for HNSW index binary persistence.
diff --git a/spector-index/src/main/java/com/spectrayan/spector/index/hnsw/HnswPersistenceImpl.java b/spector-index/src/main/java/com/spectrayan/spector/index/hnsw/HnswPersistenceImpl.java
index db9b3f7..2e02b99 100644
--- a/spector-index/src/main/java/com/spectrayan/spector/index/hnsw/HnswPersistenceImpl.java
+++ b/spector-index/src/main/java/com/spectrayan/spector/index/hnsw/HnswPersistenceImpl.java
@@ -1,22 +1,5 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.index;
 
-
-import com.spectrayan.spector.config.HnswParams;
 import java.io.IOException;
 import java.io.RandomAccessFile;
 import java.lang.foreign.Arena;
@@ -30,7 +13,7 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import com.spectrayan.spector.core.similarity.SimilarityFunction;
+import com.spectrayan.spector.core.SimilarityFunction;
 
 /**
  * Implementation of HNSW binary persistence format.
diff --git a/spector-index/src/main/java/com/spectrayan/spector/index/hnsw/NeighborQueue.java b/spector-index/src/main/java/com/spectrayan/spector/index/hnsw/NeighborQueue.java
index eddf42e..65936c2 100644
--- a/spector-index/src/main/java/com/spectrayan/spector/index/hnsw/NeighborQueue.java
+++ b/spector-index/src/main/java/com/spectrayan/spector/index/hnsw/NeighborQueue.java
@@ -1,24 +1,7 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.index;
 
 import java.util.Arrays;
 import java.util.Comparator;
-import com.spectrayan.spector.commons.error.SpectorInternalException;
-import com.spectrayan.spector.commons.error.ErrorCode;
 
 /**
  * A bounded priority queue for HNSW candidate tracking during search and construction.
@@ -86,19 +69,19 @@ public boolean add(int index, float score) {
 
     /** Returns the score at the top of the heap (worst in a max-heap of top-K). */
     public float topScore() {
-        if (size == 0) throw new SpectorInternalException(ErrorCode.EMPTY_COLLECTION, "queue");
+        if (size == 0) throw new IllegalStateException("Queue is empty");
         return scores[0];
     }
 
     /** Returns the index at the top of the heap. */
     public int topIndex() {
-        if (size == 0) throw new SpectorInternalException(ErrorCode.EMPTY_COLLECTION, "queue");
+        if (size == 0) throw new IllegalStateException("Queue is empty");
         return indices[0];
     }
 
     /** Removes and returns the top element. */
     public int poll() {
-        if (size == 0) throw new SpectorInternalException(ErrorCode.EMPTY_COLLECTION, "queue");
+        if (size == 0) throw new IllegalStateException("Queue is empty");
         int result = indices[0];
         size--;
         if (size > 0) {
diff --git a/spector-index/src/main/java/com/spectrayan/spector/index/hnsw/ParallelHnswBuilder.java b/spector-index/src/main/java/com/spectrayan/spector/index/hnsw/ParallelHnswBuilder.java
index 8ba95e2..1b3d644 100644
--- a/spector-index/src/main/java/com/spectrayan/spector/index/hnsw/ParallelHnswBuilder.java
+++ b/spector-index/src/main/java/com/spectrayan/spector/index/hnsw/ParallelHnswBuilder.java
@@ -1,24 +1,5 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.index;
 
-import com.spectrayan.spector.index.error.SpectorHnswBuildException;
-
-
-import com.spectrayan.spector.config.HnswParams;
 import java.util.Arrays;
 import java.util.BitSet;
 import java.util.concurrent.StructuredTaskScope;
@@ -28,9 +9,7 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import com.spectrayan.spector.core.similarity.SimilarityFunction;
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-import com.spectrayan.spector.commons.error.ErrorCode;
+import com.spectrayan.spector.core.SimilarityFunction;
 
 /**
  * Multi-threaded HNSW index builder using virtual threads.
@@ -46,7 +25,7 @@
  * <h3>Error Handling</h3>
  * If any virtual thread encounters an unrecoverable error during parallel
  * construction, the entire build is aborted, the partial graph is discarded,
- * and a {@link SpectorHnswBuildException} is thrown.
+ * and a {@link HnswBuildException} is thrown.
  *
  * @see HnswIndex
  * @see AbstractHnswIndex
@@ -69,18 +48,19 @@ public class ParallelHnswBuilder {
      * @param params             HNSW tuning parameters
      * @param similarityFunction the similarity/distance function
      * @return the constructed HNSW index
-     * @throws SpectorHnswBuildException if parallel construction fails
-     * @throws SpectorValidationException if vectors is null or empty, or dimensions are inconsistent
+     * @throws HnswBuildException if parallel construction fails
+     * @throws IllegalArgumentException if vectors is null or empty, or dimensions are inconsistent
      */
     public HnswIndex build(float[][] vectors, HnswParams params, SimilarityFunction similarityFunction) {
         if (vectors == null || vectors.length == 0) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_NULL, "Vectors array");
+            throw new IllegalArgumentException("Vectors array must not be null or empty");
         }
 
         int dimensions = vectors[0].length;
         for (int i = 1; i < vectors.length; i++) {
             if (vectors[i].length != dimensions) {
-                throw new SpectorValidationException(ErrorCode.DIMENSIONS_MISMATCH, dimensions, vectors[i].length);
+                throw new IllegalArgumentException(
+                        "Inconsistent dimensions: vector[0]=" + dimensions + ", vector[" + i + "]=" + vectors[i].length);
             }
         }
 
@@ -156,9 +136,9 @@ private HnswIndex buildParallel(float[][] vectors, HnswParams params, Similarity
             scope.join();
         } catch (InterruptedException e) {
             Thread.currentThread().interrupt();
-            throw new SpectorHnswBuildException("Parallel HNSW build interrupted", e);
+            throw new HnswBuildException("Parallel HNSW build interrupted", e);
         } catch (Exception e) {
-            throw new SpectorHnswBuildException(
+            throw new HnswBuildException(
                     "Parallel HNSW build failed: " + e.getMessage(), e);
         }
 
@@ -193,9 +173,6 @@ private int[] preComputeLevels(int n, HnswParams params) {
      */
     private static final class ParallelHnswGraph {
 
-        /** Shared empty neighbor array — Flyweight to avoid per-call allocations. */
-        private static final int[] EMPTY_NEIGHBORS = new int[0];
-
         private final int dimensions;
         private final int capacity;
         private final SimilarityFunction similarityFunction;
@@ -231,11 +208,11 @@ private static final class ParallelHnswGraph {
             // Initialize node structures and locks
             for (int i = 0; i < capacity; i++) {
                 nodeLocks[i] = new ReentrantLock();
-                neighbors[i] = EMPTY_NEIGHBORS;
+                neighbors[i] = new int[0];
                 if (levels[i] > 0) {
                     upperNeighbors[i] = new int[levels[i]][];
                     for (int l = 0; l < levels[i]; l++) {
-                        upperNeighbors[i][l] = EMPTY_NEIGHBORS;
+                        upperNeighbors[i][l] = new int[0];
                     }
                 }
             }
@@ -371,9 +348,9 @@ private void addConnectionLocked(int fromNode, int toNode, int layer, int maxCon
                     float[] fromVec = vectors[fromNode];
                     NeighborQueue queue = new NeighborQueue(maxConn + 1, false);
                     for (int n : currentNeighbors) {
-                        queue.add(n, similarityFunction.computeForRanking(fromVec, vectors[n]));
+                        queue.add(n, similarityFunction.compute(fromVec, vectors[n]));
                     }
-                    queue.add(toNode, similarityFunction.computeForRanking(fromVec, vectors[toNode]));
+                    queue.add(toNode, similarityFunction.compute(fromVec, vectors[toNode]));
 
                     ScoredResult[] best = queue.toSortedResults(null, similarityFunction.higherIsBetter());
                     int keepCount = Math.min(best.length, maxConn);
@@ -407,26 +384,26 @@ private void setNeighborsInternal(int nodeIdx, int layer, int[] nbrs) {
         private int[] getNeighbors(int nodeIdx, int layer) {
             if (layer == 0) {
                 int[] n = neighbors[nodeIdx];
-                return n != null ? n : EMPTY_NEIGHBORS;
+                return n != null ? n : new int[0];
             } else {
                 int[][] upper = upperNeighbors[nodeIdx];
-                if (upper == null || layer - 1 >= upper.length) return EMPTY_NEIGHBORS;
+                if (upper == null || layer - 1 >= upper.length) return new int[0];
                 int[] n = upper[layer - 1];
-                return n != null ? n : EMPTY_NEIGHBORS;
+                return n != null ? n : new int[0];
             }
         }
 
         /** Greedy closest node at a given layer. */
         private int greedyClosest(float[] query, int startNode, int layer) {
             int current = startNode;
-            float currentDist = similarityFunction.computeForRanking(query, vectors[current]);
+            float currentDist = similarityFunction.compute(query, vectors[current]);
             boolean improved = true;
 
             while (improved) {
                 improved = false;
                 int[] nbrs = getNeighbors(current, layer);
                 for (int neighbor : nbrs) {
-                    float dist = similarityFunction.computeForRanking(query, vectors[neighbor]);
+                    float dist = similarityFunction.compute(query, vectors[neighbor]);
                     if (isBetter(dist, currentDist)) {
                         current = neighbor;
                         currentDist = dist;
@@ -443,7 +420,7 @@ private NeighborQueue searchLayer(float[] query, int entryNode, int ef, int laye
             NeighborQueue candidates = new NeighborQueue(ef + 1, ef, maxHeap());
             NeighborQueue workQueue = new NeighborQueue(ef + 1, minHeap());
 
-            float entryDist = similarityFunction.computeForRanking(query, vectors[entryNode]);
+            float entryDist = similarityFunction.compute(query, vectors[entryNode]);
             candidates.add(entryNode, entryDist);
             workQueue.add(entryNode, entryDist);
             visited.set(entryNode);
@@ -460,7 +437,7 @@ private NeighborQueue searchLayer(float[] query, int entryNode, int ef, int laye
                 for (int neighbor : nbrs) {
                     if (!visited.get(neighbor)) {
                         visited.set(neighbor);
-                        float dist = similarityFunction.computeForRanking(query, vectors[neighbor]);
+                        float dist = similarityFunction.compute(query, vectors[neighbor]);
                         if (candidates.size() < ef || isBetter(dist, candidates.topScore())) {
                             candidates.add(neighbor, dist);
                             workQueue.add(neighbor, dist);
diff --git a/spector-index/src/main/java/com/spectrayan/spector/index/hnsw/QuantizedHnswIndex.java b/spector-index/src/main/java/com/spectrayan/spector/index/hnsw/QuantizedHnswIndex.java
index 4547569..d452ada 100644
--- a/spector-index/src/main/java/com/spectrayan/spector/index/hnsw/QuantizedHnswIndex.java
+++ b/spector-index/src/main/java/com/spectrayan/spector/index/hnsw/QuantizedHnswIndex.java
@@ -1,71 +1,35 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.index;
 
-
-import com.spectrayan.spector.config.HnswParams;
-import java.lang.foreign.Arena;
-import java.lang.foreign.MemorySegment;
 import java.util.Arrays;
 import java.util.BitSet;
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import com.spectrayan.spector.core.quantization.NonUniformQuantizer;
-import com.spectrayan.spector.core.quantization.QuantizationType;
-import com.spectrayan.spector.core.quantization.ScalarQuantizer;
-import com.spectrayan.spector.core.quantization.strategy.DistanceContext;
-import com.spectrayan.spector.core.quantization.strategy.QuantizationStrategy;
-import com.spectrayan.spector.core.quantization.strategy.QuantizationStrategyFactory;
-import com.spectrayan.spector.core.quantization.strategy.Svasq4Strategy;
-import com.spectrayan.spector.core.quantization.strategy.SvasqStrategy;
-import com.spectrayan.spector.core.quantization.svasq.Svasq4Encoder;
-import com.spectrayan.spector.core.quantization.svasq.SvasqCalibrator;
-import com.spectrayan.spector.core.quantization.svasq.SvasqEncoder;
-import com.spectrayan.spector.core.quantization.svasq.SvasqParams;
-import com.spectrayan.spector.core.similarity.SimilarityFunction;
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-import com.spectrayan.spector.commons.error.ErrorCode;
+import com.spectrayan.spector.core.CrumbPacker;
+import com.spectrayan.spector.core.NibblePacker;
+import com.spectrayan.spector.core.NonUniformQuantizer;
+import com.spectrayan.spector.core.PackedDotProduct;
+import com.spectrayan.spector.core.QuantizationType;
+import com.spectrayan.spector.core.ScalarQuantizer;
+import com.spectrayan.spector.core.SimilarityFunction;
 
 /**
- * HNSW vector index with scalar quantization (INT8, INT4, INT2, SVASQ) support.
+ * HNSW vector index with scalar quantization (INT8, INT4, INT2) support.
  *
  * <p>Uses a two-phase search strategy for optimal speed/recall tradeoff:</p>
  * <ol>
  *   <li><b>Coarse search</b> — traverses the HNSW graph using quantized
- *       distances via the {@link QuantizationStrategy} SPI</li>
+ *       distances (INT8 linear, or INT4/INT2 packed dot product via SIMD)</li>
  *   <li><b>Re-ranking</b> — recomputes exact float32 distances for the top
  *       candidates to restore full-precision recall</li>
  * </ol>
  *
- * <h3>Design — Strategy Pattern</h3>
- * <p>All quantization-type-specific logic ({@code encode}, {@code decode}, {@code distance})
- * is delegated to a single {@link QuantizationStrategy} instance created by
- * {@link QuantizationStrategyFactory}. This eliminates the switch/if-else dispatch
- * chains that previously existed in this class. Adding a new quantization type requires
- * only a new strategy implementation — this class does not change.</p>
- *
  * <h3>Quantization Types</h3>
  * <ul>
- *   <li><b>INT8</b> — one byte per dimension, auto-calibrated after first N vectors (4× compression)</li>
- *   <li><b>INT4</b> — nibble-packed, calibrated from NonUniformQuantizer (8× compression)</li>
- *   <li><b>INT2</b> — crumb-packed, calibrated from NonUniformQuantizer (16× compression)</li>
- *   <li><b>SVASQ</b> — FWHT-rotated INT8, off-heap Panama SIMD kernel, auto-calibrated</li>
- *   <li><b>SVASQ-4</b> — FWHT-rotated INT4 (nibble-packed), 2× more compressed than SVASQ, auto-calibrated</li>
+ *   <li><b>INT8</b> — one byte per dimension, linear min/max calibration (4× compression)</li>
+ *   <li><b>INT4</b> — nibble-packed (2 values/byte), non-uniform quantile calibration (8× compression)</li>
+ *   <li><b>INT2</b> — crumb-packed (4 values/byte), non-uniform quantile calibration (16× compression)</li>
  * </ul>
  *
  * <h3>Rescore Strategy</h3>
@@ -73,15 +37,9 @@
  * {@code oversamplingFactor × k} candidates using fast quantized distance,
  * then rescores them with exact float32 distances to return the true top-K.</p>
  *
- * <h3>Calibration</h3>
- * <p>For INT8 and SVASQ: calibration is deferred. Vectors inserted before calibration
- * are buffered and retroactively encoded after auto-calibration triggers at
- * {@link #CALIBRATION_SAMPLE_SIZE} vectors. For INT4/INT2: the NonUniformQuantizer
- * must be pre-calibrated and provided at construction time.</p>
- *
  * @see AbstractHnswIndex
  * @see HnswIndex
- * @see QuantizationStrategy
+ * @see PackedDotProduct
  */
 public class QuantizedHnswIndex extends AbstractHnswIndex {
 
@@ -90,47 +48,23 @@ public class QuantizedHnswIndex extends AbstractHnswIndex {
     /** Number of vectors to buffer before auto-calibrating the quantizer. */
     private static final int CALIBRATION_SAMPLE_SIZE = 10_000;
 
-    // ── Vector storage (float32 kept for re-ranking and HNSW graph construction) ──
-    private final float[][] floatVectors;
-
-    // ── Unified off-heap storage (all quantization types) ──
-    /** Off-heap segment storing all quantized vectors. Null until the first calibration. */
-    private volatile MemorySegment storageSegment;
-    private Arena storageArena;
+    // ── Vector storage ──
+    private final float[][] floatVectors;      // kept for re-ranking and construction
+    private final byte[][] quantizedVectors;   // quantized for fast graph traversal
 
-    // ── Calibration state ──
-    private final QuantizationType quantizationType;
+    // ── Quantizer state (INT8) ──
+    private volatile ScalarQuantizer quantizer;
     private float[][] calibrationBuffer;
     private int calibrationCount;
 
-    /**
-     * The active quantization strategy. Null before calibration completes (for auto-calibrate types).
-     * Set atomically after calibration by {@link #calibrate()} or {@link #calibrateSvasq()}.
-     * For pre-calibrated types (INT4/INT2), set at construction.
-     */
-    private volatile QuantizationStrategy strategy;
-
-    /**
-     * Per-search distance context. Created locally inside {@link #searchLayerQuantized}
-     * and passed as a parameter — never stored as an instance field. This keeps
-     * concurrent reads on the same index safe (each search uses its own context).
-     */
-    // NOTE: currentQueryContext was previously a mutable instance field, which made
-    // concurrent searches on the same QuantizedHnswIndex unsafe despite AbstractHnswIndex's
-    // readLock. It has been moved to a method-local variable in searchLayerQuantized().
+    // ── Quantizer state (INT4/INT2) ──
+    private final QuantizationType quantizationType;
+    private final NonUniformQuantizer nonUniformQuantizer;
+    private final float[] globalCentroids; // averaged centroids for PackedDotProduct
 
     // ── Rescore configuration ──
     private final int oversamplingFactor;
 
-    // ── Retained for backward-compat accessors ──
-    private volatile ScalarQuantizer quantizer;
-    private final NonUniformQuantizer nonUniformQuantizer;
-    private volatile SvasqEncoder svasqEncoder;
-    private volatile Svasq4Encoder svasq4Encoder;
-    private final long svasqSeed;
-
-    // ─────────────── Constructors ───────────────
-
     /**
      * Creates a quantized HNSW index with a pre-calibrated INT8 quantizer.
      *
@@ -157,98 +91,7 @@ public QuantizedHnswIndex(int dimensions, int capacity,
     }
 
     /**
-     * Creates a SVASQ HNSW index with auto-calibration.
-     *
-     * <p>SVASQ calibration happens automatically when the first {@link #CALIBRATION_SAMPLE_SIZE}
-     * vectors are inserted. All vectors (including those inserted before calibration) are
-     * retroactively encoded after calibration.</p>
-     *
-     * @param dimensions           vector dimensionality
-     * @param capacity             max vectors
-     * @param similarityFunction   distance metric
-     * @param params               HNSW parameters
-     * @param oversamplingFactor   rescore oversampling (1 = no rescore, 3 = recommended for SVASQ)
-     */
-    public static QuantizedHnswIndex svasq(int dimensions, int capacity,
-                                           SimilarityFunction similarityFunction,
-                                           HnswParams params, int oversamplingFactor) {
-        return new QuantizedHnswIndex(dimensions, capacity, similarityFunction, params,
-                null, QuantizationType.SVASQ, null, oversamplingFactor);
-    }
-
-    /**
-     * Creates a SVASQ-quantized HNSW index with a <em>pre-calibrated</em> {@link SvasqStrategy}.
-     *
-     * <p>Unlike {@link #svasq} (which auto-calibrates on the first
-     * {@link #CALIBRATION_SAMPLE_SIZE} inserted vectors), this variant accepts a
-     * {@link SvasqStrategy} calibrated externally — typically on the full residual buffer
-     * of a {@link com.spectrayan.spector.index.spectrum.SpectorShard} at promotion time.
-     * This gives tighter quantization bounds because all residuals participate in
-     * calibration, not just the first 10K.</p>
-     *
-     * <p>The strategy is active from the very first {@link #add} call — no buffering
-     * phase occurs and the off-heap segment is allocated immediately.</p>
-     *
-     * @param dimensions           vector dimensionality
-     * @param capacity             max vectors
-     * @param similarityFunction   distance metric
-     * @param params               HNSW parameters
-     * @param preCalibrated        a fully built {@link SvasqStrategy} (non-null)
-     * @param oversamplingFactor   rescore oversampling (1 = no rescore, 3 = recommended)
-     * @throws SpectorValidationException if {@code preCalibrated} is null
-     */
-    public static QuantizedHnswIndex svasqPreCalibrated(int dimensions, int capacity,
-                                                        SimilarityFunction similarityFunction,
-                                                        HnswParams params,
-                                                        SvasqStrategy preCalibrated,
-                                                        int oversamplingFactor) {
-        if (preCalibrated == null) throw new SpectorValidationException(ErrorCode.ARGUMENT_NULL, "preCalibrated SvasqStrategy");
-        return new QuantizedHnswIndex(dimensions, capacity, similarityFunction, params,
-                preCalibrated, QuantizationType.SVASQ, oversamplingFactor);
-    }
-
-    /**
-     * Creates a SVASQ-4 HNSW index with auto-calibration.
-     *
-     * <p>SVASQ-4 uses INT4 nibble-packed codes (2× smaller than SVASQ-8).
-     * Calibration happens automatically when the first {@link #CALIBRATION_SAMPLE_SIZE}
-     * vectors are inserted, using 4-bit scales and tighter clipping (2.5σ).</p>
-     *
-     * @param dimensions         vector dimensionality
-     * @param capacity           max vectors
-     * @param similarityFunction distance metric
-     * @param params             HNSW parameters
-     * @param oversamplingFactor rescore oversampling (3 = recommended for SVASQ-4)
-     */
-    public static QuantizedHnswIndex svasq4(int dimensions, int capacity,
-                                            SimilarityFunction similarityFunction,
-                                            HnswParams params, int oversamplingFactor) {
-        return new QuantizedHnswIndex(dimensions, capacity, similarityFunction, params,
-                null, QuantizationType.SVASQ_4, null, oversamplingFactor);
-    }
-
-    /**
-     * Creates a SVASQ-4 HNSW index with a pre-calibrated {@link Svasq4Strategy}.
-     *
-     * @param dimensions         vector dimensionality
-     * @param capacity           max vectors
-     * @param similarityFunction distance metric
-     * @param params             HNSW parameters
-     * @param preCalibrated      a fully built {@link Svasq4Strategy} (non-null)
-     * @param oversamplingFactor rescore oversampling
-     */
-    public static QuantizedHnswIndex svasq4PreCalibrated(int dimensions, int capacity,
-                                                         SimilarityFunction similarityFunction,
-                                                         HnswParams params,
-                                                         Svasq4Strategy preCalibrated,
-                                                         int oversamplingFactor) {
-        if (preCalibrated == null) throw new SpectorValidationException(ErrorCode.ARGUMENT_NULL, "preCalibrated Svasq4Strategy");
-        return new QuantizedHnswIndex(dimensions, capacity, similarityFunction, params,
-                preCalibrated, QuantizationType.SVASQ_4, oversamplingFactor);
-    }
-
-    /**
-     * Creates a quantized HNSW index supporting INT8, INT4, INT2, or SVASQ quantization
+     * Creates a quantized HNSW index supporting INT8, INT4, or INT2 quantization
      * with configurable rescore oversampling.
      *
      * @param dimensions           vector dimensionality
@@ -256,9 +99,9 @@ public static QuantizedHnswIndex svasq4PreCalibrated(int dimensions, int capacit
      * @param similarityFunction   distance metric
      * @param params               HNSW parameters
      * @param quantizer            pre-calibrated INT8 quantizer (null for auto-calibrate; ignored for INT4/INT2)
-     * @param quantizationType     quantization type
-     * @param nonUniformQuantizer  calibrated non-uniform quantizer (required for INT4/INT2, null for INT8/SVASQ)
-     * @param oversamplingFactor   rescore oversampling factor (1 = no rescore, &gt;1 = oversample and rescore)
+     * @param quantizationType     quantization type (SCALAR_INT8, SCALAR_INT4, or SCALAR_INT2)
+     * @param nonUniformQuantizer  calibrated non-uniform quantizer (required for INT4/INT2, null for INT8)
+     * @param oversamplingFactor   rescore oversampling factor (1 = no rescore, >1 = oversample and rescore)
      */
     public QuantizedHnswIndex(int dimensions, int capacity,
                                SimilarityFunction similarityFunction,
@@ -272,93 +115,44 @@ public QuantizedHnswIndex(int dimensions, int capacity,
         this.quantizationType = quantizationType != null ? quantizationType : QuantizationType.SCALAR_INT8;
         this.nonUniformQuantizer = nonUniformQuantizer;
         this.oversamplingFactor = Math.max(1, oversamplingFactor);
+
         this.floatVectors = new float[capacity][];
-        this.svasqSeed = SvasqParams.DEFAULT_SEED;
+        this.quantizedVectors = new byte[capacity][];
 
-        // For INT4/INT2: strategy is ready immediately (pre-calibrated quantizer required)
-        // For INT8: strategy is ready if quantizer is provided; otherwise null until auto-calibrate
-        // For SVASQ: strategy is null until auto-calibrate
+        // INT4/INT2 path: pre-compute global centroids for PackedDotProduct
         if (this.quantizationType == QuantizationType.SCALAR_INT4
                 || this.quantizationType == QuantizationType.SCALAR_INT2) {
-            if (nonUniformQuantizer == null) {
-                throw new SpectorValidationException(ErrorCode.ARGUMENT_NULL, "NonUniformQuantizer (required for " + quantizationType + ")");
+            if (nonUniformQuantizer != null) {
+                this.globalCentroids = computeGlobalCentroids(nonUniformQuantizer);
+            } else {
+                // Deferred calibration: centroids will be computed when quantizer is set
+                this.globalCentroids = null;
             }
-            this.strategy = QuantizationStrategyFactory.create(
-                    this.quantizationType, null, nonUniformQuantizer, null, null, similarityFunction);
             this.quantizer = null;
-            this.svasqEncoder = null;
-            this.calibrationBuffer = null;
-            this.calibrationCount = 0;
-            // Allocate unified storage segment for packed INT4/INT2
-            allocateStorageSegment(capacity, strategy.bytesPerVector());
-        } else if (this.quantizationType == QuantizationType.SCALAR_INT8 && quantizer != null) {
-            // Pre-calibrated INT8 — strategy ready immediately
-            this.strategy = QuantizationStrategyFactory.create(
-                    this.quantizationType, quantizer, null, null, null, similarityFunction);
-            this.quantizer = quantizer;
-            this.svasqEncoder = null;
             this.calibrationBuffer = null;
             this.calibrationCount = 0;
-            allocateStorageSegment(capacity, strategy.bytesPerVector());
         } else {
-            // Auto-calibrate (INT8 or SVASQ) — strategy and segment are null until calibration
-            this.strategy = null;
-            this.quantizer = null;
-            this.svasqEncoder = null;
-            this.svasq4Encoder = null;
-            this.calibrationBuffer = new float[Math.min(CALIBRATION_SAMPLE_SIZE, capacity)][];
-            this.calibrationCount = 0;
-            this.storageSegment = null;
-            this.storageArena = null;
+            // INT8 path
+            this.globalCentroids = null;
+            this.quantizer = quantizer;
+            if (quantizer == null) {
+                this.calibrationBuffer = new float[Math.min(CALIBRATION_SAMPLE_SIZE, capacity)][];
+                this.calibrationCount = 0;
+            }
         }
 
-        log.info("QuantizedHnswIndex created: dims={}, capacity={}, M={}, type={}, oversampling={}, strategy={}",
+        log.info("QuantizedHnswIndex created: dims={}, capacity={}, M={}, type={}, oversampling={}, quantizer={}",
                 dimensions, capacity, params.m(), this.quantizationType, this.oversamplingFactor,
-                this.strategy != null ? "ready" : "pending-calibration");
-    }
-
-    /**
-     * Private constructor for pre-calibrated SVASQ or SVASQ-4.
-     * The strategy is immediately active; no calibration buffer is allocated.
-     */
-    private QuantizedHnswIndex(int dimensions, int capacity,
-                                SimilarityFunction similarityFunction,
-                                HnswParams params,
-                                QuantizationStrategy preCalibrated,
-                                QuantizationType quantType,
-                                int oversamplingFactor) {
-        super(dimensions, capacity, similarityFunction, params);
-        this.quantizationType = quantType;
-        this.nonUniformQuantizer = null;
-        this.oversamplingFactor = Math.max(1, oversamplingFactor);
-        this.floatVectors = new float[capacity][];
-        this.svasqSeed = SvasqParams.DEFAULT_SEED;
-        this.strategy = preCalibrated;
-
-        // Set the appropriate encoder accessor based on the strategy type
-        if (preCalibrated instanceof SvasqStrategy vs) {
-            this.svasqEncoder = vs.encoder();
-            this.svasq4Encoder = null;
-        } else if (preCalibrated instanceof Svasq4Strategy v4s) {
-            this.svasqEncoder = null;
-            this.svasq4Encoder = v4s.encoder();
-        } else {
-            this.svasqEncoder = null;
-            this.svasq4Encoder = null;
-        }
-        this.quantizer = null;
-        this.calibrationBuffer = null;
-        this.calibrationCount = 0;
-        allocateStorageSegment(capacity, preCalibrated.bytesPerVector());
-        log.info("QuantizedHnswIndex created with pre-calibrated {}: dims={}, capacity={}, M={}, bpv={}, oversampling={}",
-                quantType, dimensions, capacity, params.m(), preCalibrated.bytesPerVector(), this.oversamplingFactor);
+                this.quantizationType == QuantizationType.SCALAR_INT8
+                        ? (quantizer != null ? "pre-calibrated" : "auto-calibrate")
+                        : "non-uniform");
     }
 
     // ─────────────── Template method implementations ───────────────
 
     @Override
     protected float computeDistance(float[] query, int nodeIdx) {
-        return similarityFunction.computeForRanking(query, floatVectors[nodeIdx]);
+        return similarityFunction.compute(query, floatVectors[nodeIdx]);
     }
 
     @Override
@@ -366,77 +160,44 @@ protected float[] getNodeVector(int nodeIdx) {
         return floatVectors[nodeIdx];
     }
 
-    @Override
-    public float[] getVector(int nodeIdx) {
-        return floatVectors[nodeIdx];
-    }
-
     @Override
     protected void storeVector(int nodeIdx, float[] vector) {
-        // Defensive copy: the caller (add()) may mutate the passed vector after this returns.
-        // SpectorShard's ThreadLocal residual scratch is overwritten on the next add(), so the copy
-        // is necessary for the normal hot path. addOwned() sets skipCopy to bypass this.
-        floatVectors[nodeIdx] = skipCopy.get()[0] ? vector : Arrays.copyOf(vector, vector.length);
-
-        if (strategy == null) {
-            // Pre-calibration buffer phase (INT8 auto or SVASQ auto)
-            bufferForCalibration(vector, nodeIdx);
-        } else {
-            // Strategy is ready — encode directly into the off-heap segment
-            long offset = (long) nodeIdx * strategy.bytesPerVector();
-            strategy.encode(vector, storageSegment, offset);
+        floatVectors[nodeIdx] = Arrays.copyOf(vector, vector.length);
+
+        switch (quantizationType) {
+            case SCALAR_INT8 -> storeVectorInt8(nodeIdx, vector);
+            case SCALAR_INT4 -> storeVectorInt4(nodeIdx, vector);
+            case SCALAR_INT2 -> storeVectorInt2(nodeIdx, vector);
+            default -> throw new IllegalStateException("Unsupported type: " + quantizationType);
         }
     }
 
-    /**
-     * ThreadLocal flag used by {@link #addOwned} to tell {@link #storeVector} to skip the
-     * defensive {@code Arrays.copyOf}. A {@code boolean[1]} (not {@code Boolean}) is used so
-     * it can be mutated inside the lambda without a wrapper allocation.
-     */
-    private final ThreadLocal<boolean[]> skipCopy = ThreadLocal.withInitial(() -> new boolean[]{false});
+    private void storeVectorInt8(int nodeIdx, float[] vector) {
+        // Handle quantizer calibration
+        if (quantizer == null) {
+            if (calibrationCount < calibrationBuffer.length) {
+                calibrationBuffer[calibrationCount++] = vector;
+            }
+            if (calibrationCount >= calibrationBuffer.length
+                    || calibrationCount >= CALIBRATION_SAMPLE_SIZE) {
+                calibrate();
+            }
+        }
 
-    /**
-     * Bulk-insert variant that transfers ownership of {@code vector} to this index,
-     * skipping the defensive {@link Arrays#copyOf} that {@link #add} performs.
-     *
-     * <p><b>Ownership contract</b>: the caller must NOT mutate or reuse {@code vector}
-     * after this call returns. {@link com.spectrayan.spector.index.spectrum.SpectorShard#promote}
-     * satisfies this contract — it extracts sub-arrays from its flat buffer and nulls the
-     * buffer immediately after the bulk insert completes.</p>
-     *
-     * <p>For a shard of 20 000 vectors at D=768, this avoids ~61 MB of copy work
-     * compared to the standard {@link #add} path.</p>
-     *
-     * @param id         external document ID
-     * @param storeIndex external store index
-     * @param vector     float32 vector — ownership is transferred to this index
-     */
-    public void addOwned(String id, int storeIndex, float[] vector) {
-        boolean[] flag = skipCopy.get();
-        flag[0] = true;
-        try {
-            add(id, storeIndex, vector);  // AbstractHnswIndex.add() — acquires writeLock, calls storeVector()
-        } finally {
-            flag[0] = false;
+        // Quantize if calibrated
+        if (quantizer != null) {
+            quantizedVectors[nodeIdx] = quantizer.encode(vector);
         }
     }
 
-    private void bufferForCalibration(float[] vector, int nodeIdx) {
+    private void storeVectorInt4(int nodeIdx, float[] vector) {
+        int[] levels = nonUniformQuantizer.encode(vector);
+        quantizedVectors[nodeIdx] = NibblePacker.pack(levels, dimensions);
+    }
 
-        if (calibrationCount < calibrationBuffer.length) {
-            calibrationBuffer[calibrationCount++] = vector;
-        }
-        if (calibrationCount >= calibrationBuffer.length
-                || calibrationCount >= CALIBRATION_SAMPLE_SIZE) {
-            // Trigger calibration for INT8, SVASQ, or SVASQ_4
-            if (quantizationType == QuantizationType.SVASQ) {
-                calibrateSvasq();
-            } else if (quantizationType == QuantizationType.SVASQ_4) {
-                calibrateSvasq4();
-            } else {
-                calibrate();
-            }
-        }
+    private void storeVectorInt2(int nodeIdx, float[] vector) {
+        int[] levels = nonUniformQuantizer.encode(vector);
+        quantizedVectors[nodeIdx] = CrumbPacker.pack(levels, dimensions);
     }
 
     // ─────────────── Overridden search with quantized re-ranking ───────────────
@@ -444,7 +205,7 @@ private void bufferForCalibration(float[] vector, int nodeIdx) {
     @Override
     public ScoredResult[] search(float[] query, int k) {
         if (query.length != dimensions) {
-            throw new SpectorValidationException(ErrorCode.DIMENSIONS_MISMATCH, dimensions, query.length);
+            throw new IllegalArgumentException("Expected " + dimensions + " dims, got " + query.length);
         }
         if (nodeCount == 0) {
             return new ScoredResult[0];
@@ -453,38 +214,45 @@ public ScoredResult[] search(float[] query, int k) {
         int ef = Math.max(k, params.efSearch());
         int currentNode = entryPoint;
 
-        // Phase 1: Greedy descent through upper layers (uses exact float for precision)
+        // Phase 1: Greedy descent through upper layers (uses float for precision)
         for (int lc = maxLevel; lc > 0; lc--) {
             currentNode = greedyClosest(query, currentNode, lc);
         }
 
-        // Phase 2: Search at layer 0 using quantized distance (if strategy is ready)
+        // Phase 2: Search at layer 0 using quantized distance
         NeighborQueue candidates;
-        if (strategy != null) {
+        boolean hasQuantizer = (quantizationType == QuantizationType.SCALAR_INT8 && quantizer != null)
+                || quantizationType == QuantizationType.SCALAR_INT4
+                || quantizationType == QuantizationType.SCALAR_INT2;
+
+        if (hasQuantizer) {
+            // When oversampling > 1, retrieve more candidates for rescore
             int effectiveEf = oversamplingFactor > 1
                     ? Math.max(ef, oversamplingFactor * k)
                     : ef;
             candidates = searchLayerQuantized(query, currentNode, effectiveEf);
         } else {
-            // No strategy yet (pre-calibration phase) — use exact float distances
+            // No quantizer yet — use exact float distances
             candidates = searchLayer(query, currentNode, ef, 0);
-            return mapToStoreIndices(candidates.toSortedResults(ids, similarityFunction.higherIsBetter()));
+            return candidates.toSortedResults(ids, similarityFunction.higherIsBetter());
         }
 
         // Phase 3: Rescore — re-rank coarse candidates with exact float distances
+        // When oversamplingFactor == 1, skip rescoring and return quantized results directly
         if (oversamplingFactor <= 1) {
             ScoredResult[] sorted = candidates.toSortedResults(ids, similarityFunction.higherIsBetter());
             int resultCount = Math.min(k, sorted.length);
-            ScoredResult[] trimmed = resultCount == sorted.length ? sorted : Arrays.copyOf(sorted, resultCount);
-            return mapToStoreIndices(trimmed);
+            return resultCount == sorted.length ? sorted : Arrays.copyOf(sorted, resultCount);
         }
 
+        // Rescore: compute exact float32 distances for oversampled candidates
         int[] candidateIndices = candidates.indicesUnsorted();
         int reRankCount = candidateIndices.length;
+
         ScoredResult[] exactResults = new ScoredResult[reRankCount];
         for (int i = 0; i < reRankCount; i++) {
             int nodeIdx = candidateIndices[i];
-            float exactScore = similarityFunction.computeForRanking(query, floatVectors[nodeIdx]);
+            float exactScore = similarityFunction.compute(query, floatVectors[nodeIdx]);
             exactResults[i] = new ScoredResult(ids[nodeIdx], nodeIdx, exactScore);
         }
 
@@ -495,40 +263,18 @@ public ScoredResult[] search(float[] query, int k) {
         }
 
         int resultCount = Math.min(k, exactResults.length);
-        ScoredResult[] rescored = Arrays.copyOf(exactResults, resultCount);
-        return mapToStoreIndices(rescored);
-    }
-
-    private ScoredResult[] mapToStoreIndices(ScoredResult[] results) {
-        if (results == null || results.length == 0) return results;
-        ScoredResult[] mapped = new ScoredResult[results.length];
-        for (int i = 0; i < results.length; i++) {
-            ScoredResult r = results[i];
-            mapped[i] = new ScoredResult(r.id(), storeIndices[r.index()], r.score());
-        }
-        return mapped;
+        return Arrays.copyOf(exactResults, resultCount);
     }
 
     // ─────────────── Quantized layer-0 search ───────────────
 
-    /**
-     * Layer-0 search using quantized distances for coarse filtering.
-     *
-     * <p>Creates the {@link DistanceContext} locally (not as an instance field) so that
-     * concurrent searches on the same index are safe — each search thread has its own
-     * context, and the FWHT rotate scratch is already per-thread via ThreadLocal.</p>
-     */
+    /** Layer-0 search using quantized distances for coarse filtering. */
     private NeighborQueue searchLayerQuantized(float[] query, int entryNode, int ef) {
-        // Context is local — zero shared mutable state between concurrent searches
-        DistanceContext ctx = strategy.prepareQueryContext(query);
-
-        // Reuse per-thread BitSet from parent class — avoids per-search allocation
-        BitSet visited = visitedBitSetLocal.get();
-        visited.clear();
+        BitSet visited = new BitSet(nodeCount);
         NeighborQueue candidates = new NeighborQueue(ef + 1, ef, maxHeap());
         NeighborQueue workQueue = new NeighborQueue(ef + 1, minHeap());
 
-        float entryDist = computeQuantizedDistance(entryNode, ctx);
+        float entryDist = computeQuantizedDistance(query, entryNode);
         candidates.add(entryNode, entryDist);
         workQueue.add(entryNode, entryDist);
         visited.set(entryNode);
@@ -545,7 +291,7 @@ private NeighborQueue searchLayerQuantized(float[] query, int entryNode, int ef)
             for (int neighbor : nbrs) {
                 if (!visited.get(neighbor)) {
                     visited.set(neighbor);
-                    float dist = computeQuantizedDistance(neighbor, ctx);
+                    float dist = computeQuantizedDistance(query, neighbor);
                     if (candidates.size() < ef || isBetter(dist, candidates.topScore())) {
                         candidates.add(neighbor, dist);
                         workQueue.add(neighbor, dist);
@@ -553,114 +299,83 @@ private NeighborQueue searchLayerQuantized(float[] query, int entryNode, int ef)
                 }
             }
         }
-
         return candidates;
     }
 
-    /**
-     * Computes quantized distance from a stored vector to the current search query.
-     *
-     * <p>Reads from the unified off-heap {@link #storageSegment} using the active
-     * {@link QuantizationStrategy} and the per-search {@link DistanceContext} passed
-     * directly as a parameter (not stored as an instance field, ensuring thread safety).</p>
-     *
-     * @param nodeIdx the index of the candidate node
-     * @param ctx     the per-search distance context created by {@link #searchLayerQuantized}
-     * @return approximate distance
-     */
-    private float computeQuantizedDistance(int nodeIdx, DistanceContext ctx) {
-        long offset = (long) nodeIdx * strategy.bytesPerVector();
-        return strategy.distance(storageSegment, offset, ctx);
-    }
-
-    // ─────────────── Calibration ───────────────
+    // ─────────────── Quantized distance dispatch ───────────────
 
     /**
-     * Auto-calibrates the INT8 scalar quantizer from buffered vectors, builds the
-     * strategy, allocates the off-heap segment, and retroactively encodes all buffered
-     * vectors.
+     * Computes quantized distance between a query and a stored vector,
+     * dispatching to the appropriate kernel based on quantization type.
      */
-    private synchronized void calibrate() {
-        if (strategy != null) return; // already calibrated (concurrent trigger)
-        float[][] sample = Arrays.copyOf(calibrationBuffer, calibrationCount);
-        ScalarQuantizer sq = ScalarQuantizer.calibrate(sample, dimensions);
-        this.quantizer = sq;
-
-        this.strategy = QuantizationStrategyFactory.create(
-                QuantizationType.SCALAR_INT8, sq, null, null, null, similarityFunction);
-        allocateStorageSegment(capacity, strategy.bytesPerVector());
+    private float computeQuantizedDistance(float[] query, int nodeIdx) {
+        return switch (quantizationType) {
+            case SCALAR_INT8 -> distanceQuantizedInt8(query, nodeIdx);
+            case SCALAR_INT4 -> distanceQuantizedInt4(query, nodeIdx);
+            case SCALAR_INT2 -> distanceQuantizedInt2(query, nodeIdx);
+            default -> similarityFunction.compute(query, floatVectors[nodeIdx]);
+        };
+    }
 
-        log.info("QuantizedHnswIndex INT8 auto-calibrated from {} sample vectors", calibrationCount);
+    private float distanceQuantizedInt8(float[] query, int nodeIdx) {
+        float[] qMins = quantizer.mins();
+        float[] qScales = quantizer.scales();
+        return similarityFunction.computeQuantized(
+                query, quantizedVectors[nodeIdx], qMins, qScales, dimensions);
+    }
 
-        // Retroactively encode all buffered vectors
-        for (int i = 0; i < nodeCount; i++) {
-            if (floatVectors[i] != null) {
-                long offset = (long) i * strategy.bytesPerVector();
-                strategy.encode(floatVectors[i], storageSegment, offset);
-            }
+    private float distanceQuantizedInt4(float[] query, int nodeIdx) {
+        byte[] packed = quantizedVectors[nodeIdx];
+        if (packed == null) {
+            return similarityFunction.compute(query, floatVectors[nodeIdx]);
         }
+        // PackedDotProduct computes sum(query[i] * centroids[level[i]])
+        // For cosine/dot product similarity, higher is better (negate for distance)
+        float dotProduct = PackedDotProduct.computeInt4(query, packed, globalCentroids, dimensions);
+        return similarityFunction.higherIsBetter() ? dotProduct : -dotProduct;
+    }
 
-        calibrationBuffer = null;
-        calibrationCount = 0;
+    private float distanceQuantizedInt2(float[] query, int nodeIdx) {
+        byte[] packed = quantizedVectors[nodeIdx];
+        if (packed == null) {
+            return similarityFunction.compute(query, floatVectors[nodeIdx]);
+        }
+        float dotProduct = PackedDotProduct.computeInt2(query, packed, globalCentroids, dimensions);
+        return similarityFunction.higherIsBetter() ? dotProduct : -dotProduct;
     }
 
+    // ─────────────── Quantizer helpers ───────────────
+
     /**
-     * Auto-calibrates the SVASQ encoder from buffered vectors, builds the strategy,
-     * allocates the off-heap segment, and retroactively encodes all buffered vectors.
-     *
-     * <p>Uses {@link SvasqCalibrator#calibrate(float[][], int, int, long)} to avoid
-     * the previous {@code Arrays.copyOf} + {@code Arrays.asList} wrapper.
+     * Computes global centroids by averaging per-dimension centroids from the NonUniformQuantizer.
+     * This produces a single centroid lookup table for PackedDotProduct.
      */
-    private synchronized void calibrateSvasq() {
-        if (strategy != null) return; // already calibrated
-        SvasqParams vParams = SvasqCalibrator.calibrate(
-                calibrationBuffer, calibrationCount, dimensions, svasqSeed);
-        SvasqEncoder enc = new SvasqEncoder(vParams);
-        this.svasqEncoder = enc;
-
-        this.strategy = new SvasqStrategy(enc, similarityFunction);
-        allocateStorageSegment(capacity, strategy.bytesPerVector());
-
-        log.info("QuantizedHnswIndex SVASQ auto-calibrated: {} sample vectors, paddedDim={}, bpv={}",
-                calibrationCount, vParams.paddedDim(), strategy.bytesPerVector());
-
-        // Retroactively encode all vectors inserted before calibration
-        for (int i = 0; i < nodeCount; i++) {
-            if (floatVectors[i] != null) {
-                long offset = (long) i * strategy.bytesPerVector();
-                strategy.encode(floatVectors[i], storageSegment, offset);
+    private static float[] computeGlobalCentroids(NonUniformQuantizer nuq) {
+        int levels = nuq.levels();
+        int dims = nuq.dimensions();
+        float[] global = new float[levels];
+
+        for (int level = 0; level < levels; level++) {
+            double sum = 0.0;
+            for (int dim = 0; dim < dims; dim++) {
+                float[] dimCentroids = nuq.centroids(dim);
+                sum += dimCentroids[level];
             }
+            global[level] = (float) (sum / dims);
         }
-
-        calibrationBuffer = null;
-        calibrationCount = 0;
+        return global;
     }
 
-    /**
-     * Auto-calibrates the SVASQ-4 (INT4) encoder from buffered vectors, builds the strategy,
-     * allocates the off-heap segment, and retroactively encodes all buffered vectors.
-     *
-     * <p>Uses {@link SvasqCalibrator#calibrate4bit} with tighter clipping (2.5σ) for optimal
-     * use of the 15 available INT4 quantization levels.</p>
-     */
-    private synchronized void calibrateSvasq4() {
-        if (strategy != null) return;
-        SvasqParams vParams = SvasqCalibrator.calibrate4bit(
-                calibrationBuffer, calibrationCount, dimensions, svasqSeed);
-        Svasq4Encoder enc = new Svasq4Encoder(vParams);
-        this.svasq4Encoder = enc;
-
-        this.strategy = new Svasq4Strategy(enc, similarityFunction);
-        allocateStorageSegment(capacity, strategy.bytesPerVector());
-
-        log.info("QuantizedHnswIndex SVASQ-4 auto-calibrated: {} sample vectors, paddedDim={}, bpv={}",
-                calibrationCount, vParams.paddedDim(), strategy.bytesPerVector());
+    /** Auto-calibrates the INT8 quantizer from buffered vectors. */
+    private void calibrate() {
+        float[][] sample = Arrays.copyOf(calibrationBuffer, calibrationCount);
+        this.quantizer = ScalarQuantizer.calibrate(sample, dimensions);
+        log.info("QuantizedHnswIndex auto-calibrated from {} sample vectors", calibrationCount);
 
-        // Retroactively encode all vectors inserted before calibration
+        // Quantize all existing vectors that were inserted before calibration
         for (int i = 0; i < nodeCount; i++) {
             if (floatVectors[i] != null) {
-                long offset = (long) i * strategy.bytesPerVector();
-                strategy.encode(floatVectors[i], storageSegment, offset);
+                quantizedVectors[i] = quantizer.encode(floatVectors[i]);
             }
         }
 
@@ -668,40 +383,26 @@ private synchronized void calibrateSvasq4() {
         calibrationCount = 0;
     }
 
-    private void allocateStorageSegment(int capacity, int bpv) {
-        if (this.storageArena != null) {
-            this.storageArena.close(); // free previous (shouldn't happen, but defensive)
-        }
-        this.storageArena = Arena.ofShared();
-        this.storageSegment = storageArena.allocate((long) capacity * bpv, 8L);
-    }
-
     // ─────────────── Public accessors ───────────────
 
-    /** Returns the active {@link QuantizationStrategy}, or null if not yet calibrated. */
-    public QuantizationStrategy strategy() { return strategy; }
-
-    /** Returns the quantization type used by this index. */
-    public QuantizationType quantizationType() { return quantizationType; }
-
     /** Returns the INT8 quantizer (may be null if not INT8 or not yet calibrated). */
     public ScalarQuantizer quantizer() { return quantizer; }
 
-    /** Returns the non-uniform quantizer (INT4/INT2), or null if INT8/SVASQ. */
-    public NonUniformQuantizer nonUniformQuantizer() { return nonUniformQuantizer; }
+    /** Returns true if the quantizer has been calibrated (INT8) or non-uniform quantizer is set (INT4/INT2). */
+    public boolean isCalibrated() {
+        return switch (quantizationType) {
+            case SCALAR_INT8 -> quantizer != null;
+            case SCALAR_INT4, SCALAR_INT2 -> nonUniformQuantizer != null;
+            default -> false;
+        };
+    }
 
-    /** Returns the SVASQ encoder, or null if not SVASQ or not yet calibrated. */
-    public SvasqEncoder svasqEncoder() { return svasqEncoder; }
+    /** Returns the quantization type used by this index. */
+    public QuantizationType quantizationType() { return quantizationType; }
 
-    /** Returns the SVASQ-4 encoder, or null if not SVASQ-4 or not yet calibrated. */
-    public Svasq4Encoder svasq4Encoder() { return svasq4Encoder; }
+    /** Returns the non-uniform quantizer (INT4/INT2), or null if INT8. */
+    public NonUniformQuantizer nonUniformQuantizer() { return nonUniformQuantizer; }
 
     /** Returns the configured oversampling factor. */
     public int oversamplingFactor() { return oversamplingFactor; }
-
-    /**
-     * Returns true if the quantization strategy has been initialized (either pre-calibrated
-     * or auto-calibrated from buffered vectors).
-     */
-    public boolean isCalibrated() { return strategy != null; }
 }
diff --git a/spector-index/src/main/java/com/spectrayan/spector/index/hnsw/ShardedDiskHnswIndex.java b/spector-index/src/main/java/com/spectrayan/spector/index/hnsw/ShardedDiskHnswIndex.java
deleted file mode 100644
index 2889592..0000000
--- a/spector-index/src/main/java/com/spectrayan/spector/index/hnsw/ShardedDiskHnswIndex.java
+++ /dev/null
@@ -1,453 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.index;
-
-import com.spectrayan.spector.core.similarity.SimilarityFunction;
-import com.spectrayan.spector.storage.IndexFileFormat;
-import com.spectrayan.spector.storage.ShardedIndexFormat;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.io.IOException;
-import java.io.RandomAccessFile;
-import java.lang.foreign.Arena;
-import java.lang.foreign.MemorySegment;
-import java.lang.foreign.ValueLayout;
-import java.nio.channels.FileChannel;
-import java.nio.charset.StandardCharsets;
-import java.nio.file.Path;
-import java.util.Arrays;
-import java.util.BitSet;
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-import com.spectrayan.spector.commons.error.ErrorCode;
-
-/**
- * Read-only HNSW index backed by multiple memory-mapped shard files.
- *
- * <p>Each shard is independently mmap'd via its own {@link Arena}. The HNSW
- * search algorithm works identically to {@link DiskHnswIndex} — greedy descent
- * through upper layers followed by beam search at layer 0 — but reads vectors
- * and neighbors from the correct shard using global-to-local index mapping:</p>
- * <pre>
- *   shardIdx  = globalNodeIdx / nodesPerShard
- *   localIdx  = globalNodeIdx % nodesPerShard
- * </pre>
- *
- * <p>Neighbor indices in the shard files are <b>global</b>, so cross-shard
- * graph traversal is transparent and requires no remapping.</p>
- *
- * <h3>Thread Safety</h3>
- * <p>Concurrent searches are safe (shared arenas, read-only segments).</p>
- *
- * @see ShardedDiskHnswWriter
- * @see ShardedIndexFormat
- */
-public class ShardedDiskHnswIndex implements VectorIndex {
-
-    private static final Logger log = LoggerFactory.getLogger(ShardedDiskHnswIndex.class);
-
-    private final Path shardDir;
-    private final ShardedIndexFormat.Manifest manifest;
-    private final Shard[] shards;
-    private final String[] ids;  // global ID table (heap)
-    private final SimilarityFunction similarityFunction;
-    private volatile boolean closed;
-    private volatile long lastAccessed;
-
-    /**
-     * Per-shard mmap context.
-     */
-    private record Shard(
-            Path filePath,
-            IndexFileFormat.Header header,
-            Arena arena,
-            MemorySegment segment,
-            RandomAccessFile raf,
-            FileChannel channel
-    ) {
-        void close() throws IOException {
-            if (segment.isMapped()) {
-                com.spectrayan.spector.commons.concurrent.MemoryPinning.unlock(segment);
-                segment.unload();
-            }
-            arena.close();
-            channel.close();
-            raf.close();
-        }
-    }
-
-    private ShardedDiskHnswIndex(Path shardDir, ShardedIndexFormat.Manifest manifest,
-                                  Shard[] shards, String[] ids) {
-        this.shardDir = shardDir;
-        this.manifest = manifest;
-        this.shards = shards;
-        this.ids = ids;
-        this.similarityFunction = SimilarityFunction.values()[manifest.similarity()];
-        this.closed = false;
-        this.lastAccessed = System.currentTimeMillis();
-    }
-
-    /**
-     * Opens a sharded disk HNSW index for read-only search.
-     *
-     * @param shardDir directory containing the manifest and shard files
-     * @return a ready-to-search sharded index
-     * @throws IOException if any file cannot be read or is invalid
-     */
-    public static ShardedDiskHnswIndex open(Path shardDir) throws IOException {
-        // 1. Read manifest
-        var manifest = ShardedIndexFormat.readManifest(shardDir);
-        manifest.validate();
-
-        int shardCount = manifest.shardCount();
-        Shard[] shards = new Shard[shardCount];
-
-        // 2. Open each shard file
-        try {
-            for (int s = 0; s < shardCount; s++) {
-                Path shardPath = shardDir.resolve(ShardedIndexFormat.shardFileName(s));
-                var raf = new RandomAccessFile(shardPath.toFile(), "r");
-                var channel = raf.getChannel();
-                long fileSize = raf.length();
-
-                var arena = Arena.ofShared();
-                var segment = channel.map(FileChannel.MapMode.READ_ONLY, 0, fileSize, arena);
-
-                var header = IndexFileFormat.readHeader(segment);
-                header.validate();
-
-                shards[s] = new Shard(shardPath, header, arena, segment, raf, channel);
-            }
-        } catch (Exception e) {
-            // Close any shards we already opened
-            for (Shard shard : shards) {
-                if (shard != null) {
-                    try { shard.close(); } catch (Exception ignore) {}
-                }
-            }
-            throw new IOException("Failed to open sharded index at " + shardDir, e);
-        }
-
-        // 3. Load global ID table from all shards
-        String[] ids = new String[manifest.totalNodeCount()];
-        int globalIdx = 0;
-        for (int s = 0; s < shardCount; s++) {
-            String[] shardIds = readIdTable(shards[s].segment(), shards[s].header());
-            System.arraycopy(shardIds, 0, ids, globalIdx, shardIds.length);
-            globalIdx += shardIds.length;
-        }
-
-        log.info("ShardedDiskHnswIndex opened: {} nodes across {} shards, dims={}, dir={}",
-                manifest.totalNodeCount(), shardCount, manifest.dimensions(), shardDir);
-
-        var index = new ShardedDiskHnswIndex(shardDir, manifest, shards, ids);
-        index.warmup();
-        return index;
-    }
-
-    // ─────────────── VectorIndex implementation ───────────────
-
-    @Override
-    public void add(String id, int storeIndex, float[] vector) {
-        throw new SpectorValidationException(ErrorCode.ARGUMENT_INVALID, "ShardedDiskHnswIndex", "read-only; build with AbstractHnswIndex + ShardedDiskHnswWriter");
-    }
-
-    @Override
-    public boolean isReadOnly() {
-        return true;
-    }
-
-    @Override
-    public ScoredResult[] search(float[] query, int k) {
-        this.lastAccessed = System.currentTimeMillis();
-        if (query.length != manifest.dimensions()) {
-            throw new SpectorValidationException(ErrorCode.DIMENSIONS_MISMATCH, manifest.dimensions(), query.length);
-        }
-        if (manifest.totalNodeCount() == 0) {
-            return new ScoredResult[0];
-        }
-
-        int ef = Math.max(k, 50);
-        int currentNode = manifest.globalEntryPoint();
-
-        // Phase 1: Greedy descent through upper layers
-        for (int lc = manifest.globalMaxLevel(); lc > 0; lc--) {
-            currentNode = greedyClosest(query, currentNode, lc);
-        }
-
-        // Phase 2: Beam search at layer 0
-        NeighborQueue candidates = searchLayer(query, currentNode, ef);
-
-        // Extract top-K
-        boolean higherIsBetter = similarityFunction.higherIsBetter();
-        ScoredResult[] results = candidates.toSortedResults(ids, higherIsBetter);
-        if (results.length > k) {
-            results = Arrays.copyOf(results, k);
-        }
-        return results;
-    }
-
-    @Override
-    public int size() { return manifest.totalNodeCount(); }
-
-    @Override
-    public SimilarityFunction similarityFunction() { return similarityFunction; }
-
-    @Override
-    public synchronized void close() {
-        if (!closed) {
-            closed = true;
-            for (Shard shard : shards) {
-                try {
-                    shard.close();
-                } catch (IOException e) {
-                    log.warn("Error closing shard {}", shard.filePath(), e);
-                }
-            }
-            log.info("ShardedDiskHnswIndex closed: {} shards, dir={}", shards.length, shardDir);
-        }
-    }
-
-    // ─────────────── Warmup ───────────────
-
-    /**
-     * Pre-touches all shard segments on virtual threads for warm page cache.
-     */
-    public void warmup() {
-        for (Shard shard : shards) {
-            if (shard.segment().isMapped()) {
-                Thread.startVirtualThread(() -> {
-                    long start = System.nanoTime();
-                    try {
-                        shard.segment().load();
-                        boolean pinned = com.spectrayan.spector.commons.concurrent.MemoryPinning.lock(shard.segment());
-                        long elapsedMs = (System.nanoTime() - start) / 1_000_000;
-                        log.debug("Shard warmed up (pinned={}) in {} ms: {}",
-                                pinned, elapsedMs, shard.filePath());
-                    } catch (Exception e) {
-                        log.warn("Failed to warm up shard {}: {}", shard.filePath(), e.getMessage());
-                    }
-                });
-            }
-        }
-    }
-
-    /**
-     * Evicts idle shard pages from physical memory.
-     *
-     * @param gracePeriodMs threshold of inactivity in milliseconds
-     * @return true if any shards were evicted
-     */
-    public synchronized boolean unloadIdle(long gracePeriodMs) {
-        if (closed) return false;
-        long idleMs = System.currentTimeMillis() - lastAccessed;
-        if (idleMs < gracePeriodMs) return false;
-
-        boolean evicted = false;
-        for (Shard shard : shards) {
-            if (shard.segment().isMapped()) {
-                com.spectrayan.spector.commons.concurrent.MemoryPinning.unlock(shard.segment());
-                shard.segment().unload();
-                evicted = true;
-            }
-        }
-        if (evicted) {
-            log.info("ShardedDiskHnswIndex idle-evicted all shards (idle for {} ms)", idleMs);
-        }
-        return evicted;
-    }
-
-    // ─────────────── Accessors ───────────────
-
-    /** Returns the shard directory path. */
-    public Path shardDir() { return shardDir; }
-
-    /** Returns the manifest. */
-    public ShardedIndexFormat.Manifest manifest() { return manifest; }
-
-    /** Returns the number of shards. */
-    public int shardCount() { return shards.length; }
-
-    /** Returns the HNSW entry point node index. */
-    public int entryPoint() { return manifest.globalEntryPoint(); }
-
-    /** Returns the HNSW maximum level. */
-    public int maxLevel() { return manifest.globalMaxLevel(); }
-
-    /** Returns the ID for the given global node index. */
-    public String getId(int globalNodeIdx) { return ids[globalNodeIdx]; }
-
-    // ─────────────── Graph operations (mmap-backed, cross-shard) ───────────────
-
-    /**
-     * Reads a vector from the correct shard's mmap'd segment.
-     *
-     * @param globalNodeIdx global node index
-     * @return the float32 vector
-     */
-    public float[] readVector(int globalNodeIdx) {
-        int shardIdx = manifest.shardFor(globalNodeIdx);
-        int localIdx = manifest.localIndex(globalNodeIdx);
-        Shard shard = shards[shardIdx];
-        int dims = manifest.dimensions();
-        float[] vector = new float[dims];
-        long offset = shard.header().vectorDataOffset()
-                + (long) localIdx * dims * Float.BYTES;
-        MemorySegment.copy(shard.segment(), IndexFileFormat.FLOAT_U, offset, vector, 0, dims);
-        return vector;
-    }
-
-    /**
-     * Reads neighbor indices from the correct shard's graph region.
-     * Returned indices are <b>global</b>.
-     *
-     * @param globalNodeIdx global node index
-     * @param layer         the HNSW layer
-     * @return neighbor indices (global)
-     */
-    public int[] readNeighbors(int globalNodeIdx, int layer) {
-        int shardIdx = manifest.shardFor(globalNodeIdx);
-        int localIdx = manifest.localIndex(globalNodeIdx);
-        Shard shard = shards[shardIdx];
-        MemorySegment seg = shard.segment();
-        IndexFileFormat.Header h = shard.header();
-
-        long blockOffset = h.graphDataOffset() + (long) localIdx * h.graphBlockSize();
-        long pos = blockOffset + 4; // skip level field
-
-        if (layer == 0) {
-            int count = seg.get(IndexFileFormat.INT_U, pos);
-            pos += 4;
-            int[] neighbors = new int[count];
-            for (int i = 0; i < count; i++) {
-                neighbors[i] = seg.get(IndexFileFormat.INT_U, pos + (long) i * 4);
-            }
-            return neighbors;
-        }
-
-        // Skip layer 0
-        pos += 4 + (long) h.maxLevel0Connections() * 4;
-
-        // Skip to the requested upper layer
-        for (int l = 1; l < layer; l++) {
-            pos += 4 + (long) h.m() * 4;
-        }
-
-        int count = seg.get(IndexFileFormat.INT_U, pos);
-        pos += 4;
-        int[] neighbors = new int[count];
-        for (int i = 0; i < count; i++) {
-            neighbors[i] = seg.get(IndexFileFormat.INT_U, pos + (long) i * 4);
-        }
-        return neighbors;
-    }
-
-    /**
-     * Reads the HNSW level for a global node index.
-     */
-    public int readLevel(int globalNodeIdx) {
-        int shardIdx = manifest.shardFor(globalNodeIdx);
-        int localIdx = manifest.localIndex(globalNodeIdx);
-        Shard shard = shards[shardIdx];
-        long blockOffset = shard.header().graphDataOffset()
-                + (long) localIdx * shard.header().graphBlockSize();
-        return shard.segment().get(IndexFileFormat.INT_U, blockOffset);
-    }
-
-    // ─────────────── HNSW search algorithm ───────────────
-
-    private int greedyClosest(float[] query, int startNode, int layer) {
-        int current = startNode;
-        float currentDist = distance(query, current);
-        boolean improved = true;
-
-        while (improved) {
-            improved = false;
-            int[] nbrs = readNeighbors(current, layer);
-            for (int neighbor : nbrs) {
-                float dist = distance(query, neighbor);
-                if (isBetter(dist, currentDist)) {
-                    current = neighbor;
-                    currentDist = dist;
-                    improved = true;
-                }
-            }
-        }
-        return current;
-    }
-
-    private NeighborQueue searchLayer(float[] query, int entryNode, int ef) {
-        BitSet visited = new BitSet(manifest.totalNodeCount());
-        NeighborQueue candidates = new NeighborQueue(ef + 1, ef, maxHeap());
-        NeighborQueue workQueue = new NeighborQueue(ef + 1, minHeap());
-
-        float entryDist = distance(query, entryNode);
-        candidates.add(entryNode, entryDist);
-        workQueue.add(entryNode, entryDist);
-        visited.set(entryNode);
-
-        while (!workQueue.isEmpty()) {
-            float currentDist = workQueue.topScore();
-            int current = workQueue.poll();
-
-            if (candidates.size() >= ef && !isBetter(currentDist, candidates.topScore())) {
-                break;
-            }
-
-            int[] nbrs = readNeighbors(current, 0);
-            for (int neighbor : nbrs) {
-                if (!visited.get(neighbor)) {
-                    visited.set(neighbor);
-                    float dist = distance(query, neighbor);
-                    if (candidates.size() < ef || isBetter(dist, candidates.topScore())) {
-                        candidates.add(neighbor, dist);
-                        workQueue.add(neighbor, dist);
-                    }
-                }
-            }
-        }
-        return candidates;
-    }
-
-    private float distance(float[] query, int globalNodeIdx) {
-        float[] vector = readVector(globalNodeIdx);
-        return similarityFunction.compute(query, vector);
-    }
-
-    private boolean isBetter(float a, float b) {
-        return similarityFunction.higherIsBetter() ? a > b : a < b;
-    }
-
-    private boolean minHeap() { return !similarityFunction.higherIsBetter(); }
-    private boolean maxHeap() { return similarityFunction.higherIsBetter(); }
-
-    // ─────────────── ID table reader ───────────────
-
-    private static String[] readIdTable(MemorySegment segment, IndexFileFormat.Header header) {
-        String[] ids = new String[header.nodeCount()];
-        long pos = header.idTableOffset();
-        for (int i = 0; i < header.nodeCount(); i++) {
-            int len = segment.get(IndexFileFormat.INT_U, pos);
-            pos += 4;
-            byte[] bytes = new byte[len];
-            MemorySegment.copy(segment, ValueLayout.JAVA_BYTE, pos, bytes, 0, len);
-            ids[i] = new String(bytes, StandardCharsets.UTF_8);
-            pos += len;
-        }
-        return ids;
-    }
-}
diff --git a/spector-index/src/main/java/com/spectrayan/spector/index/hnsw/ShardedDiskHnswWriter.java b/spector-index/src/main/java/com/spectrayan/spector/index/hnsw/ShardedDiskHnswWriter.java
deleted file mode 100644
index c0460ec..0000000
--- a/spector-index/src/main/java/com/spectrayan/spector/index/hnsw/ShardedDiskHnswWriter.java
+++ /dev/null
@@ -1,253 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.index;
-
-import com.spectrayan.spector.config.HnswParams;
-import com.spectrayan.spector.core.quantization.QuantizationType;
-import com.spectrayan.spector.core.similarity.SimilarityFunction;
-import com.spectrayan.spector.storage.IndexFileFormat;
-import com.spectrayan.spector.storage.ShardedIndexFormat;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.io.IOException;
-import java.io.RandomAccessFile;
-import java.lang.foreign.Arena;
-import java.lang.foreign.MemorySegment;
-import java.lang.foreign.ValueLayout;
-import java.nio.channels.FileChannel;
-import java.nio.charset.StandardCharsets;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-import com.spectrayan.spector.commons.error.ErrorCode;
-
-/**
- * Serializes an in-memory {@link AbstractHnswIndex} into multiple shard files.
- *
- * <p>Each shard file uses the standard {@link IndexFileFormat} layout and contains
- * a range of nodes. Neighbor indices remain <b>global</b> (not shard-local),
- * preserving the HNSW graph structure unchanged. A manifest file catalogs all shards.</p>
- *
- * <h3>Usage</h3>
- * <pre>{@code
- *   HnswIndex inMemory = buildIndex(...);
- *   ShardedDiskHnswWriter.write(inMemory, Path.of("index_shards"), 50_000);
- *   // Creates:
- *   //   index_shards/index.spct.manifest
- *   //   index_shards/index-000000.spct  (nodes 0–49999)
- *   //   index_shards/index-000001.spct  (nodes 50000–99999)
- *   //   ...
- * }</pre>
- *
- * @see ShardedIndexFormat
- * @see ShardedDiskHnswIndex
- * @see DiskHnswWriter
- */
-public final class ShardedDiskHnswWriter {
-
-    private static final Logger log = LoggerFactory.getLogger(ShardedDiskHnswWriter.class);
-
-    /** Maximum upper layers supported per node in the graph block layout. */
-    private static final int MAX_POSSIBLE_LEVELS = 10;
-
-    private ShardedDiskHnswWriter() {}
-
-    /**
-     * Writes an HNSW index as multiple sharded files plus a manifest.
-     *
-     * @param index        the in-memory HNSW index
-     * @param shardDir     directory for shard files and manifest (created if absent)
-     * @param nodesPerShard maximum nodes per shard (last shard may have fewer)
-     * @throws IOException if writing fails
-     * @throws SpectorValidationException if nodesPerShard <= 0
-     */
-    public static void write(AbstractHnswIndex index, Path shardDir, int nodesPerShard)
-            throws IOException {
-
-        if (nodesPerShard <= 0) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_OUT_OF_RANGE, "nodesPerShard", 1, Integer.MAX_VALUE, nodesPerShard);
-        }
-
-        int totalNodes = index.size();
-        if (totalNodes == 0) {
-            log.info("ShardedDiskHnswWriter: nothing to write (0 nodes)");
-            return;
-        }
-
-        int dimensions = index.dimensions();
-        SimilarityFunction simFunc = index.similarityFunction();
-        HnswParams params = index.params();
-
-        int shardCount = (totalNodes + nodesPerShard - 1) / nodesPerShard;
-        int graphBlockSize = IndexFileFormat.computeGraphBlockSize(
-                params.maxLevel0Connections(), params.m(), MAX_POSSIBLE_LEVELS);
-
-        Files.createDirectories(shardDir);
-
-        ShardedIndexFormat.ShardEntry[] shardEntries = new ShardedIndexFormat.ShardEntry[shardCount];
-
-        log.info("ShardedDiskHnswWriter: writing {} nodes across {} shards ({}/ shard) to {}",
-                totalNodes, shardCount, nodesPerShard, shardDir);
-
-        // Write each shard file
-        for (int s = 0; s < shardCount; s++) {
-            int startNode = s * nodesPerShard;
-            int endNode = Math.min(startNode + nodesPerShard, totalNodes);
-            int shardNodeCount = endNode - startNode;
-
-            Path shardPath = shardDir.resolve(ShardedIndexFormat.shardFileName(s));
-            long shardFileSize = writeShard(index, shardPath, startNode, endNode,
-                    dimensions, params, graphBlockSize, simFunc);
-
-            shardEntries[s] = new ShardedIndexFormat.ShardEntry(shardNodeCount, shardFileSize);
-
-            log.debug("  Shard {}: nodes [{}, {}), {} bytes → {}",
-                    s, startNode, endNode, shardFileSize, shardPath);
-        }
-
-        // Write manifest
-        var manifest = new ShardedIndexFormat.Manifest(
-                ShardedIndexFormat.MAGIC, ShardedIndexFormat.VERSION,
-                shardCount, dimensions, totalNodes, nodesPerShard,
-                params.m(), params.maxLevel0Connections(),
-                index.entryPoint(), index.maxLevel(),
-                simFunc.ordinal(), QuantizationType.NONE.ordinal(),
-                shardEntries
-        );
-        ShardedIndexFormat.writeManifest(manifest, shardDir);
-
-        long totalBytes = 0;
-        for (var e : shardEntries) totalBytes += e.fileSize();
-        log.info("ShardedDiskHnswWriter: done — {} shards, {} total bytes, manifest at {}",
-                shardCount, totalBytes, shardDir.resolve(ShardedIndexFormat.MANIFEST_NAME));
-    }
-
-    // ─────────────── Single shard write ───────────────
-
-    /**
-     * Writes a single shard file containing nodes [startNode, endNode).
-     * Returns the total file size in bytes.
-     *
-     * <p>The file uses the standard {@link IndexFileFormat} layout. The header's
-     * nodeCount is the shard's local count, but all neighbor indices in the graph
-     * region are <b>global</b>.</p>
-     */
-    private static long writeShard(AbstractHnswIndex index, Path shardPath,
-                                    int startNode, int endNode,
-                                    int dimensions, HnswParams params,
-                                    int graphBlockSize, SimilarityFunction simFunc)
-            throws IOException {
-
-        int shardNodeCount = endNode - startNode;
-
-        // Compute layout
-        long vectorDataOffset = IndexFileFormat.HEADER_SIZE;
-        long vectorRegionSize = (long) shardNodeCount * dimensions * Float.BYTES;
-        long graphDataOffset = IndexFileFormat.alignToPage(vectorDataOffset + vectorRegionSize);
-        long graphRegionSize = (long) shardNodeCount * graphBlockSize;
-        long idTableOffset = IndexFileFormat.alignToPage(graphDataOffset + graphRegionSize);
-
-        // Compute ID table size
-        byte[][] idBytes = new byte[shardNodeCount][];
-        long idRegionSize = 0;
-        for (int i = 0; i < shardNodeCount; i++) {
-            idBytes[i] = index.getId(startNode + i).getBytes(StandardCharsets.UTF_8);
-            idRegionSize += 4 + idBytes[i].length;
-        }
-        long totalFileSize = IndexFileFormat.alignToPage(idTableOffset + idRegionSize);
-
-        // Create header (nodeCount = shard-local, entryPoint/maxLevel are shard-local too for format compat)
-        // Note: entryPoint and maxLevel in the shard header are set to 0 since the global values
-        // are stored in the manifest. The shard is not independently searchable.
-        var header = new IndexFileFormat.Header(
-                IndexFileFormat.MAGIC, IndexFileFormat.VERSION,
-                dimensions, shardNodeCount,
-                params.m(), params.maxLevel0Connections(),
-                0, 0, // shard-local entryPoint/maxLevel unused
-                simFunc.ordinal(), QuantizationType.NONE.ordinal(),
-                vectorDataOffset, graphDataOffset, idTableOffset,
-                graphBlockSize, totalFileSize
-        );
-
-        Path parent = shardPath.getParent();
-        if (parent != null) Files.createDirectories(parent);
-
-        try (var raf = new RandomAccessFile(shardPath.toFile(), "rw");
-             var channel = raf.getChannel()) {
-
-            raf.setLength(totalFileSize);
-            var arena = Arena.ofConfined();
-            var segment = channel.map(FileChannel.MapMode.READ_WRITE, 0, totalFileSize, arena);
-
-            // 1. Write header
-            IndexFileFormat.writeHeader(segment, header);
-
-            // 2. Write vectors (sequential within shard)
-            for (int i = 0; i < shardNodeCount; i++) {
-                float[] vector = index.getVector(startNode + i);
-                long offset = vectorDataOffset + (long) i * dimensions * Float.BYTES;
-                MemorySegment.copy(vector, 0, segment, IndexFileFormat.FLOAT_U, offset, dimensions);
-            }
-
-            // 3. Write graph blocks — neighbor indices remain GLOBAL
-            for (int i = 0; i < shardNodeCount; i++) {
-                int globalIdx = startNode + i;
-                long blockOffset = graphDataOffset + (long) i * graphBlockSize;
-                int level = index.getLevel(globalIdx);
-                segment.set(IndexFileFormat.INT_U, blockOffset, level);
-                long pos = blockOffset + 4;
-
-                // Layer 0 neighbors (global indices)
-                int[] layer0 = index.getNeighborsAtLayer(globalIdx, 0);
-                segment.set(IndexFileFormat.INT_U, pos, layer0.length);
-                pos += 4;
-                for (int j = 0; j < layer0.length; j++) {
-                    segment.set(IndexFileFormat.INT_U, pos + (long) j * 4, layer0[j]);
-                }
-                pos += (long) params.maxLevel0Connections() * 4;
-
-                // Upper layer neighbors (global indices)
-                for (int l = 1; l <= MAX_POSSIBLE_LEVELS; l++) {
-                    int[] layerN = l <= level
-                            ? index.getNeighborsAtLayer(globalIdx, l)
-                            : new int[0];
-                    segment.set(IndexFileFormat.INT_U, pos, layerN.length);
-                    pos += 4;
-                    for (int j = 0; j < layerN.length; j++) {
-                        segment.set(IndexFileFormat.INT_U, pos + (long) j * 4, layerN[j]);
-                    }
-                    pos += (long) params.m() * 4;
-                }
-            }
-
-            // 4. Write ID table
-            long idPos = idTableOffset;
-            for (int i = 0; i < shardNodeCount; i++) {
-                segment.set(IndexFileFormat.INT_U, idPos, idBytes[i].length);
-                idPos += 4;
-                MemorySegment.copy(idBytes[i], 0, segment, ValueLayout.JAVA_BYTE, idPos, idBytes[i].length);
-                idPos += idBytes[i].length;
-            }
-
-            segment.force();
-            arena.close();
-        }
-
-        return totalFileSize;
-    }
-}
diff --git a/spector-index/src/main/java/com/spectrayan/spector/index/ivf/FlatPostingList.java b/spector-index/src/main/java/com/spectrayan/spector/index/ivf/FlatPostingList.java
index c5f3e20..812217c 100644
--- a/spector-index/src/main/java/com/spectrayan/spector/index/ivf/FlatPostingList.java
+++ b/spector-index/src/main/java/com/spectrayan/spector/index/ivf/FlatPostingList.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.index.ivf;
 
 import java.util.Arrays;
diff --git a/spector-index/src/main/java/com/spectrayan/spector/index/ivf/IvfFlatIndex.java b/spector-index/src/main/java/com/spectrayan/spector/index/ivf/IvfFlatIndex.java
index e78a593..807a542 100644
--- a/spector-index/src/main/java/com/spectrayan/spector/index/ivf/IvfFlatIndex.java
+++ b/spector-index/src/main/java/com/spectrayan/spector/index/ivf/IvfFlatIndex.java
@@ -1,22 +1,6 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.index.ivf;
 
-import com.spectrayan.spector.core.cluster.KMeans;
-import com.spectrayan.spector.core.similarity.SimilarityFunction;
+import com.spectrayan.spector.core.SimilarityFunction;
 import com.spectrayan.spector.index.ScoredResult;
 import com.spectrayan.spector.index.VectorIndex;
 
@@ -24,11 +8,9 @@
 import org.slf4j.LoggerFactory;
 
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
-import java.util.concurrent.locks.StampedLock;
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-import com.spectrayan.spector.commons.error.SpectorInternalException;
-import com.spectrayan.spector.commons.error.ErrorCode;
+import java.util.concurrent.locks.ReentrantLock;
 
 /**
  * IVF-Flat (Inverted File with exact distance) vector index.
@@ -62,7 +44,6 @@ public class IvfFlatIndex implements VectorIndex {
     public static final int MAX_CELLS = 65_536;
 
     private static final int KMEANS_MAX_ITERATIONS = 25;
-    private static final long KMEANS_SEED = 42L;
 
     private final int dimensions;
     private final SimilarityFunction similarityFunction;
@@ -76,20 +57,7 @@ public class IvfFlatIndex implements VectorIndex {
     private List<FlatPostingList> postingLists;
     private volatile int totalVectors;
 
-    // ── Concurrency ──
-    //
-    // StampedLock provides three modes:
-    //   writeLock()         — exclusive, used by add()
-    //   readLock()          — shared, used as search() fallback
-    //   tryOptimisticRead() — lock-free! used as search() fast path
-    //
-    // In a read-dominant search workload (searches >> adds), the optimistic read
-    // succeeds on nearly every call because there is no concurrent writer.
-    // Cost: 2 CPU instructions (read stamp + validate stamp). Zero atomic ops.
-    // If a write races, validate() returns false and we fall back to readLock().
-    //
-    // VT note: StampedLock.readLock() uses LockSupport.park() — VTs unmount, not pin.
-    private final StampedLock stampedLock = new StampedLock();
+    private final ReentrantLock writeLock = new ReentrantLock();
 
     /**
      * Creates an IVF-Flat index.
@@ -99,7 +67,7 @@ public class IvfFlatIndex implements VectorIndex {
      */
     public IvfFlatIndex(int dimensions, SimilarityFunction similarityFunction) {
         if (dimensions <= 0) {
-            throw new SpectorValidationException(ErrorCode.DIMENSIONS_INVALID, dimensions);
+            throw new IllegalArgumentException("Dimensions must be positive, got " + dimensions);
         }
         this.dimensions = dimensions;
         this.similarityFunction = similarityFunction;
@@ -113,26 +81,29 @@ public IvfFlatIndex(int dimensions, SimilarityFunction similarityFunction) {
      * @param trainingVectors representative training vectors
      * @param numCells        number of Voronoi cells (partitions), must be between
      *                        {@link #MIN_CELLS} and {@link #MAX_CELLS}
-     * @throws SpectorValidationException if numCells is out of range or training set is too small
-     * @throws SpectorValidationException    if the index has already been trained
+     * @throws IllegalArgumentException if numCells is out of range or training set is too small
+     * @throws IllegalStateException    if the index has already been trained
      */
     public void train(float[][] trainingVectors, int numCells) {
         if (trained) {
-            throw new SpectorInternalException(ErrorCode.INVARIANT_VIOLATED, "Index already trained");
+            throw new IllegalStateException("Index has already been trained.");
         }
         if (numCells < MIN_CELLS || numCells > MAX_CELLS) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_OUT_OF_RANGE, "numCells", MIN_CELLS, MAX_CELLS, numCells);
+            throw new IllegalArgumentException(
+                    "numCells must be between " + MIN_CELLS + " and " + MAX_CELLS + ", got " + numCells);
         }
         if (trainingVectors == null || trainingVectors.length < numCells) {
             int provided = (trainingVectors == null) ? 0 : trainingVectors.length;
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_INVALID, "Training requires at least " + numCells + " vectors (the configured number of cells), " + "but only " + provided + " were provided.");
+            throw new IllegalArgumentException(
+                    "Training requires at least " + numCells + " vectors (the configured number of cells), "
+                            + "but only " + provided + " were provided.");
         }
 
         log.info("Training IVF-Flat: {} samples, numCells={}", trainingVectors.length, numCells);
         long start = System.nanoTime();
 
         this.numCells = numCells;
-        this.centroids = KMeans.train(trainingVectors, numCells, KMEANS_MAX_ITERATIONS, KMEANS_SEED);
+        this.centroids = trainCentroids(trainingVectors, numCells);
 
         // Initialize posting lists
         this.postingLists = new ArrayList<>(numCells);
@@ -148,19 +119,19 @@ public void train(float[][] trainingVectors, int numCells) {
     @Override
     public void add(String id, int storeIndex, float[] vector) {
         if (!trained) {
-            throw new SpectorInternalException(ErrorCode.INDEX_NOT_TRAINED);
+            throw new IllegalStateException("Index must be trained before adding vectors. Call train() first.");
         }
         if (vector.length != dimensions) {
-            throw new SpectorValidationException(ErrorCode.DIMENSIONS_MISMATCH, dimensions, vector.length);
+            throw new IllegalArgumentException("Expected " + dimensions + " dims, got " + vector.length);
         }
 
-        long stamp = stampedLock.writeLock();
+        writeLock.lock();
         try {
-            int cell = KMeans.nearestCentroid(vector, centroids);
+            int cell = nearestCentroid(vector);
             postingLists.get(cell).add(id, storeIndex, vector);
             totalVectors++;
         } finally {
-            stampedLock.unlockWrite(stamp);
+            writeLock.unlock();
         }
     }
 
@@ -171,72 +142,26 @@ public void add(String id, int storeIndex, float[] vector) {
      * @param nprobe number of cells to probe (1 to numCells)
      * @param topK   number of results to return
      * @return scored results sorted by relevance
-     * @throws SpectorValidationException    if the index is not trained
-     * @throws SpectorValidationException if nprobe is invalid
+     * @throws IllegalStateException    if the index is not trained
+     * @throws IllegalArgumentException if nprobe is invalid
      */
     public ScoredResult[] search(float[] query, int nprobe, int topK) {
         if (!trained) {
-            throw new SpectorInternalException(ErrorCode.INDEX_NOT_TRAINED);
+            throw new IllegalStateException("Index must be trained before searching. Call train() first.");
         }
         if (query.length != dimensions) {
-            throw new SpectorValidationException(ErrorCode.DIMENSIONS_MISMATCH, dimensions, query.length);
+            throw new IllegalArgumentException("Expected " + dimensions + " dims, got " + query.length);
         }
         if (nprobe < 1 || nprobe > numCells) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_OUT_OF_RANGE, "nprobe", 1, numCells, nprobe);
+            throw new IllegalArgumentException(
+                    "nprobe must be between 1 and " + numCells + ", got " + nprobe);
         }
         if (totalVectors == 0) {
             return new ScoredResult[0];
         }
 
-        // ── Optimistic read (lock-free fast path for read-dominant workloads) ──
-        //
-        // tryOptimisticRead() returns a stamp without acquiring any lock.
-        // We read all shared data under this stamp, then validate it.
-        // If no write occurred during our read, validate() returns true and we're done.
-        // If a write raced us, validate() returns false and we fall back to readLock().
-        //
-        // Key: local variables snapshot the array references and size before reading
-        // elements. Even if a grow() replaces the backing arrays during our read,
-        // our local references still point to the old (valid) arrays which contain
-        // consistent data for all indices [0, localSize).
-        long stamp = stampedLock.tryOptimisticRead();
-        ScoredResult[] result = trySearchOptimistic(query, nprobe, topK, stamp);
-        if (result != null) return result;
-
-        // ── Fallback: shared readLock (rare — only when a concurrent add() races) ──
-        stamp = stampedLock.readLock();
-        try {
-            return doSearch(query, nprobe, topK);
-        } finally {
-            stampedLock.unlockRead(stamp);
-        }
-    }
-
-    /**
-     * Attempts an optimistic (lock-free) search.
-     * Returns null if a concurrent write was detected, signalling the caller to retry
-     * under a readLock.
-     */
-    private ScoredResult[] trySearchOptimistic(float[] query, int nprobe, int topK, long stamp) {
-        // Snapshot mutable state under the optimistic stamp
-        int tv = totalVectors;
-        if (!stampedLock.validate(stamp)) return null;
-        if (tv == 0) return new ScoredResult[0];
-
-        ScoredResult[] result = doSearch(query, nprobe, topK);
-
-        // Validate: if any write happened during doSearch(), result may be stale
-        // (but not corrupted — local references are stable). We return it if valid;
-        // if invalid, caller retries under readLock for a strictly consistent view.
-        return stampedLock.validate(stamp) ? result : null;
-    }
-
-    /** Core search logic — called under either optimistic stamp or readLock. */
-    private ScoredResult[] doSearch(float[] query, int nprobe, int topK) {
-        if (totalVectors == 0) return new ScoredResult[0];
-
         // Find the nprobe nearest centroids
-        int[] probeCells = KMeans.nearestCentroids(query, centroids, nprobe);
+        int[] probeCells = findNearestCentroids(query, nprobe);
 
         // Exhaustive scan within probed cells using exact distance
         List<ScoredResult> candidates = new ArrayList<>();
@@ -245,13 +170,13 @@ private ScoredResult[] doSearch(float[] query, int nprobe, int topK) {
             int size = plist.size();
             if (size == 0) continue;
 
-            // Snapshot array references locally — stable even if grow() swaps arrays
-            String[]   ids     = plist.ids();
-            int[]      indices = plist.storeIndices();
-            float[][]  vectors = plist.vectors();
+            String[] ids = plist.ids();
+            int[] indices = plist.storeIndices();
+            float[][] vectors = plist.vectors();
 
             for (int i = 0; i < size; i++) {
                 float score = similarityFunction.compute(query, vectors[i]);
+                // For distance metrics (lower is better), convert to a similarity score
                 if (!similarityFunction.higherIsBetter()) {
                     score = 1.0f / (1.0f + score);
                 }
@@ -259,7 +184,9 @@ private ScoredResult[] doSearch(float[] query, int nprobe, int topK) {
             }
         }
 
+        // Sort descending by score
         candidates.sort(null); // ScoredResult.compareTo is descending
+
         int resultCount = Math.min(topK, candidates.size());
         return candidates.subList(0, resultCount).toArray(ScoredResult[]::new);
     }
@@ -303,4 +230,122 @@ public int dimensions() {
         return dimensions;
     }
 
-}
\ No newline at end of file
+    // ─────────────── K-Means Training ───────────────
+
+    private float[][] trainCentroids(float[][] samples, int k) {
+        int n = samples.length;
+        float[][] centers = new float[k][dimensions];
+        java.util.Random rng = new java.util.Random(42);
+
+        // K-Means++ initialization
+        System.arraycopy(samples[rng.nextInt(n)], 0, centers[0], 0, dimensions);
+        float[] minDists = new float[n];
+        Arrays.fill(minDists, Float.MAX_VALUE);
+
+        for (int c = 1; c < k; c++) {
+            double totalDist = 0;
+            for (int i = 0; i < n; i++) {
+                float d = squaredL2(samples[i], centers[c - 1]);
+                if (d < minDists[i]) {
+                    minDists[i] = d;
+                }
+                totalDist += minDists[i];
+            }
+            double target = rng.nextDouble() * totalDist;
+            double cumulative = 0;
+            int selected = 0;
+            for (int i = 0; i < n; i++) {
+                cumulative += minDists[i];
+                if (cumulative >= target) {
+                    selected = i;
+                    break;
+                }
+            }
+            System.arraycopy(samples[selected], 0, centers[c], 0, dimensions);
+        }
+
+        // K-Means iterations
+        int[] assignments = new int[n];
+        for (int iter = 0; iter < KMEANS_MAX_ITERATIONS; iter++) {
+            boolean changed = false;
+            for (int i = 0; i < n; i++) {
+                int nearest = nearestCentroidIdx(samples[i], centers, k);
+                if (nearest != assignments[i]) {
+                    assignments[i] = nearest;
+                    changed = true;
+                }
+            }
+            if (!changed) break;
+
+            // Recompute centroids
+            float[][] newCenters = new float[k][dimensions];
+            int[] counts = new int[k];
+            for (int i = 0; i < n; i++) {
+                counts[assignments[i]]++;
+                for (int d = 0; d < dimensions; d++) {
+                    newCenters[assignments[i]][d] += samples[i][d];
+                }
+            }
+            for (int c = 0; c < k; c++) {
+                if (counts[c] > 0) {
+                    for (int d = 0; d < dimensions; d++) {
+                        newCenters[c][d] /= counts[c];
+                    }
+                    centers[c] = newCenters[c];
+                }
+                // If a cluster is empty, keep its previous centroid
+            }
+        }
+
+        return centers;
+    }
+
+    // ─────────────── Helpers ───────────────
+
+    private int nearestCentroid(float[] vector) {
+        return nearestCentroidIdx(vector, centroids, numCells);
+    }
+
+    private static int nearestCentroidIdx(float[] vector, float[][] centroids, int k) {
+        int best = 0;
+        float bestDist = Float.MAX_VALUE;
+        for (int c = 0; c < k; c++) {
+            float dist = squaredL2(vector, centroids[c]);
+            if (dist < bestDist) {
+                bestDist = dist;
+                best = c;
+            }
+        }
+        return best;
+    }
+
+    private int[] findNearestCentroids(float[] query, int nprobe) {
+        int actualProbe = Math.min(nprobe, numCells);
+        float[] dists = new float[numCells];
+        for (int c = 0; c < numCells; c++) {
+            dists[c] = squaredL2(query, centroids[c]);
+        }
+
+        // Partial sort: find top-nprobe nearest
+        Integer[] indices = new Integer[numCells];
+        for (int i = 0; i < numCells; i++) {
+            indices[i] = i;
+        }
+        Arrays.sort(indices, (a, b) -> Float.compare(dists[a], dists[b]));
+
+        int[] result = new int[actualProbe];
+        for (int i = 0; i < actualProbe; i++) {
+            result[i] = indices[i];
+        }
+        return result;
+    }
+
+    private static float squaredL2(float[] a, float[] b) {
+        float sum = 0;
+        for (int i = 0; i < a.length; i++) {
+            float diff = a[i] - b[i];
+            sum += diff * diff;
+        }
+        return sum;
+    }
+}
diff --git a/spector-index/src/main/java/com/spectrayan/spector/index/ivf/IvfPqIndex.java b/spector-index/src/main/java/com/spectrayan/spector/index/ivf/IvfPqIndex.java
index 0483d44..9c4c807 100644
--- a/spector-index/src/main/java/com/spectrayan/spector/index/ivf/IvfPqIndex.java
+++ b/spector-index/src/main/java/com/spectrayan/spector/index/ivf/IvfPqIndex.java
@@ -1,22 +1,6 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.index.ivf;
 
-import com.spectrayan.spector.core.cluster.KMeans;
-import com.spectrayan.spector.core.similarity.SimilarityFunction;
+import com.spectrayan.spector.core.SimilarityFunction;
 import com.spectrayan.spector.index.NeighborQueue;
 import com.spectrayan.spector.index.ScoredResult;
 import com.spectrayan.spector.index.VectorIndex;
@@ -26,11 +10,9 @@
 import org.slf4j.LoggerFactory;
 
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
-import java.util.concurrent.locks.StampedLock;
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-import com.spectrayan.spector.commons.error.SpectorInternalException;
-import com.spectrayan.spector.commons.error.ErrorCode;
+import java.util.concurrent.locks.ReentrantLock;
 
 /**
  * IVF-PQ (Inverted File with Product Quantization) vector index.
@@ -79,10 +61,7 @@ public class IvfPqIndex implements VectorIndex {
     private final List<PostingList> postingLists;  // per-cluster posting lists
     private volatile int totalVectors;
 
-    // ── Concurrency: StampedLock ──
-    // Optimistic read (lock-free) for searches; exclusive writeLock for adds.
-    // VT-safe: readLock fallback uses LockSupport.park(), never pins virtual threads.
-    private final StampedLock stampedLock = new StampedLock();
+    private final ReentrantLock writeLock = new ReentrantLock();
 
     /**
      * Creates an IVF-PQ index.
@@ -96,7 +75,8 @@ public class IvfPqIndex implements VectorIndex {
     public IvfPqIndex(int dimensions, int nlist, int nprobe, int numSubspaces,
                        SimilarityFunction similarityFunction) {
         if (dimensions % numSubspaces != 0) {
-            throw new SpectorValidationException(ErrorCode.DIMENSIONS_MISMATCH, "dimensions (" + dimensions + ") must be divisible by numSubspaces (" + numSubspaces + ")");
+            throw new IllegalArgumentException(
+                    "dimensions (" + dimensions + ") must be divisible by numSubspaces (" + numSubspaces + ")");
         }
         this.dimensions = dimensions;
         this.nlist = nlist;
@@ -146,20 +126,21 @@ public IvfPqIndex(int dimensions, int expectedSize) {
      */
     public void train(float[][] samples) {
         if (samples.length < nlist) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_INVALID, "Need at least nlist (" + nlist + ") samples, got " + samples.length);
+            throw new IllegalArgumentException(
+                    "Need at least nlist (" + nlist + ") samples, got " + samples.length);
         }
 
         log.info("Training IVF-PQ: {} samples, nlist={}, M={}", samples.length, nlist, numSubspaces);
         long start = System.nanoTime();
 
         // Step 1: Train IVF centroids via K-Means
-        this.centroids = KMeans.train(samples, nlist, 25, 42L);
+        this.centroids = trainCentroids(samples);
 
         // Step 2: Compute residuals (vector - nearest centroid)
         // PQ is trained on residuals for better accuracy
         float[][] residuals = new float[samples.length][dimensions];
         for (int i = 0; i < samples.length; i++) {
-            int cluster = KMeans.nearestCentroid(samples[i], centroids);
+            int cluster = nearestCentroid(samples[i]);
             for (int d = 0; d < dimensions; d++) {
                 residuals[i][d] = samples[i][d] - centroids[cluster][d];
             }
@@ -176,16 +157,16 @@ public void train(float[][] samples) {
     @Override
     public void add(String id, int storeIndex, float[] vector) {
         if (!trained) {
-            throw new SpectorInternalException(ErrorCode.INDEX_NOT_TRAINED);
+            throw new IllegalStateException("Index must be trained before adding vectors. Call train() first.");
         }
         if (vector.length != dimensions) {
-            throw new SpectorValidationException(ErrorCode.DIMENSIONS_MISMATCH, dimensions, vector.length);
+            throw new IllegalArgumentException("Expected " + dimensions + " dims, got " + vector.length);
         }
 
-        long stamp = stampedLock.writeLock();
+        writeLock.lock();
         try {
             // Assign to nearest cluster
-            int cluster = KMeans.nearestCentroid(vector, centroids);
+            int cluster = nearestCentroid(vector);
 
             // Compute residual and PQ-encode
             float[] residual = new float[dimensions];
@@ -198,55 +179,24 @@ public void add(String id, int storeIndex, float[] vector) {
             postingLists.get(cluster).add(id, storeIndex, code);
             totalVectors++;
         } finally {
-            stampedLock.unlockWrite(stamp);
+            writeLock.unlock();
         }
     }
 
     @Override
     public ScoredResult[] search(float[] query, int k) {
         if (!trained) {
-            throw new SpectorInternalException(ErrorCode.INDEX_NOT_TRAINED);
+            throw new IllegalStateException("Index must be trained before searching.");
         }
         if (query.length != dimensions) {
-            throw new SpectorValidationException(ErrorCode.DIMENSIONS_MISMATCH, dimensions, query.length);
+            throw new IllegalArgumentException("Expected " + dimensions + " dims, got " + query.length);
         }
         if (totalVectors == 0) {
             return new ScoredResult[0];
         }
 
-        // ── Optimistic read — lock-free fast path ──
-        long stamp = stampedLock.tryOptimisticRead();
-        ScoredResult[] result = trySearchOptimistic(query, k, stamp);
-        if (result != null) return result;
-
-        // ── Fallback to shared readLock (concurrent add detected) ──
-        stamp = stampedLock.readLock();
-        try {
-            return doSearch(query, k);
-        } finally {
-            stampedLock.unlockRead(stamp);
-        }
-    }
-
-    /**
-     * Lock-free optimistic search attempt.
-     * Returns null if a concurrent write was detected; caller retries under readLock.
-     */
-    private ScoredResult[] trySearchOptimistic(float[] query, int k, long stamp) {
-        int tv = totalVectors;
-        if (!stampedLock.validate(stamp)) return null;
-        if (tv == 0) return new ScoredResult[0];
-
-        ScoredResult[] result = doSearch(query, k);
-        return stampedLock.validate(stamp) ? result : null;
-    }
-
-    /** Core search logic — safe to call under optimistic stamp or readLock. */
-    private ScoredResult[] doSearch(float[] query, int k) {
-        if (totalVectors == 0) return new ScoredResult[0];
-
         // Step 1: Find the nprobe nearest cluster centroids
-        int[] probeClusters = KMeans.nearestCentroids(query, centroids, nprobe);
+        int[] probeClusters = findNearestClusters(query, nprobe);
 
         // Step 2: Collect all candidates from probed clusters with ADC distances
         List<ScoredResult> candidates = new ArrayList<>();
@@ -255,28 +205,33 @@ private ScoredResult[] doSearch(float[] query, int k) {
             PostingList plist = postingLists.get(clusterIdx);
             if (plist.size() == 0) continue;
 
-            // Snapshot array references — stable even if a concurrent grow() swaps arrays
+            // Compute residual query for this cluster
             float[] residualQuery = new float[dimensions];
             for (int d = 0; d < dimensions; d++) {
                 residualQuery[d] = query[d] - centroids[clusterIdx][d];
             }
 
+            // Precompute ADC distance table for this cluster's residual query
             float[][] distTable = pq.computeDistanceTable(residualQuery);
 
-            int       size    = plist.size();
-            byte[][]  codes   = plist.codes();
-            String[]  ids     = plist.ids();
-            int[]     indices = plist.storeIndices();
+            // Scan all codes in this posting list
+            int size = plist.size();
+            byte[][] codes = plist.codes();
+            String[] ids = plist.ids();
+            int[] indices = plist.storeIndices();
 
             for (int i = 0; i < size; i++) {
-                float dist  = ProductQuantizer.adcDistance(distTable, codes[i]);
+                float dist = ProductQuantizer.adcDistance(distTable, codes[i]);
+                // Convert L2 distance to similarity score (lower dist = higher similarity)
                 float score = 1.0f / (1.0f + dist);
                 candidates.add(new ScoredResult(ids[i], indices[i], score));
             }
         }
 
-        // Step 3: Sort by score descending and return top-k
-        candidates.sort(java.util.Comparator.naturalOrder());
+        // Step 3: Sort by score descending (highest similarity first)
+        candidates.sort(java.util.Comparator.naturalOrder()); // ScoredResult.compareTo is descending
+
+        // Return top-k
         int resultCount = Math.min(k, candidates.size());
         return candidates.subList(0, resultCount).toArray(ScoredResult[]::new);
     }
@@ -304,7 +259,122 @@ public void close() {
     /** Returns the product quantizer (null if not trained). */
     public ProductQuantizer quantizer() { return pq; }
 
+    // ─────────────── IVF K-Means training ───────────────
+
+    private float[][] trainCentroids(float[][] samples) {
+        int n = samples.length;
+        float[][] centers = new float[nlist][dimensions];
+        java.util.Random rng = new java.util.Random(42);
+
+        // K-Means++ initialization
+        System.arraycopy(samples[rng.nextInt(n)], 0, centers[0], 0, dimensions);
+        float[] minDists = new float[n];
+        Arrays.fill(minDists, Float.MAX_VALUE);
+
+        for (int c = 1; c < nlist; c++) {
+            double totalDist = 0;
+            for (int i = 0; i < n; i++) {
+                float d = squaredL2(samples[i], centers[c - 1]);
+                if (d < minDists[i]) minDists[i] = d;
+                totalDist += minDists[i];
+            }
+            double target = rng.nextDouble() * totalDist;
+            double cumulative = 0;
+            int selected = 0;
+            for (int i = 0; i < n; i++) {
+                cumulative += minDists[i];
+                if (cumulative >= target) { selected = i; break; }
+            }
+            System.arraycopy(samples[selected], 0, centers[c], 0, dimensions);
+        }
+
+        // K-Means iterations
+        int[] assignments = new int[n];
+        for (int iter = 0; iter < 25; iter++) {
+            boolean changed = false;
+            for (int i = 0; i < n; i++) {
+                int nearest = nearestCentroidIdx(samples[i], centers);
+                if (nearest != assignments[i]) {
+                    assignments[i] = nearest;
+                    changed = true;
+                }
+            }
+            if (!changed) break;
+
+            float[][] newCenters = new float[nlist][dimensions];
+            int[] counts = new int[nlist];
+            for (int i = 0; i < n; i++) {
+                counts[assignments[i]]++;
+                for (int d = 0; d < dimensions; d++) {
+                    newCenters[assignments[i]][d] += samples[i][d];
+                }
+            }
+            for (int c = 0; c < nlist; c++) {
+                if (counts[c] > 0) {
+                    for (int d = 0; d < dimensions; d++) {
+                        newCenters[c][d] /= counts[c];
+                    }
+                    centers[c] = newCenters[c];
+                }
+            }
+        }
+
+        return centers;
+    }
+
+    // ─────────────── Helpers ───────────────
+
+    private int nearestCentroid(float[] vector) {
+        return nearestCentroidIdx(vector, centroids);
+    }
+
+    private static int nearestCentroidIdx(float[] vector, float[][] centroids) {
+        int best = 0;
+        float bestDist = Float.MAX_VALUE;
+        for (int k = 0; k < centroids.length; k++) {
+            float dist = squaredL2(vector, centroids[k]);
+            if (dist < bestDist) {
+                bestDist = dist;
+                best = k;
+            }
+        }
+        return best;
+    }
+
+    private int[] findNearestClusters(float[] query, int probe) {
+        int actualProbe = Math.min(probe, nlist);
+        // Simple: compute distances to all centroids, pick top-nprobe
+        float[] dists = new float[nlist];
+        for (int c = 0; c < nlist; c++) {
+            dists[c] = squaredL2(query, centroids[c]);
+        }
+
+        // Partial sort to find top-nprobe nearest
+        Integer[] indices = new Integer[nlist];
+        for (int i = 0; i < nlist; i++) indices[i] = i;
+        Arrays.sort(indices, (a, b) -> Float.compare(dists[a], dists[b]));
+
+        int[] result = new int[actualProbe];
+        for (int i = 0; i < actualProbe; i++) {
+            result[i] = indices[i];
+        }
+        return result;
+    }
+
+    private String findIdByStoreIndex(int storeIndex) {
+        for (PostingList plist : postingLists) {
+            String id = plist.findId(storeIndex);
+            if (id != null) return id;
+        }
+        return null;
+    }
+
     private static float squaredL2(float[] a, float[] b) {
-        return KMeans.squaredL2(a, b);
+        float sum = 0;
+        for (int i = 0; i < a.length; i++) {
+            float diff = a[i] - b[i];
+            sum += diff * diff;
+        }
+        return sum;
     }
-}
\ No newline at end of file
+}
diff --git a/spector-index/src/main/java/com/spectrayan/spector/index/ivf/PostingList.java b/spector-index/src/main/java/com/spectrayan/spector/index/ivf/PostingList.java
index 5c34147..a567895 100644
--- a/spector-index/src/main/java/com/spectrayan/spector/index/ivf/PostingList.java
+++ b/spector-index/src/main/java/com/spectrayan/spector/index/ivf/PostingList.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.index.ivf;
 
 import java.util.Arrays;
diff --git a/spector-index/src/main/java/com/spectrayan/spector/index/ivf/QuantizedIvfPqIndex.java b/spector-index/src/main/java/com/spectrayan/spector/index/ivf/QuantizedIvfPqIndex.java
index 5dc1ac9..61fed3a 100644
--- a/spector-index/src/main/java/com/spectrayan/spector/index/ivf/QuantizedIvfPqIndex.java
+++ b/spector-index/src/main/java/com/spectrayan/spector/index/ivf/QuantizedIvfPqIndex.java
@@ -1,41 +1,22 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.index.ivf;
 
-import com.spectrayan.spector.core.cluster.KMeans;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
-import java.util.concurrent.locks.StampedLock;
+import java.util.concurrent.locks.ReentrantLock;
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import com.spectrayan.spector.core.quantization.CrumbPacker;
-import com.spectrayan.spector.core.quantization.NibblePacker;
-import com.spectrayan.spector.core.quantization.NonUniformQuantizer;
-import com.spectrayan.spector.core.similarity.PackedDotProduct;
-import com.spectrayan.spector.core.quantization.QuantizationType;
-import com.spectrayan.spector.core.similarity.SimilarityFunction;
+import com.spectrayan.spector.core.CrumbPacker;
+import com.spectrayan.spector.core.NibblePacker;
+import com.spectrayan.spector.core.NonUniformQuantizer;
+import com.spectrayan.spector.core.PackedDotProduct;
+import com.spectrayan.spector.core.QuantizationType;
+import com.spectrayan.spector.core.SimilarityFunction;
 import com.spectrayan.spector.index.ScoredResult;
 import com.spectrayan.spector.index.VectorIndex;
 import com.spectrayan.spector.index.pq.ProductQuantizer;
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-import com.spectrayan.spector.commons.error.SpectorInternalException;
-import com.spectrayan.spector.commons.error.ErrorCode;
 
 /**
  * IVF-PQ vector index with INT4/INT2 quantization support and configurable rescore strategy.
@@ -85,12 +66,7 @@ public class QuantizedIvfPqIndex implements VectorIndex {
     private final List<String> vectorIds;         // document IDs indexed by insert order
     private volatile int totalVectors;
 
-    // ── Concurrency: StampedLock ──
-    // Optimistic read (lock-free) for searches; exclusive writeLock for adds.
-    // floatVectors (ArrayList) and postingLists are safely readable under the optimistic
-    // stamp as long as we access only indices < totalVectors (written before count increment).
-    // VT-safe: readLock fallback uses LockSupport.park(), never pins virtual threads.
-    private final StampedLock stampedLock = new StampedLock();
+    private final ReentrantLock writeLock = new ReentrantLock();
 
     /**
      * Creates a quantized IVF-PQ index with INT4/INT2 support and configurable rescore.
@@ -110,11 +86,13 @@ public QuantizedIvfPqIndex(int dimensions, int nlist, int nprobe, int numSubspac
                                 NonUniformQuantizer nonUniformQuantizer,
                                 int oversamplingFactor) {
         if (dimensions % numSubspaces != 0) {
-            throw new SpectorValidationException(ErrorCode.DIMENSIONS_MISMATCH, "dimensions (" + dimensions + ") must be divisible by numSubspaces (" + numSubspaces + ")");
+            throw new IllegalArgumentException(
+                    "dimensions (" + dimensions + ") must be divisible by numSubspaces (" + numSubspaces + ")");
         }
         if (quantizationType == QuantizationType.SCALAR_INT4 || quantizationType == QuantizationType.SCALAR_INT2) {
             if (nonUniformQuantizer == null) {
-                throw new SpectorValidationException(ErrorCode.ARGUMENT_NULL, "NonUniformQuantizer (required for " + quantizationType + ")");
+                throw new IllegalArgumentException(
+                        "NonUniformQuantizer is required for " + quantizationType);
             }
         }
 
@@ -171,7 +149,8 @@ public QuantizedIvfPqIndex(int dimensions, int nlist, int nprobe, int numSubspac
      */
     public void train(float[][] samples) {
         if (samples.length < nlist) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_INVALID, "Need at least nlist (" + nlist + ") samples, got " + samples.length);
+            throw new IllegalArgumentException(
+                    "Need at least nlist (" + nlist + ") samples, got " + samples.length);
         }
 
         log.info("Training QuantizedIvfPqIndex: {} samples, nlist={}, M={}, type={}",
@@ -179,7 +158,7 @@ public void train(float[][] samples) {
         long start = System.nanoTime();
 
         // Step 1: Train IVF centroids via K-Means
-        this.centroids = KMeans.train(samples, nlist, 25, 42L);
+        this.centroids = trainCentroids(samples);
 
         // Step 2: Pack centroids for INT4/INT2 coarse quantizer
         if (quantizationType == QuantizationType.SCALAR_INT4
@@ -190,7 +169,7 @@ public void train(float[][] samples) {
         // Step 3: Compute residuals (vector - nearest centroid)
         float[][] residuals = new float[samples.length][dimensions];
         for (int i = 0; i < samples.length; i++) {
-            int cluster = KMeans.nearestCentroid(samples[i], centroids);
+            int cluster = nearestCentroid(samples[i]);
             for (int d = 0; d < dimensions; d++) {
                 residuals[i][d] = samples[i][d] - centroids[cluster][d];
             }
@@ -207,13 +186,13 @@ public void train(float[][] samples) {
     @Override
     public void add(String id, int storeIndex, float[] vector) {
         if (!trained) {
-            throw new SpectorInternalException(ErrorCode.INDEX_NOT_TRAINED);
+            throw new IllegalStateException("Index must be trained before adding vectors. Call train() first.");
         }
         if (vector.length != dimensions) {
-            throw new SpectorValidationException(ErrorCode.DIMENSIONS_MISMATCH, dimensions, vector.length);
+            throw new IllegalArgumentException("Expected " + dimensions + " dims, got " + vector.length);
         }
 
-        long stamp = stampedLock.writeLock();
+        writeLock.lock();
         try {
             // Store full-precision vector for rescore
             int internalIndex = totalVectors;
@@ -236,64 +215,39 @@ public void add(String id, int storeIndex, float[] vector) {
             postingLists.get(cluster).add(id, internalIndex, code);
             totalVectors++;
         } finally {
-            stampedLock.unlockWrite(stamp);
+            writeLock.unlock();
         }
     }
 
     @Override
     public ScoredResult[] search(float[] query, int k) {
         if (!trained) {
-            throw new SpectorInternalException(ErrorCode.INDEX_NOT_TRAINED);
+            throw new IllegalStateException("Index must be trained before searching.");
         }
         if (query.length != dimensions) {
-            throw new SpectorValidationException(ErrorCode.DIMENSIONS_MISMATCH, dimensions, query.length);
+            throw new IllegalArgumentException("Expected " + dimensions + " dims, got " + query.length);
         }
         if (totalVectors == 0) {
             return new ScoredResult[0];
         }
 
-        // ── Optimistic read — lock-free fast path ──
-        long stamp = stampedLock.tryOptimisticRead();
-        ScoredResult[] result = trySearchOptimistic(query, k, stamp);
-        if (result != null) return result;
-
-        // ── Fallback to shared readLock (concurrent add detected) ──
-        stamp = stampedLock.readLock();
-        try {
-            return doSearch(query, k);
-        } finally {
-            stampedLock.unlockRead(stamp);
-        }
-    }
-
-    /**
-     * Lock-free optimistic search attempt.
-     * Returns null if a concurrent write was detected; caller retries under readLock.
-     */
-    private ScoredResult[] trySearchOptimistic(float[] query, int k, long stamp) {
-        int tv = totalVectors;
-        if (!stampedLock.validate(stamp)) return null;
-        if (tv == 0) return new ScoredResult[0];
-
-        ScoredResult[] result = doSearch(query, k);
-        return stampedLock.validate(stamp) ? result : null;
-    }
-
-    /** Core search logic — safe under optimistic stamp or readLock. */
-    private ScoredResult[] doSearch(float[] query, int k) {
-        if (totalVectors == 0) return new ScoredResult[0];
-
+        // Determine effective K for coarse search based on oversampling
         int effectiveK = oversamplingFactor > 1
                 ? Math.min(oversamplingFactor * k, totalVectors)
                 : k;
 
+        // Step 1: Find the nprobe nearest cluster centroids
         int[] probeClusters = findNearestClusters(query, nprobe);
+
+        // Step 2: Collect candidates from probed clusters
         List<ScoredResult> candidates = collectCandidates(query, probeClusters, effectiveK);
 
+        // Step 3: If oversampling > 1, rescore with exact float32 distances
         if (oversamplingFactor > 1 && !candidates.isEmpty()) {
             return rescoreAndReturn(query, candidates, k);
         }
 
+        // No rescore: return top-k from quantized search
         int resultCount = Math.min(k, candidates.size());
         return candidates.subList(0, resultCount).toArray(ScoredResult[]::new);
     }
@@ -485,7 +439,7 @@ private int nearestCentroidL2(float[] vector) {
         int best = 0;
         float bestDist = Float.MAX_VALUE;
         for (int k = 0; k < nlist; k++) {
-            float dist = KMeans.squaredL2(vector, centroids[k]);
+            float dist = squaredL2(vector, centroids[k]);
             if (dist < bestDist) {
                 bestDist = dist;
                 best = k;
@@ -545,12 +499,100 @@ private int[] findNearestClustersPacked(float[] query, int actualProbe) {
     }
 
     private int[] findNearestClustersL2(float[] query, int actualProbe) {
-        return KMeans.nearestCentroids(query, centroids, actualProbe);
+        float[] dists = new float[nlist];
+        for (int c = 0; c < nlist; c++) {
+            dists[c] = squaredL2(query, centroids[c]);
+        }
+
+        Integer[] indices = new Integer[nlist];
+        for (int i = 0; i < nlist; i++) indices[i] = i;
+        Arrays.sort(indices, (a, b) -> Float.compare(dists[a], dists[b]));
+
+        int[] result = new int[actualProbe];
+        for (int i = 0; i < actualProbe; i++) {
+            result[i] = indices[i];
+        }
+        return result;
     }
 
+    // ─────────────── IVF K-Means training ───────────────
+
+    private float[][] trainCentroids(float[][] samples) {
+        int n = samples.length;
+        float[][] centers = new float[nlist][dimensions];
+        java.util.Random rng = new java.util.Random(42);
+
+        // K-Means++ initialization
+        System.arraycopy(samples[rng.nextInt(n)], 0, centers[0], 0, dimensions);
+        float[] minDists = new float[n];
+        Arrays.fill(minDists, Float.MAX_VALUE);
+
+        for (int c = 1; c < nlist; c++) {
+            double totalDist = 0;
+            for (int i = 0; i < n; i++) {
+                float d = squaredL2(samples[i], centers[c - 1]);
+                if (d < minDists[i]) minDists[i] = d;
+                totalDist += minDists[i];
+            }
+            double target = rng.nextDouble() * totalDist;
+            double cumulative = 0;
+            int selected = 0;
+            for (int i = 0; i < n; i++) {
+                cumulative += minDists[i];
+                if (cumulative >= target) { selected = i; break; }
+            }
+            System.arraycopy(samples[selected], 0, centers[c], 0, dimensions);
+        }
+
+        // K-Means iterations
+        int[] assignments = new int[n];
+        for (int iter = 0; iter < 25; iter++) {
+            boolean changed = false;
+            for (int i = 0; i < n; i++) {
+                int nearest = nearestCentroidIdx(samples[i], centers);
+                if (nearest != assignments[i]) {
+                    assignments[i] = nearest;
+                    changed = true;
+                }
+            }
+            if (!changed) break;
+
+            float[][] newCenters = new float[nlist][dimensions];
+            int[] counts = new int[nlist];
+            for (int i = 0; i < n; i++) {
+                counts[assignments[i]]++;
+                for (int d = 0; d < dimensions; d++) {
+                    newCenters[assignments[i]][d] += samples[i][d];
+                }
+            }
+            for (int c = 0; c < nlist; c++) {
+                if (counts[c] > 0) {
+                    for (int d = 0; d < dimensions; d++) {
+                        newCenters[c][d] /= counts[c];
+                    }
+                    centers[c] = newCenters[c];
+                }
+            }
+        }
+
+        return centers;
+    }
 
     // ─────────────── Helpers ───────────────
 
+    private static int nearestCentroidIdx(float[] vector, float[][] centroids) {
+        int best = 0;
+        float bestDist = Float.MAX_VALUE;
+        for (int k = 0; k < centroids.length; k++) {
+            float dist = squaredL2(vector, centroids[k]);
+            if (dist < bestDist) {
+                bestDist = dist;
+                best = k;
+            }
+        }
+        return best;
+    }
+
     /**
      * Computes global centroids by averaging per-dimension centroids from the NonUniformQuantizer.
      */
@@ -571,6 +613,11 @@ private static float[] computeGlobalCentroids(NonUniformQuantizer nuq) {
     }
 
     private static float squaredL2(float[] a, float[] b) {
-        return KMeans.squaredL2(a, b);
+        float sum = 0;
+        for (int i = 0; i < a.length; i++) {
+            float diff = a[i] - b[i];
+            sum += diff * diff;
+        }
+        return sum;
     }
-}
\ No newline at end of file
+}
diff --git a/spector-index/src/main/java/com/spectrayan/spector/index/package-info.java b/spector-index/src/main/java/com/spectrayan/spector/index/package-info.java
index e7f3ad2..b959d39 100644
--- a/spector-index/src/main/java/com/spectrayan/spector/index/package-info.java
+++ b/spector-index/src/main/java/com/spectrayan/spector/index/package-info.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 /**
  * Spector Index — HNSW vector index and BM25 keyword index implementations.
  *
diff --git a/spector-index/src/main/java/com/spectrayan/spector/index/pq/ParallelPqTrainer.java b/spector-index/src/main/java/com/spectrayan/spector/index/pq/ParallelPqTrainer.java
index 4722da3..b723b1a 100644
--- a/spector-index/src/main/java/com/spectrayan/spector/index/pq/ParallelPqTrainer.java
+++ b/spector-index/src/main/java/com/spectrayan/spector/index/pq/ParallelPqTrainer.java
@@ -1,37 +1,18 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.index.pq;
 
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 import java.util.Random;
-import java.util.concurrent.Callable;
-
-import com.spectrayan.spector.commons.concurrent.ConcurrentExecutionException;
-import com.spectrayan.spector.commons.concurrent.ConcurrentTasks;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
 
 import jdk.incubator.vector.FloatVector;
 import jdk.incubator.vector.VectorMask;
 import jdk.incubator.vector.VectorOperators;
 import jdk.incubator.vector.VectorSpecies;
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-import com.spectrayan.spector.commons.error.SpectorServerException;
-import com.spectrayan.spector.commons.error.ErrorCode;
-import com.spectrayan.spector.commons.error.SpectorInternalException;
 
 /**
  * Parallel Product Quantization trainer with SIMD-accelerated K-Means.
@@ -88,7 +69,7 @@ public ParallelPqTrainer() {
      */
     public ParallelPqTrainer(int maxIterations, long seed) {
         if (maxIterations <= 0) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_OUT_OF_RANGE, "maxIterations", 1, Integer.MAX_VALUE, maxIterations);
+            throw new IllegalArgumentException("maxIterations must be positive: " + maxIterations);
         }
         this.maxIterations = maxIterations;
         this.seed = seed;
@@ -102,7 +83,7 @@ public ParallelPqTrainer(int maxIterations, long seed) {
      * @param numCentroids  number of centroids per subspace (typically 256)
      * @param maxIterations maximum K-Means iterations (overrides constructor value)
      * @return codebooks of shape [M][numCentroids][D/M]
-     * @throws SpectorValidationException if inputs are invalid
+     * @throws IllegalArgumentException if inputs are invalid
      */
     public float[][][] train(float[][] vectors, int numSubspaces, int numCentroids, int maxIterations) {
         validateInputs(vectors, numSubspaces, numCentroids);
@@ -114,20 +95,21 @@ public float[][][] train(float[][] vectors, int numSubspaces, int numCentroids,
 
         float[][][] codebooks = new float[numSubspaces][][];
 
-        // Build tasks — one per subspace
-        List<Callable<float[][]>> tasks = new ArrayList<>(numSubspaces);
-        for (int m = 0; m < numSubspaces; m++) {
-            final int offset = m * dsub;
-            final long subspaceSeed = seed + m;
-            tasks.add(() -> trainSubspace(vectors, offset, dsub, actualK, iters, subspaceSeed));
-        }
+        // Parallelize sub-quantizer training across virtual threads (one per subspace)
+        try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {
+            List<Future<float[][]>> futures = new ArrayList<>(numSubspaces);
+
+            for (int m = 0; m < numSubspaces; m++) {
+                final int offset = m * dsub;
+                // Each subspace gets its own seed derived from the base seed
+                final long subspaceSeed = seed + m;
 
-        // Execute all subspaces in parallel via ConcurrentTasks
-        try {
-            List<float[][]> results = ConcurrentTasks.forkJoinAll(tasks);
+                futures.add(executor.submit(() -> trainSubspace(
+                        vectors, offset, dsub, actualK, iters, subspaceSeed)));
+            }
 
             for (int m = 0; m < numSubspaces; m++) {
-                float[][] centroids = results.get(m);
+                float[][] centroids = futures.get(m).get();
                 // Pad to numCentroids if actualK < numCentroids
                 if (centroids.length < numCentroids) {
                     float[][] padded = new float[numCentroids][dsub];
@@ -139,11 +121,11 @@ public float[][][] train(float[][] vectors, int numSubspaces, int numCentroids,
                     codebooks[m] = centroids;
                 }
             }
-        } catch (ConcurrentExecutionException e) {
-            throw new SpectorInternalException(ErrorCode.INTERNAL_ERROR, e.getCause(), "PQ subspace training failed");
         } catch (InterruptedException e) {
             Thread.currentThread().interrupt();
-            throw new SpectorServerException(ErrorCode.INTERNAL_ERROR, e, "PQ training interrupted");
+            throw new RuntimeException("PQ training interrupted", e);
+        } catch (ExecutionException e) {
+            throw new RuntimeException("PQ subspace training failed", e.getCause());
         }
 
         return codebooks;
@@ -350,20 +332,22 @@ private static float[][] kMeansPlusPlusInit(float[][] data, int k, int dims, Ran
 
     private static void validateInputs(float[][] vectors, int numSubspaces, int numCentroids) {
         if (vectors == null || vectors.length == 0) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_NULL, "Training vectors");
+            throw new IllegalArgumentException("Training vectors must not be null or empty");
         }
         if (numSubspaces <= 0) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_OUT_OF_RANGE, "numSubspaces", 1, Integer.MAX_VALUE, numSubspaces);
+            throw new IllegalArgumentException("numSubspaces must be positive: " + numSubspaces);
         }
         if (numCentroids <= 0 || numCentroids > KSUB) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_OUT_OF_RANGE, "numCentroids", 1, KSUB, numCentroids);
+            throw new IllegalArgumentException(
+                    "numCentroids must be between 1 and " + KSUB + ": " + numCentroids);
         }
         int dimensions = vectors[0].length;
         if (dimensions <= 0) {
-            throw new SpectorValidationException(ErrorCode.DIMENSIONS_INVALID, 0);
+            throw new IllegalArgumentException("Vector dimensions must be positive");
         }
         if (dimensions % numSubspaces != 0) {
-            throw new SpectorValidationException(ErrorCode.DIMENSIONS_MISMATCH, "dimensions (" + dimensions + ") must be divisible by numSubspaces (" + numSubspaces + ")");
+            throw new IllegalArgumentException(
+                    "dimensions (" + dimensions + ") must be divisible by numSubspaces (" + numSubspaces + ")");
         }
     }
-}
\ No newline at end of file
+}
diff --git a/spector-index/src/main/java/com/spectrayan/spector/index/pq/ProductQuantizer.java b/spector-index/src/main/java/com/spectrayan/spector/index/pq/ProductQuantizer.java
index cdf984f..2cbd43f 100644
--- a/spector-index/src/main/java/com/spectrayan/spector/index/pq/ProductQuantizer.java
+++ b/spector-index/src/main/java/com/spectrayan/spector/index/pq/ProductQuantizer.java
@@ -1,26 +1,9 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.index.pq;
 
-import com.spectrayan.spector.core.similarity.SimilarityFunction;
+import com.spectrayan.spector.core.SimilarityFunction;
 
 import java.util.Arrays;
 import java.util.Random;
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-import com.spectrayan.spector.commons.error.ErrorCode;
 
 /**
  * Product Quantizer (PQ) for extreme vector compression.
@@ -75,10 +58,11 @@ private ProductQuantizer(int dimensions, int numSubspaces, float[][][] codebooks
      */
     public static ProductQuantizer train(float[][] samples, int dimensions, int numSubspaces) {
         if (samples.length == 0) {
-            throw new SpectorValidationException(ErrorCode.EMPTY_COLLECTION, "trainingSamples");
+            throw new IllegalArgumentException("Need at least 1 training sample");
         }
         if (dimensions % numSubspaces != 0) {
-            throw new SpectorValidationException(ErrorCode.DIMENSIONS_MISMATCH, "dimensions (" + dimensions + ") must be divisible by numSubspaces (" + numSubspaces + ")");
+            throw new IllegalArgumentException(
+                    "dimensions (" + dimensions + ") must be divisible by numSubspaces (" + numSubspaces + ")");
         }
 
         int dsub = dimensions / numSubspaces;
@@ -322,4 +306,4 @@ private static float squaredL2(float[] a, int offsetA, float[] b, int dims) {
         }
         return sum;
     }
-}
\ No newline at end of file
+}
diff --git a/spector-index/src/main/java/com/spectrayan/spector/index/spectrum/SpectorIndex.java b/spector-index/src/main/java/com/spectrayan/spector/index/spectrum/SpectorIndex.java
deleted file mode 100644
index b75dcd7..0000000
--- a/spector-index/src/main/java/com/spectrayan/spector/index/spectrum/SpectorIndex.java
+++ /dev/null
@@ -1,514 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.index.spectrum;
-
-import com.spectrayan.spector.core.cluster.KMeans;
-import com.spectrayan.spector.core.similarity.SimilarityFunction;
-import com.spectrayan.spector.config.HnswParams;
-import com.spectrayan.spector.index.ScoredResult;
-import com.spectrayan.spector.index.VectorIndex;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.io.IOException;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.util.Arrays;
-import java.util.Properties;
-import java.util.concurrent.atomic.AtomicInteger;
-import java.util.concurrent.locks.ReentrantLock;
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-import com.spectrayan.spector.commons.error.SpectorInternalException;
-import com.spectrayan.spector.commons.error.ErrorCode;
-
-/**
- * SpectorIndex — the flagship adaptive vector index of the Spector search engine.
- *
- * <h2>Architecture</h2>
- * <p>SpectorIndex combines three orthogonal techniques for optimal speed, recall, and memory:</p>
- * <ol>
- *   <li><b>IVF (Inverted File)</b> — coarse K-Means clustering partitions the space into
- *       Voronoi cells. At query time only the {@code nProbe} closest cells are searched,
- *       reducing the effective search space by {@code nCentroids / nProbe}.</li>
- *   <li><b>Adaptive Shards</b> — each cell is a {@link SpectorShard}: a flat scan when
- *       small (&lt; {@code shardThreshold}), automatically promoted to a local HNSW graph
- *       when large. SIMD flat scans beat HNSW pointer-chasing for small partitions; for
- *       large partitions the graph wins decisively.</li>
- *   <li><b>SVASQ Residual Quantization</b> — vectors are stored as residuals
- *       ({@code r = x − centroid}) quantized with SVASQ (FWHT-rotated INT8). Residual
- *       variance is 10–100× lower than absolute coordinates, giving INT8 residuals the
- *       spatial precision of INT12–INT16 absolute quantization.</li>
- * </ol>
- *
- * <h2>Lifecycle</h2>
- * <ol>
- *   <li><b>Train</b> — call {@link #train(float[][])} with representative vectors.
- *       Runs K-Means++ to learn {@code nCentroids} centroids.</li>
- *   <li><b>Add</b> — call {@link #add(String, int, float[])} for each vector.
- *       The vector is routed to its nearest centroid's shard as a residual.</li>
- *   <li><b>Search</b> — call {@link #search(float[], int)}.
- *       Probes the {@code nProbe} closest centroids, searches each shard, merges results.</li>
- * </ol>
- *
- * <h2>Key Design Points</h2>
- * <ul>
- *   <li><b>FWHT on residual, not on raw vector</b> — applying the Walsh-Hadamard Transform
- *       to the residual preserves IVF cluster geometry. Applying it to the raw vector before
- *       centroid assignment would break the spatial clustering.</li>
- *   <li><b>nProbe ≥ 16 for 95%+ recall</b> — boundary vectors near Voronoi boundaries
- *       may be missed if too few cells are probed. The default {@code nProbe = 16} is
- *       cheap (SVASQ makes each shard scan ~200 ns) and ensures excellent recall.</li>
- *   <li><b>ADC for graph construction</b> — when promoting a shard, each float32 residual
- *       is inserted into the local HNSW using Asymmetric Distance Computation (ADC):
- *       exact query state vs. already-quantized nodes. This is the correct approach;
- *       using symmetric quantized distance for graph construction destroys recall.</li>
- * </ul>
- *
- * <h2>Thread Safety</h2>
- * <p>Concurrent reads ({@link #search}) are safe after training completes.
- * Concurrent writes ({@link #add}) use per-shard locks for minimal contention.
- * {@link #train} must complete before any add or search calls.</p>
- *
- * @see SpectorIndexConfig
- * @see SpectorShard
- */
-public final class SpectorIndex implements VectorIndex {
-
-    private static final Logger log = LoggerFactory.getLogger(SpectorIndex.class);
-
-
-    private final int dimensions;
-    private final SpectorIndexConfig config;
-
-    // ── IVF state (set after training) ──
-    private volatile float[][] centroids;  // [nCentroids][dimensions]
-    private volatile SpectorShard[] shards;
-    private volatile boolean trained;
-
-
-    // ── Stats ──
-    /**
-     * Atomic total vector count. Incremented under the per-shard lock in add(), so
-     * the increment itself is visible to concurrent searches immediately after the lock release.
-     * Using AtomicInteger (not volatile int++) eliminates the read-modify-write race.
-     */
-    private final AtomicInteger totalSize = new AtomicInteger(0);
-
-    /**
-     * Per-thread residual scratch buffer: one {@code float[dimensions]} reused across every
-     * {@link #add} call and every probed shard in {@link #search}. Eliminates the
-     * {@code subtract()} allocation that previously occurred on each add and each probe.
-     *
-     * <p>Safe for add(): the residual is always System.arraycopy'd into the shard's flat
-     * buffer (or copied by hnswIndex.add's storeVector) before the scratch is released.</p>
-     *
-     * <p>Safe for search(): the scratch is overwritten for each probe, but each shard.search()
-     * completes fully before the next probe overwrites it — probes are sequential.</p>
-     */
-    private final ThreadLocal<float[]> residualScratch;
-
-
-    // ─────────────── Builder ───────────────
-
-    /** Creates a builder for SpectorIndex. */
-    public static Builder builder() {
-        return new Builder();
-    }
-
-    /**
-     * Fluent builder for {@link SpectorIndex}.
-     *
-     * <pre>{@code
-     * SpectorIndex index = SpectorIndex.builder()
-     *     .dimensions(768)
-     *     .nCentroids(256)
-     *     .nProbe(16)
-     *     .shardThreshold(20_000)
-     *     .similarityFunction(SimilarityFunction.COSINE)
-     *     .build();
-     * }</pre>
-     */
-    public static final class Builder {
-        private int dimensions = -1;
-        private int nCentroids = 256;
-        private int nProbe = 16;
-        private int shardThreshold = 20_000;
-        private int oversamplingFactor = 3;
-        private int kMeansIterations = 25;
-        private SimilarityFunction similarityFunction = SimilarityFunction.COSINE;
-        private HnswParams hnswParams = HnswParams.DEFAULT;
-
-        private Builder() {}
-
-        public Builder dimensions(int d)                          { this.dimensions = d; return this; }
-        public Builder nCentroids(int n)                          { this.nCentroids = n; return this; }
-        public Builder nProbe(int p)                              { this.nProbe = p; return this; }
-        public Builder shardThreshold(int t)                      { this.shardThreshold = t; return this; }
-        public Builder oversamplingFactor(int f)                  { this.oversamplingFactor = f; return this; }
-        public Builder kMeansIterations(int i)                    { this.kMeansIterations = i; return this; }
-        public Builder similarityFunction(SimilarityFunction fn)  { this.similarityFunction = fn; return this; }
-        public Builder hnswParams(HnswParams p)                   { this.hnswParams = p; return this; }
-        public Builder config(SpectorIndexConfig c) {
-            this.nCentroids = c.nCentroids();
-            this.nProbe = c.nProbe();
-            this.shardThreshold = c.shardThreshold();
-            this.oversamplingFactor = c.oversamplingFactor();
-            this.kMeansIterations = c.kMeansIterations();
-            this.similarityFunction = c.similarityFunction();
-            this.hnswParams = c.hnswParams();
-            return this;
-        }
-
-        public SpectorIndex build() {
-            if (dimensions <= 0) throw new SpectorValidationException(ErrorCode.DIMENSIONS_INVALID, 0);
-            SpectorIndexConfig cfg = new SpectorIndexConfig(
-                    nCentroids, nProbe, shardThreshold, oversamplingFactor,
-                    kMeansIterations, similarityFunction, hnswParams);
-            return new SpectorIndex(dimensions, cfg);
-        }
-    }
-
-    // ─────────────── Constructor ───────────────
-
-    private SpectorIndex(int dimensions, SpectorIndexConfig config) {
-        this.dimensions = dimensions;
-        this.config = config;
-        this.trained = false;
-
-        // Thread-local residual scratch — one float[dimensions] per thread, never GC'd during add/search
-        this.residualScratch = ThreadLocal.withInitial(() -> new float[dimensions]);
-    }
-
-    // ─────────────── Training ───────────────
-
-    /**
-     * Trains the index by running K-Means++ on the provided representative vectors.
-     *
-     * <p>Must be called before any {@link #add} or {@link #search} calls.
-     * Training is a one-time operation; the index cannot be re-trained after calling this.</p>
-     *
-     * @param trainingVectors representative sample vectors (≥ nCentroids)
-     * @throws SpectorValidationException    if already trained
-     * @throws SpectorValidationException if the training set is smaller than nCentroids
-     */
-    public synchronized void train(float[][] trainingVectors) {
-        if (trained) throw new SpectorInternalException(ErrorCode.INVARIANT_VIOLATED, "Index already trained");
-        int n = trainingVectors.length;
-        int k = config.nCentroids();
-        if (n < k) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_INVALID, "Training requires at least " + k + " vectors (nCentroids), got " + n);
-        }
-
-        log.info("SpectorIndex training: {} samples, nCentroids={}", n, k);
-        long t0 = System.nanoTime();
-
-        this.centroids = KMeans.train(trainingVectors, k, config.kMeansIterations(), 42L);
-        log.debug("K-Means converged");
-
-        this.shards = new SpectorShard[k];
-        for (int i = 0; i < k; i++) {
-            shards[i] = new SpectorShard(dimensions, config, centroids[i]);
-        }
-
-        this.trained = true;
-        long ms = (System.nanoTime() - t0) / 1_000_000;
-        log.info("SpectorIndex training complete in {}ms", ms);
-    }
-
-    // ─────────────── VectorIndex ───────────────
-
-    /**
-     * Adds a vector to the index.
-     *
-     * <p>Routes the vector to the nearest centroid's shard as a float32 residual.
-     * If the shard crosses the {@link SpectorIndexConfig#shardThreshold()}, it automatically
-     * promotes to HNSW mode.</p>
-     *
-     * @throws SpectorValidationException if {@link #train} has not been called
-     */
-    @Override
-    public void add(String id, int storeIndex, float[] vector) {
-        requireTrained();
-        if (vector.length != dimensions)
-            throw new SpectorValidationException(ErrorCode.DIMENSIONS_MISMATCH, dimensions, vector.length);
-
-        int shardIdx = KMeans.nearestCentroid(vector, centroids);
-
-        // Reuse thread-local scratch for residual — no allocation per add()
-        // SpectorShard.add() acquires its internal writeLock; the residual is copied into
-        // the shard's flat buffer before writeLock is released, so ThreadLocal reuse is safe.
-        float[] residual = residualScratch.get();
-        float[] c = centroids[shardIdx];
-        for (int i = 0; i < dimensions; i++) residual[i] = vector[i] - c[i];
-
-        shards[shardIdx].add(id, storeIndex, residual);
-        totalSize.incrementAndGet();
-    }
-
-    /**
-     * Searches for the {@code k} nearest neighbors to the query vector.
-     *
-     * <p>Algorithm:</p>
-     * <ol>
-     *   <li>Find the {@code nProbe} closest centroids to the query.</li>
-     *   <li>For each probed centroid {@code c}: compute residual query {@code q − c},
-     *       search that centroid's {@link SpectorShard}.</li>
-     *   <li>Merge candidates from all probed shards and return the global top-K.</li>
-     * </ol>
-     *
-     * @throws SpectorValidationException if {@link #train} has not been called
-     */
-    @Override
-    public ScoredResult[] search(float[] query, int k) {
-        requireTrained();
-        if (query.length != dimensions)
-            throw new SpectorValidationException(ErrorCode.DIMENSIONS_MISMATCH, dimensions, query.length);
-        if (totalSize.get() == 0) return new ScoredResult[0];
-
-        // Step 1: Select nProbe closest centroids (box-free partial sort via KMeans)
-        int[] probeShards = KMeans.nearestCentroids(query, centroids, config.nProbe());
-
-        // Step 2: Search each probed shard with its residual query
-        // Reuse thread-local scratch for residualQuery — overwritten per probe, but
-        // each shard.search() fully completes before the next probe, so this is safe.
-        float[] residualQuery = residualScratch.get();
-
-        // ── CRITICAL: IVF residual search always uses L2 distance ──
-        // Cosine/dot-product are NOT translation-invariant: cosine(q-c1, x-c1)
-        // and cosine(q-c2, y-c2) are in different coordinate systems and cannot
-        // be compared across shards. L2 IS translation-invariant:
-        //   ‖(q-c) - (x-c)‖ = ‖q - x‖
-        // So L2 on residuals gives the true original-space distance regardless
-        // of which centroid's shard the vector resides in. This is the standard
-        // approach used by FAISS IVF and all production IVF implementations.
-        //
-        // The user's similarityFunction is still used for centroid routing
-        // (nearestCentroid) where it operates in absolute space.
-        int oversample = Math.max(k, k * config.oversamplingFactor());
-
-        // Array-based global top-K — zero GC during the merge (consistent with flatScan pattern)
-        // L2 distance: lower is better → sentinel is POSITIVE_INFINITY
-        float[]  topScores       = new float[k];
-        String[] topIds          = new String[k];
-        int[]    topStoreIndices = new int[k];
-        Arrays.fill(topScores, Float.POSITIVE_INFINITY);
-
-        float worstScore = Float.POSITIVE_INFINITY;
-        int   worstPos   = 0;
-
-        for (int shardIdx : probeShards) {
-            float[] c = centroids[shardIdx];
-            for (int i = 0; i < dimensions; i++) residualQuery[i] = query[i] - c[i];
-
-            // Read-only search — no lock needed (shards handle internal thread safety)
-            ScoredResult[] localResults = shards[shardIdx].search(residualQuery, oversample);
-
-            for (ScoredResult r : localResults) {
-                // L2: lower is better → replace if new score is lower than worst
-                if (r.score() < worstScore) {
-                    topScores[worstPos]       = r.score();
-                    topIds[worstPos]          = r.id();
-                    topStoreIndices[worstPos] = r.index();
-
-                    // Find the new worst — O(k) scan, negligible vs the O(nProbe) outer loop
-                    worstScore = topScores[0];
-                    worstPos   = 0;
-                    for (int j = 1; j < k; j++) {
-                        if (topScores[j] > worstScore) {
-                            worstScore = topScores[j];
-                            worstPos   = j;
-                        }
-                    }
-                }
-            }
-        }
-
-        // Step 3: Materialize results and sort by L2 distance (ascending — best first)
-        int validCount = 0;
-        for (int i = 0; i < k; i++) {
-            if (topIds[i] != null) validCount++;
-        }
-        ScoredResult[] results = new ScoredResult[validCount];
-        int ri = 0;
-        for (int i = 0; i < k; i++) {
-            if (topIds[i] != null) {
-                results[ri++] = new ScoredResult(topIds[i], topStoreIndices[i], topScores[i]);
-            }
-        }
-        Arrays.sort(results, (a, b) -> Float.compare(a.score(), b.score()));
-        return results;
-    }
-
-    @Override
-    public int size() {
-        return totalSize.get();
-    }
-
-    @Override
-    public SimilarityFunction similarityFunction() {
-        return config.similarityFunction();
-    }
-
-    @Override
-    public void close() {
-        SpectorShard[] s = this.shards;
-        if (s != null) {
-            for (SpectorShard shard : s) {
-                if (shard != null) shard.close();
-            }
-        }
-    }
-
-    /** Returns whether the index has been trained. */
-    public boolean isTrained() { return trained; }
-
-    /** Returns the config used by this index. */
-    public SpectorIndexConfig config() { return config; }
-
-    /** Returns the vector dimensionality. */
-    public int dimensions() { return dimensions; }
-
-    /**
-     * Returns the centroid assignment counts — useful for diagnosing cluster balance.
-     *
-     * @return int array of length nCentroids, where entry i is the number of vectors
-     *         assigned to centroid i
-     * @throws SpectorValidationException if not trained
-     */
-    public int[] shardSizes() {
-        requireTrained();
-        int[] sizes = new int[config.nCentroids()];
-        for (int i = 0; i < config.nCentroids(); i++) {
-            sizes[i] = shards[i].size();
-        }
-        return sizes;
-    }
-
-
-    // ─────────────── Math helpers ───────────────
-
-    private void requireTrained() {
-        if (!trained)
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_INVALID, "SpectorIndex must be trained before use. Call train(trainingVectors) first.");
-    }
-
-    /**
-     * Saves the SpectorIndex's state (centroids, shard modes, structures) to the given directory.
-     */
-    public void save(Path dir, com.spectrayan.spector.storage.VectorStore vs) throws IOException {
-        if (!trained) {
-            log.warn("SpectorIndex is not trained; skipping persistence.");
-            return;
-        }
-
-        Files.createDirectories(dir);
-
-        // 1. Save metadata to meta.properties
-        var props = new Properties();
-        props.setProperty("dimensions", String.valueOf(dimensions));
-        props.setProperty("nCentroids", String.valueOf(config.nCentroids()));
-        props.setProperty("nProbe", String.valueOf(config.nProbe()));
-        props.setProperty("shardThreshold", String.valueOf(config.shardThreshold()));
-        props.setProperty("totalSize", String.valueOf(totalSize.get()));
-        props.setProperty("trained", String.valueOf(trained));
-
-        try (var out = Files.newOutputStream(dir.resolve("meta.properties"))) {
-            props.store(out, "SpectorIndex Metadata");
-        }
-
-        // 2. Save Centroids
-        Path centroidsFile = dir.resolve("centroids.bin");
-        try (var out = new java.io.DataOutputStream(new java.io.BufferedOutputStream(Files.newOutputStream(centroidsFile)))) {
-            for (int i = 0; i < config.nCentroids(); i++) {
-                for (int d = 0; d < dimensions; d++) {
-                    out.writeFloat(centroids[i][d]);
-                }
-            }
-        }
-
-        // 3. Save Shards
-        Path shardsDir = dir.resolve("shards");
-        Files.createDirectories(shardsDir);
-        for (int i = 0; i < config.nCentroids(); i++) {
-            shards[i].save(shardsDir, i);
-        }
-
-        log.info("SpectorIndex persisted successfully to {} ({} centroids, {} size)", dir, config.nCentroids(), totalSize.get());
-    }
-
-    /**
-     * Reconstructs and loads a SpectorIndex state from the given directory.
-     */
-    public static SpectorIndex load(Path dir, int dimensions, SpectorIndexConfig config, com.spectrayan.spector.storage.VectorStore vs) throws IOException {
-        Path metaFile = dir.resolve("meta.properties");
-        if (!Files.exists(metaFile)) {
-            throw new java.io.FileNotFoundException("SpectorIndex meta file not found: " + metaFile);
-        }
-
-        var props = new Properties();
-        try (var in = Files.newInputStream(metaFile)) {
-            props.load(in);
-        }
-
-        int loadedDims = Integer.parseInt(props.getProperty("dimensions"));
-        int loadedNCentroids = Integer.parseInt(props.getProperty("nCentroids"));
-        int loadedNProbe = Integer.parseInt(props.getProperty("nProbe"));
-        int loadedShardThreshold = Integer.parseInt(props.getProperty("shardThreshold"));
-        int loadedTotalSize = Integer.parseInt(props.getProperty("totalSize"));
-        boolean loadedTrained = Boolean.parseBoolean(props.getProperty("trained"));
-
-        if (loadedDims != dimensions) {
-            throw new SpectorValidationException(ErrorCode.DIMENSIONS_MISMATCH, dimensions, loadedDims);
-        }
-
-        var index = new SpectorIndex(dimensions, config);
-        index.trained = loadedTrained;
-        index.totalSize.set(loadedTotalSize);
-
-        if (loadedTrained) {
-            // 1. Load Centroids
-            Path centroidsFile = dir.resolve("centroids.bin");
-            if (!Files.exists(centroidsFile)) {
-                throw new java.io.FileNotFoundException("Centroids bin file not found: " + centroidsFile);
-            }
-            index.centroids = new float[loadedNCentroids][dimensions];
-            try (var in = new java.io.DataInputStream(new java.io.BufferedInputStream(Files.newInputStream(centroidsFile)))) {
-                for (int i = 0; i < loadedNCentroids; i++) {
-                    for (int d = 0; d < dimensions; d++) {
-                        index.centroids[i][d] = in.readFloat();
-                    }
-                }
-            }
-
-            // 2. Load Shards
-            Path shardsDir = dir.resolve("shards");
-            index.shards = new SpectorShard[loadedNCentroids];
-            for (int i = 0; i < loadedNCentroids; i++) {
-                index.shards[i] = SpectorShard.load(shardsDir, i, dimensions, config, index.centroids[i]);
-            }
-
-            // 3. Post-load promoted graph reconstruction (must happen sequentially)
-            for (int i = 0; i < loadedNCentroids; i++) {
-                if (index.shards[i].isPromoted()) {
-                    index.shards[i].loadPromotedGraph(shardsDir, i, vs);
-                }
-            }
-        }
-
-        return index;
-    }
-}
\ No newline at end of file
diff --git a/spector-index/src/main/java/com/spectrayan/spector/index/spectrum/SpectorIndexConfig.java b/spector-index/src/main/java/com/spectrayan/spector/index/spectrum/SpectorIndexConfig.java
deleted file mode 100644
index d6348b1..0000000
--- a/spector-index/src/main/java/com/spectrayan/spector/index/spectrum/SpectorIndexConfig.java
+++ /dev/null
@@ -1,103 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.index.spectrum;
-
-import com.spectrayan.spector.core.similarity.SimilarityFunction;
-import com.spectrayan.spector.config.HnswParams;
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-import com.spectrayan.spector.commons.error.ErrorCode;
-
-/**
- * Configuration for the {@link SpectorIndex} adaptive vector index.
- *
- * <h3>Adaptive Shard Strategy</h3>
- * <p>Each IVF centroid's shard operates in one of two modes:</p>
- * <ul>
- *   <li><b>Flat mode</b> (size &lt; {@code shardThreshold}): exhaustive SIMD scan over
- *       float32 residuals. For small shards, contiguous memory access outperforms HNSW
- *       pointer-chasing by 5–10×.</li>
- *   <li><b>HNSW mode</b> (size ≥ {@code shardThreshold}): a local SVASQ-quantized HNSW
- *       graph is built from the accumulated residuals. Flat float32 storage is released.</li>
- * </ul>
- *
- * <h3>Residual Quantization</h3>
- * <p>Vectors are stored as residuals ({@code r = x − centroid}) and quantized with SVASQ.
- * Residuals are much tighter than absolute coordinates, giving INT8 residual quantization
- * the spatial precision of INT12–INT16 absolute quantization.</p>
- *
- * @param nCentroids         number of IVF Voronoi cells (clusters)
- * @param nProbe             number of closest cells to probe at query time (≥ 16 for 95%+ recall)
- * @param shardThreshold     shard size at which flat scan promotes to HNSW (default: 20 000)
- * @param oversamplingFactor HNSW oversampling for SVASQ re-ranking (default: 3)
- * @param kMeansIterations   K-Means++ iterations for centroid training (default: 25)
- * @param similarityFunction distance metric to use throughout
- * @param hnswParams         HNSW construction/search params for promoted shards
- */
-public record SpectorIndexConfig(
-        int nCentroids,
-        int nProbe,
-        int shardThreshold,
-        int oversamplingFactor,
-        int kMeansIterations,
-        SimilarityFunction similarityFunction,
-        HnswParams hnswParams
-) {
-
-    /**
-     * Default configuration: 256 centroids, nprobe=16, flat→HNSW at 20K vectors,
-     * 3× SVASQ oversampling, 25 K-Means iterations, cosine similarity, standard HNSW params.
-     */
-    public static final SpectorIndexConfig DEFAULT = new SpectorIndexConfig(
-            256, 16, 20_000, 3, 25,
-            SimilarityFunction.COSINE,
-            HnswParams.DEFAULT
-    );
-
-    public SpectorIndexConfig {
-        if (nCentroids < 2)
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_OUT_OF_RANGE, "nCentroids", 2, Integer.MAX_VALUE, nCentroids);
-        if (nProbe < 1 || nProbe > nCentroids)
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_OUT_OF_RANGE, "nProbe", 1, 0, nProbe);
-        if (shardThreshold < 1)
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_OUT_OF_RANGE, "shardThreshold", 1, Integer.MAX_VALUE, shardThreshold);
-        if (oversamplingFactor < 1)
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_OUT_OF_RANGE, "oversamplingFactor", 1, Integer.MAX_VALUE, oversamplingFactor);
-        if (kMeansIterations < 1)
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_OUT_OF_RANGE, "kMeansIterations", 1, Integer.MAX_VALUE, kMeansIterations);
-        if (similarityFunction == null)
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_NULL, "similarityFunction");
-        if (hnswParams == null)
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_NULL, "hnswParams");
-    }
-
-    /** Returns a copy with a different {@code nProbe}. */
-    public SpectorIndexConfig withNProbe(int newNProbe) {
-        return new SpectorIndexConfig(nCentroids, newNProbe, shardThreshold, oversamplingFactor,
-                kMeansIterations, similarityFunction, hnswParams);
-    }
-
-    /** Returns a copy with a different {@code shardThreshold}. */
-    public SpectorIndexConfig withShardThreshold(int newThreshold) {
-        return new SpectorIndexConfig(nCentroids, nProbe, newThreshold, oversamplingFactor,
-                kMeansIterations, similarityFunction, hnswParams);
-    }
-
-    /** Returns a copy with a different {@code oversamplingFactor}. */
-    public SpectorIndexConfig withOversamplingFactor(int newFactor) {
-        return new SpectorIndexConfig(nCentroids, nProbe, shardThreshold, newFactor,
-                kMeansIterations, similarityFunction, hnswParams);
-    }
-}
diff --git a/spector-index/src/main/java/com/spectrayan/spector/index/spectrum/SpectorShard.java b/spector-index/src/main/java/com/spectrayan/spector/index/spectrum/SpectorShard.java
deleted file mode 100644
index 3a15297..0000000
--- a/spector-index/src/main/java/com/spectrayan/spector/index/spectrum/SpectorShard.java
+++ /dev/null
@@ -1,570 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.index.spectrum;
-
-import com.spectrayan.spector.config.HnswParams;
-import com.spectrayan.spector.index.QuantizedHnswIndex;
-import com.spectrayan.spector.core.quantization.strategy.SvasqStrategy;
-import com.spectrayan.spector.core.quantization.svasq.SvasqCalibrator;
-import com.spectrayan.spector.core.quantization.svasq.SvasqParams;
-import com.spectrayan.spector.core.similarity.SimilarityFunction;
-import com.spectrayan.spector.index.ScoredResult;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.io.IOException;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.util.Arrays;
-import java.util.concurrent.locks.ReentrantReadWriteLock;
-
-import com.spectrayan.spector.config.SpectorConfig;
-import com.spectrayan.spector.index.ShardedDiskHnswIndex;
-import com.spectrayan.spector.index.ShardedDiskHnswWriter;
-
-/**
- * Adaptive per-centroid shard for {@link SpectorIndex}.
- *
- * <h3>Two Modes</h3>
- * <ul>
- *   <li><b>Flat mode</b> (size &lt; {@code shardThreshold}): Stores float32 residuals in
- *       a contiguous {@code float[]} flat buffer. Search is an exhaustive exact scan using
- *       the offset-based {@link SimilarityFunction#compute(float[], int, float[], int, int)}
- *       kernel — no per-vector sub-array extraction.</li>
- *   <li><b>HNSW mode</b> (size ≥ {@code shardThreshold}): A {@link QuantizedHnswIndex} with
- *       per-shard SVASQ quantization. The flat buffer is released after promotion.</li>
- * </ul>
- *
- * <h3>Memory Layout (flat mode)</h3>
- * <pre>
- *   flatData[0 .. dim-1]           → residual for vector 0
- *   flatData[dim .. 2*dim-1]       → residual for vector 1
- *   ...
- *   flatData[(n-1)*dim .. n*dim-1] → residual for vector n-1
- * </pre>
- * <p>This layout is cache-friendly: the flat scan reads {@code flatData} sequentially.</p>
- *
- * <h3>Thread Safety (Virtual-Thread Compatible)</h3>
- * <p>SpectorShard is fully thread-safe and designed for high-concurrency workloads,
- * including virtual-thread based parallel search:</p>
- * <ul>
- *   <li><b>Reads ({@link #search})</b>: Multiple concurrent readers are supported via a
- *       {@link ReentrantReadWriteLock}. Post-promotion, a volatile double-check eliminates
- *       lock acquisition entirely for the steady-state search path.</li>
- *   <li><b>Writes ({@link #add})</b>: Serialized via the write-lock. SpectorIndex no longer
- *       needs per-shard external locking; locking is fully internal to this class.</li>
- *   <li><b>Promotion</b>: Promotion holds the write-lock exclusively. In-flight flat scans
- *       complete before promotion runs; searches arriving during promotion block on the
- *       read-lock until promotion finishes and then use the HNSW directly.</li>
- *   <li><b>Virtual threads</b>: {@code ReentrantReadWriteLock} uses {@code LockSupport.park()}
- *       for blocking, which unmounts (not pins) virtual threads. This is correct for Java 21+
- *       virtual thread workloads.</li>
- * </ul>
- *
- * <h3>Promotion Race — Why {@code volatile promoted}?</h3>
- * <p>{@code promoted} is declared {@code volatile} to enable a lock-free fast path in
- * {@link #search}: once {@code promoted} is {@code true} it never reverts, so a stale
- * read of {@code false} is the only case we need to handle conservatively (we enter the
- * read-lock and re-check). The volatile read itself is a single CPU instruction and costs
- * nothing compared to a lock acquisition.</p>
- *
- * <h3>Flat Scan — Zero GC during Search</h3>
- * <p>The flat scan uses an array-based top-K tracker (parallel {@code float[]} scores and
- * {@code int[]} indices) instead of a {@link java.util.PriorityQueue}. No per-candidate
- * object allocation occurs during the scan. Only the final {@link ScoredResult}[] (size k)
- * is allocated once per search to satisfy the public interface.</p>
- */
-final class SpectorShard {
-
-    private static final Logger log = LoggerFactory.getLogger(SpectorShard.class);
-
-    /** Initial capacity for flat-mode arrays (number of vectors, not bytes). */
-    private static final int INITIAL_FLAT_CAPACITY = 128;
-
-    private final int dimensions;
-    private final SpectorIndexConfig config;
-    private final float[] centroid;
-
-    // ── Concurrency ────────────────────────────────────────────────────────
-    //
-    // ReentrantReadWriteLock (not synchronized) avoids virtual thread pinning.
-    // Multiple concurrent searches hold readLock simultaneously.
-    // Writes (add + promote) hold writeLock exclusively.
-    //
-    // promoted is volatile for a lock-free fast path in search():
-    //   once promoted=true we go directly to hnswIndex.search(), skipping readLock.
-
-    private final ReentrantReadWriteLock rwLock    = new ReentrantReadWriteLock();
-    private final ReentrantReadWriteLock.ReadLock  readLock  = rwLock.readLock();
-    private final ReentrantReadWriteLock.WriteLock writeLock = rwLock.writeLock();
-
-    /**
-     * Volatile: enables the post-promotion lock-free fast path in {@link #search}.
-     * Written exactly once (false → true) under the write-lock; never reverts.
-     */
-    private volatile boolean promoted;
-
-    // ── Flat mode (pre-promotion) ──────────────────────────────────────────
-    //
-    // These fields are only accessed under the write-lock (add/promote/growFlat)
-    // or under the read-lock (flatScan). No need for individual volatile declarations
-    // — lock acquisition/release establishes the required happens-before edges.
-
-    /**
-     * Contiguous flat buffer: {@code flatData[i * dimensions .. (i+1) * dimensions - 1]}
-     * holds the float32 residual for vector {@code i}. Null after promotion.
-     */
-    private float[] flatData;
-
-    /** External string IDs. Null after promotion. */
-    private String[] flatIds;
-
-    /** External store indices — {@code int[]}, no boxing. Null after promotion. */
-    private int[] flatStoreIndices;
-
-    /** Current allocated capacity (in vectors). */
-    private int flatCapacity;
-
-    // ── Shared count ───────────────────────────────────────────────────────
-
-    /** Total vectors in this shard. Accessed only under readLock or writeLock. */
-    private int count;
-
-    // ── HNSW mode (post-promotion) ─────────────────────────────────────────
-
-    /** Null until promoted. Set before {@code promoted = true} under writeLock. */
-    private QuantizedHnswIndex hnswIndex;
-
-    SpectorShard(int dimensions, SpectorIndexConfig config, float[] centroid) {
-        this.dimensions   = dimensions;
-        this.config       = config;
-        this.centroid     = centroid;
-        this.flatCapacity = INITIAL_FLAT_CAPACITY;
-        this.flatData         = new float[INITIAL_FLAT_CAPACITY * dimensions];
-        this.flatIds          = new String[INITIAL_FLAT_CAPACITY];
-        this.flatStoreIndices = new int[INITIAL_FLAT_CAPACITY];
-        this.count    = 0;
-        this.promoted = false;
-    }
-
-    /** Closes the promoted HNSW index (if any), releasing its off-heap Arena. */
-    void close() {
-        // Safe without lock: called only during index shutdown
-        if (promoted && hnswIndex != null) {
-            try { hnswIndex.close(); } catch (Exception ignored) {}
-        }
-    }
-
-    /**
-     * Adds a residual vector to this shard.
-     *
-     * <p>Acquires the write-lock internally — callers do not need external synchronization.
-     * In flat mode: copies the residual into the contiguous flat buffer, growing it if needed,
-     * then triggers promotion if the threshold is reached.
-     * In HNSW mode: delegates directly to the live {@link QuantizedHnswIndex}.</p>
-     *
-     * @param id         external document ID
-     * @param storeIndex external store index
-     * @param residual   {@code vector − centroid} in float32
-     */
-    void add(String id, int storeIndex, float[] residual) {
-        writeLock.lock();
-        try {
-            if (promoted) {
-                hnswIndex.add(id, storeIndex, residual);
-                count++;
-            } else {
-                if (count >= flatCapacity) {
-                    growFlat();
-                }
-                System.arraycopy(residual, 0, flatData, count * dimensions, dimensions);
-                flatIds[count]          = id;
-                flatStoreIndices[count] = storeIndex;
-                count++;
-
-                if (count >= config.shardThreshold()) {
-                    promote();
-                }
-            }
-        } finally {
-            writeLock.unlock();
-        }
-    }
-
-    /**
-     * Searches for the {@code k} nearest residuals to {@code residualQuery}.
-     *
-     * <h3>Concurrency Protocol</h3>
-     * <ol>
-     *   <li><b>Fast path (post-promotion)</b>: reads {@code promoted} (volatile) without
-     *       acquiring any shard-level lock. {@code hnswIndex.search()} then uses the HNSW's
-     *       own internal read-lock. This path is completely lock-free at the shard level.</li>
-     *   <li><b>Slow path (pre-promotion or during promotion)</b>: acquires the read-lock,
-     *       re-checks {@code promoted} (promotion may have completed while waiting), and
-     *       either delegates to HNSW or performs an exact flat scan. Multiple concurrent
-     *       searches in flat mode hold the read-lock simultaneously — full read parallelism.</li>
-     * </ol>
-     *
-     * @param residualQuery {@code query − centroid} in float32
-     * @param k             number of results to return
-     * @return scored results (IDs + scores), best-first. Empty array if shard is empty.
-     */
-    ScoredResult[] search(float[] residualQuery, int k) {
-        // ── Fast path: volatile read of promoted — lock-free for steady-state searches ──
-        if (promoted) {
-            // promoted is true and never reverts; hnswIndex is fully constructed
-            // (it was set before promoted=true under writeLock, and volatile promoted
-            // establishes the happens-before edge, so hnswIndex is visible here).
-            return hnswIndex.search(residualQuery, k);
-        }
-
-        // ── Slow path: pre-promotion or promotion in flight ──
-        // Acquire readLock to safely access flat arrays. Multiple threads may hold
-        // readLock concurrently; writeLock (held by promote()) blocks until all
-        // in-flight flat scans complete.
-        readLock.lock();
-        try {
-            // Re-check: promotion may have completed while we were waiting for readLock
-            if (promoted) {
-                return hnswIndex.search(residualQuery, k);
-            }
-            if (count == 0) return new ScoredResult[0];
-            return flatScan(residualQuery, k);
-        } finally {
-            readLock.unlock();
-        }
-    }
-
-    /** Returns the approximate number of vectors in this shard. May be slightly stale. */
-    int size() {
-        // No lock needed for approximate reporting — stale reads are acceptable here
-        return count;
-    }
-
-    /** Returns whether this shard has been promoted to HNSW mode. */
-    boolean isPromoted() {
-        return promoted;
-    }
-
-    // ── Flat scan (exact similarity) ──────────────────────────────────────
-
-    /**
-     * Exhaustive exact similarity scan over the flat float32 residual buffer.
-     *
-     * <p>Called only while holding the read-lock, so {@code flatData}, {@code flatIds},
-     * {@code flatStoreIndices}, and {@code count} are stable for the duration.</p>
-     *
-     * <p>Uses an array-based top-K tracker instead of a {@link java.util.PriorityQueue}:
-     * maintains parallel {@code float[] topScores} and {@code int[] topIndices} arrays.
-     * Zero per-candidate object allocation; only the final {@link ScoredResult}[] (size k)
-     * is allocated at the end.</p>
-     *
-     * <p>Uses {@link SimilarityFunction#compute(float[], int, float[], int, int)} to read
-     * directly from {@code flatData} with a base offset — no sub-array extraction.</p>
-     */
-    private ScoredResult[] flatScan(float[] residualQuery, int k) {
-        // CRITICAL: Always use L2 for residual search — see SpectorIndex.search() for rationale.
-        // L2 is translation-invariant: ‖(q-c)-(x-c)‖ = ‖q-x‖, making scores
-        // directly comparable across shards. Cosine/dot are NOT invariant.
-        SimilarityFunction fn  = SimilarityFunction.EUCLIDEAN;
-        boolean higherIsBetter = false; // L2: lower is better
-        int n                  = count;
-        int resultCount        = Math.min(k, n);
-
-        // Parallel arrays for top-K tracking — zero GC during the scan
-        float[] topScores  = new float[resultCount];
-        int[]   topIndices = new int[resultCount];
-
-        float sentinel = higherIsBetter ? Float.NEGATIVE_INFINITY : Float.POSITIVE_INFINITY;
-        Arrays.fill(topScores, sentinel);
-        Arrays.fill(topIndices, -1);
-
-        float worstScore = sentinel;
-        int   worstPos   = 0;
-
-        for (int i = 0; i < n; i++) {
-            float score = fn.computeForRanking(residualQuery, 0, flatData, i * dimensions, dimensions);
-
-            boolean better = higherIsBetter ? score > worstScore : score < worstScore;
-            if (better) {
-                topScores[worstPos]  = score;
-                topIndices[worstPos] = i;
-
-                // Find the new worst — O(k) scan, negligible vs the O(n) outer loop
-                worstScore = topScores[0];
-                worstPos   = 0;
-                for (int j = 1; j < resultCount; j++) {
-                    boolean worse = higherIsBetter
-                            ? topScores[j] < worstScore
-                            : topScores[j] > worstScore;
-                    if (worse) {
-                        worstScore = topScores[j];
-                        worstPos   = j;
-                    }
-                }
-            }
-        }
-
-        // Materialize ScoredResult[] — unavoidable for the public interface
-        int validCount = 0;
-        for (int i = 0; i < resultCount; i++) {
-            if (topIndices[i] >= 0) validCount++;
-        }
-        ScoredResult[] results = new ScoredResult[validCount];
-        int ri = 0;
-        for (int i = 0; i < resultCount; i++) {
-            int idx = topIndices[i];
-            if (idx >= 0) {
-                results[ri++] = new ScoredResult(flatIds[idx], flatStoreIndices[idx], topScores[i]);
-            }
-        }
-
-        if (higherIsBetter) {
-            Arrays.sort(results, (a, b) -> Float.compare(b.score(), a.score()));
-        } else {
-            Arrays.sort(results, (a, b) -> Float.compare(a.score(), b.score()));
-        }
-        return results;
-    }
-
-    // ── Flat buffer growth ────────────────────────────────────────────────
-
-    /** Called only under writeLock. */
-    private void growFlat() {
-        int newCap = flatCapacity * 2;
-        flatData         = Arrays.copyOf(flatData, newCap * dimensions);
-        flatIds          = Arrays.copyOf(flatIds, newCap);
-        flatStoreIndices = Arrays.copyOf(flatStoreIndices, newCap);
-        flatCapacity     = newCap;
-    }
-
-    // ── Promotion ─────────────────────────────────────────────────────────
-
-    /**
-     * Promotes this shard from flat-scan mode to HNSW mode.
-     *
-     * <p><b>Called only under the write-lock</b> (from {@link #add}). No concurrent flat scan
-     * or add can be in progress. The sequence is:</p>
-     * <ol>
-     *   <li>Calibrate SVASQ from the flat buffer (in-place, no copy).</li>
-     *   <li>Build and populate the {@link QuantizedHnswIndex}.</li>
-     *   <li>Null the flat buffer arrays to reclaim heap memory.</li>
-     *   <li>Write {@code promoted = true} (volatile) — this is the publication fence.
-     *       Any thread that subsequently reads {@code promoted=true} is guaranteed to
-     *       see the fully constructed {@code hnswIndex} due to the happens-before chain:
-     *       <em>writeLock.unlock()</em> → <em>readLock.lock()</em> (for slow-path readers),
-     *       and <em>volatile-write promoted</em> → <em>volatile-read promoted</em>
-     *       (for fast-path readers).</li>
-     * </ol>
-     */
-    private void promote() {
-        int currentSize = count;
-
-        // Step 1: Per-shard SVASQ calibration directly on the flat buffer
-        SvasqParams svasqParams = SvasqCalibrator.calibrate(flatData, currentSize, dimensions);
-        SvasqStrategy svasqStrategy = new SvasqStrategy(svasqParams, SimilarityFunction.EUCLIDEAN);
-
-        log.debug("SpectorShard promoting: size={}, paddedDim={}, bpv={}",
-                currentSize, svasqParams.paddedDim(), svasqStrategy.bytesPerVector());
-
-        // Step 2: Build HNSW with EUCLIDEAN — residual search must use L2
-        // (see SpectorIndex.search() for the full rationale).
-        int capacity = Math.max(currentSize * 4, 1000);
-        hnswIndex = QuantizedHnswIndex.svasqPreCalibrated(
-                dimensions,
-                capacity,
-                SimilarityFunction.EUCLIDEAN,
-                config.hnswParams(),
-                svasqStrategy,
-                config.oversamplingFactor()
-        );
-
-        // Step 3: Bulk-insert all buffered float32 residuals.
-        // addOwned() skips the defensive Arrays.copyOf inside storeVector — we are the only
-        // owner of flatData and will null it in Step 4, so the reference is safe to transfer.
-        // We extract each sub-array with Arrays.copyOfRange (one copy, unavoidable to get an
-        // independent float[]) and addOwned() stores it directly — 1 copy total vs 2 with add().
-        for (int i = 0; i < currentSize; i++) {
-            float[] residual = Arrays.copyOfRange(flatData, i * dimensions, (i + 1) * dimensions);
-            hnswIndex.addOwned(flatIds[i], flatStoreIndices[i], residual);
-        }
-
-        // Step 4: Null flat arrays to reclaim heap memory
-        flatData         = null;
-        flatIds          = null;
-        flatStoreIndices = null;
-
-        // Step 5: Volatile write — publication fence.
-        // After this, any thread reading promoted=true is guaranteed to see
-        // the fully constructed hnswIndex (via volatile happens-before).
-        promoted = true;
-    }
-
-    /**
-     * Saves this shard's state to disk under the given directory.
-     *
-     * <p>Flat shards: residuals + metadata written to {@code shard_N.flat}.<br>
-     * Promoted shards: HNSW graph written via {@link ShardedDiskHnswWriter}
-     * into a subdirectory {@code shard_N_hnsw/}.</p>
-     */
-    void save(Path shardsDir, int shardIndex) throws IOException {
-        readLock.lock();
-        try {
-            Path shardFile = shardsDir.resolve("shard_" + shardIndex + ".flat");
-            try (var out = new java.io.DataOutputStream(new java.io.BufferedOutputStream(Files.newOutputStream(shardFile)))) {
-                out.writeBoolean(promoted);
-                out.writeInt(count);
-                if (!promoted) {
-                    // Write flat residuals
-                    for (int i = 0; i < count * dimensions; i++) {
-                        out.writeFloat(flatData[i]);
-                    }
-                    // Write flat metadata
-                    for (int i = 0; i < count; i++) {
-                        out.writeUTF(flatIds[i]);
-                        out.writeInt(flatStoreIndices[i]);
-                    }
-                }
-            }
-            if (promoted) {
-                Path shardHnswDir = shardsDir.resolve("shard_" + shardIndex + "_hnsw");
-                int nodesPerShard = SpectorConfig.DEFAULT_NODES_PER_SHARD;
-                ShardedDiskHnswWriter.write(hnswIndex, shardHnswDir, nodesPerShard);
-            }
-        } finally {
-            readLock.unlock();
-        }
-    }
-
-    /**
-     * Loads a shard's state from disk.
-     */
-    static SpectorShard load(Path shardsDir, int shardIndex, int dimensions, SpectorIndexConfig config, float[] centroid) throws IOException {
-        Path shardFile = shardsDir.resolve("shard_" + shardIndex + ".flat");
-        if (!Files.exists(shardFile)) {
-            throw new java.io.FileNotFoundException("Shard flat file not found: " + shardFile);
-        }
-
-        boolean promoted;
-        int count;
-
-        try (var in = new java.io.DataInputStream(new java.io.BufferedInputStream(Files.newInputStream(shardFile)))) {
-            promoted = in.readBoolean();
-            count = in.readInt();
-
-            var shard = new SpectorShard(dimensions, config, centroid);
-            shard.promoted = promoted;
-            shard.count = count;
-
-            if (!promoted) {
-                // Restore flat residuals and metadata
-                int cap = Math.max(INITIAL_FLAT_CAPACITY, count * 2);
-                shard.flatCapacity = cap;
-                shard.flatData = new float[cap * dimensions];
-                for (int i = 0; i < count * dimensions; i++) {
-                    shard.flatData[i] = in.readFloat();
-                }
-                shard.flatIds = new String[cap];
-                shard.flatStoreIndices = new int[cap];
-                for (int i = 0; i < count; i++) {
-                    shard.flatIds[i] = in.readUTF();
-                    shard.flatStoreIndices[i] = in.readInt();
-                }
-            } else {
-                shard.flatData = null;
-                shard.flatIds = null;
-                shard.flatStoreIndices = null;
-            }
-
-            return shard;
-        }
-    }
-
-    /**
-     * Loads the promoted HNSW graph structure and dynamically recalibrates/encodes it.
-     *
-     * <p>Reads from the sharded HNSW directory {@code shard_N_hnsw/} written by
-     * {@link ShardedDiskHnswWriter}. The graph is reconstructed with fresh SVASQ
-     * calibration from the loaded residual vectors.</p>
-     */
-    void loadPromotedGraph(Path shardsDir, int shardIndex, com.spectrayan.spector.storage.VectorStore vs) throws IOException {
-        if (!promoted) return;
-
-        Path shardHnswDir = shardsDir.resolve("shard_" + shardIndex + "_hnsw");
-        if (!Files.exists(shardHnswDir)) {
-            throw new java.io.FileNotFoundException("Shard HNSW directory not found: " + shardHnswDir);
-        }
-
-        writeLock.lock();
-        try {
-            try (var diskIndex = ShardedDiskHnswIndex.open(shardHnswDir)) {
-                int nodeCount = diskIndex.size();
-
-                // 1. Read all raw residuals from the sharded disk HNSW index
-                float[][] rawResiduals = new float[nodeCount][dimensions];
-                for (int i = 0; i < nodeCount; i++) {
-                    rawResiduals[i] = diskIndex.readVector(i);
-                }
-
-                // 2. Calibrate SvasqParams using the loaded residuals
-                SvasqParams svasqParams = SvasqCalibrator.calibrate(rawResiduals, nodeCount, dimensions);
-                var svasqStrategy = new com.spectrayan.spector.core.quantization.strategy.SvasqStrategy(svasqParams, SimilarityFunction.EUCLIDEAN);
-
-                // 3. Create pre-calibrated QuantizedHnswIndex
-                int capacity = Math.max(nodeCount * 4, config.shardThreshold() * 2);
-                this.hnswIndex = QuantizedHnswIndex.svasqPreCalibrated(
-                        dimensions,
-                        capacity,
-                        SimilarityFunction.EUCLIDEAN,
-                        config.hnswParams(),
-                        svasqStrategy,
-                        config.oversamplingFactor()
-                );
-
-                // 4. Bulk-load the HNSW nodes via addPrebuilt
-                for (int i = 0; i < nodeCount; i++) {
-                    String id = diskIndex.getId(i);
-                    int level = diskIndex.readLevel(i);
-
-                    // Resolve storeIndex from VectorStore, or fallback to the node index if not found
-                    int storeIndex = vs != null ? vs.indexOf(id) : -1;
-                    if (storeIndex < 0) {
-                        storeIndex = i; // Fallback to index if VectorStore is empty/null or mapping is missing
-                    }
-
-                    int[] layer0 = diskIndex.readNeighbors(i, 0);
-                    int[][] upper = null;
-                    if (level > 0) {
-                        upper = new int[level][];
-                        for (int l = 1; l <= level; l++) {
-                            upper[l - 1] = diskIndex.readNeighbors(i, l);
-                        }
-                    }
-
-                    this.hnswIndex.addPrebuilt(id, storeIndex, rawResiduals[i], level, layer0, upper);
-                }
-
-                // 5. Restore HNSW graph entry point and max level
-                if (nodeCount > 0) {
-                    this.hnswIndex.restoreGraphState(diskIndex.entryPoint(), diskIndex.maxLevel());
-                }
-            }
-        } finally {
-            writeLock.unlock();
-        }
-    }
-}
diff --git a/spector-index/src/main/java/com/spectrayan/spector/index/text/Analyzer.java b/spector-index/src/main/java/com/spectrayan/spector/index/text/Analyzer.java
index 53167ac..6c29e10 100644
--- a/spector-index/src/main/java/com/spectrayan/spector/index/text/Analyzer.java
+++ b/spector-index/src/main/java/com/spectrayan/spector/index/text/Analyzer.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.index;
 
 import java.util.List;
diff --git a/spector-index/src/main/java/com/spectrayan/spector/index/text/BM25Index.java b/spector-index/src/main/java/com/spectrayan/spector/index/text/BM25Index.java
index 708a917..be66479 100644
--- a/spector-index/src/main/java/com/spectrayan/spector/index/text/BM25Index.java
+++ b/spector-index/src/main/java/com/spectrayan/spector/index/text/BM25Index.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.index;
 
 import java.util.ArrayList;
@@ -20,13 +5,12 @@
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
-import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
 import java.util.concurrent.locks.ReadWriteLock;
 import java.util.concurrent.locks.ReentrantReadWriteLock;
 
-import com.spectrayan.spector.commons.concurrent.ConcurrentExecutionException;
-import com.spectrayan.spector.commons.concurrent.ConcurrentTasks;
-
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -59,9 +43,7 @@ public class BM25Index implements KeywordIndex {
 
     private static final Logger log = LoggerFactory.getLogger(BM25Index.class);
 
-    /** Threshold: use parallel term scoring when total postings exceed this.
-     * Set conservatively — virtual thread scheduling overhead only pays off
-     * for large posting lists. Below 20K, sequential scoring is faster. */
+    /** Threshold: use parallel term scoring only when total postings exceed this. */
     private static final int PARALLEL_POSTING_THRESHOLD = 20_000;
 
     private final Analyzer analyzer;
@@ -256,38 +238,37 @@ private float[] scoreTermsSequential(List<String> terms, int n,
      */
     private float[] scoreTermsParallel(List<String> terms, int n,
                                         int nDocs, double avgDL, int[] docLens) {
-        // Build tasks — one per term
-        List<Callable<float[]>> tasks = new ArrayList<>(terms.size());
-        for (String term : terms) {
-            tasks.add(() -> {
-                List<Posting> postings = invertedIndex.get(term);
-                if (postings == null) return null;
-                float idf = computeIdf(postings.size(), nDocs);
-                float[] termScores = new float[n];
-                accumulatePostings(postings, idf, termScores, docLens, avgDL);
-                return termScores;
-            });
-        }
-
         float[] mergedScores = new float[n];
 
-        try {
-            List<float[]> results = ConcurrentTasks.forkJoinAll(tasks);
+        try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
+            List<Future<float[]>> futures = new ArrayList<>(terms.size());
+
+            for (String term : terms) {
+                futures.add(executor.submit(() -> {
+                    List<Posting> postings = invertedIndex.get(term);
+                    if (postings == null) return null;
+                    float idf = computeIdf(postings.size(), nDocs);
+                    float[] termScores = new float[n];
+                    accumulatePostings(postings, idf, termScores, docLens, avgDL);
+                    return termScores;
+                }));
+            }
 
             // Merge: add each per-term array into the merged result
-            for (float[] termScores : results) {
+            for (var future : futures) {
+                float[] termScores = future.get();
                 if (termScores != null) {
                     for (int i = 0; i < n; i++) {
                         mergedScores[i] += termScores[i];
                     }
                 }
             }
-        } catch (ConcurrentExecutionException e) {
-            log.error("Parallel BM25 scoring failed, falling back to sequential", e.getCause());
-            return scoreTermsSequential(terms, n, nDocs, avgDL, docLens);
         } catch (InterruptedException e) {
-            Thread.currentThread().interrupt();
+            java.lang.Thread.currentThread().interrupt();
             log.warn("Parallel BM25 scoring interrupted", e);
+        } catch (ExecutionException e) {
+            log.error("Parallel BM25 scoring failed, falling back to sequential", e.getCause());
+            return scoreTermsSequential(terms, n, nDocs, avgDL, docLens);
         }
 
         return mergedScores;
diff --git a/spector-index/src/main/java/com/spectrayan/spector/index/text/KeywordIndex.java b/spector-index/src/main/java/com/spectrayan/spector/index/text/KeywordIndex.java
index cc519fc..6a11295 100644
--- a/spector-index/src/main/java/com/spectrayan/spector/index/text/KeywordIndex.java
+++ b/spector-index/src/main/java/com/spectrayan/spector/index/text/KeywordIndex.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.index;
 
 import java.util.List;
diff --git a/spector-index/src/main/java/com/spectrayan/spector/index/text/StandardAnalyzer.java b/spector-index/src/main/java/com/spectrayan/spector/index/text/StandardAnalyzer.java
index 084d812..f310188 100644
--- a/spector-index/src/main/java/com/spectrayan/spector/index/text/StandardAnalyzer.java
+++ b/spector-index/src/main/java/com/spectrayan/spector/index/text/StandardAnalyzer.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.index;
 
 import java.util.ArrayList;
diff --git a/spector-index/src/main/java/com/spectrayan/spector/index/text/StemmingAnalyzer.java b/spector-index/src/main/java/com/spectrayan/spector/index/text/StemmingAnalyzer.java
index 622c96b..042219e 100644
--- a/spector-index/src/main/java/com/spectrayan/spector/index/text/StemmingAnalyzer.java
+++ b/spector-index/src/main/java/com/spectrayan/spector/index/text/StemmingAnalyzer.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.index;
 
 import java.util.ArrayList;
diff --git a/spector-index/src/test/java/com/spectrayan/spector/index/BM25IndexTest.java b/spector-index/src/test/java/com/spectrayan/spector/index/BM25IndexTest.java
index f6acf95..2cbce04 100644
--- a/spector-index/src/test/java/com/spectrayan/spector/index/BM25IndexTest.java
+++ b/spector-index/src/test/java/com/spectrayan/spector/index/BM25IndexTest.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.index;
 
 import static org.assertj.core.api.Assertions.assertThat;
diff --git a/spector-index/src/test/java/com/spectrayan/spector/index/DiskHnswIndexTest.java b/spector-index/src/test/java/com/spectrayan/spector/index/DiskHnswIndexTest.java
index 297dbd5..4e69f51 100644
--- a/spector-index/src/test/java/com/spectrayan/spector/index/DiskHnswIndexTest.java
+++ b/spector-index/src/test/java/com/spectrayan/spector/index/DiskHnswIndexTest.java
@@ -1,21 +1,6 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.index;
 
-import com.spectrayan.spector.core.similarity.SimilarityFunction;
+import com.spectrayan.spector.core.SimilarityFunction;
 import com.spectrayan.spector.storage.IndexFileFormat;
 
 import org.junit.jupiter.api.Test;
@@ -142,7 +127,7 @@ void diskIndex_isReadOnly() throws IOException {
         DiskHnswWriter.write(inMemory, indexFile);
 
         try (var diskIndex = DiskHnswIndex.open(indexFile)) {
-            assertThrows(com.spectrayan.spector.commons.error.SpectorException.class,
+            assertThrows(UnsupportedOperationException.class,
                     () -> diskIndex.add("new-doc", 1, new float[dims]));
         }
     }
diff --git a/spector-index/src/test/java/com/spectrayan/spector/index/HnswIndexExtendedTest.java b/spector-index/src/test/java/com/spectrayan/spector/index/HnswIndexExtendedTest.java
index 12b1266..7b537c8 100644
--- a/spector-index/src/test/java/com/spectrayan/spector/index/HnswIndexExtendedTest.java
+++ b/spector-index/src/test/java/com/spectrayan/spector/index/HnswIndexExtendedTest.java
@@ -1,26 +1,9 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.index;
 
-
-import com.spectrayan.spector.config.HnswParams;
 import static org.assertj.core.api.Assertions.assertThat;
 
 import com.spectrayan.spector.commons.ContentExtractor;
-import com.spectrayan.spector.core.similarity.SimilarityFunction;
+import com.spectrayan.spector.core.SimilarityFunction;
 
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
@@ -173,7 +156,7 @@ void searchJsonContent() {
     @Test
     void searchJavaObjectContent() {
         var bm25 = new BM25Index();
-        String obj1 = "Product{name=Spector Engine, category=Software, price=0.0}";
+        String obj1 = "Product{name=Spector Search Engine, category=Software, price=0.0}";
         String obj2 = "Product{name=Office Chair, category=Furniture, price=299.99}";
 
         bm25.index("d1", ContentExtractor.fromJavaObject(obj1));
diff --git a/spector-index/src/test/java/com/spectrayan/spector/index/HnswIndexTest.java b/spector-index/src/test/java/com/spectrayan/spector/index/HnswIndexTest.java
index 5d7d050..32d4764 100644
--- a/spector-index/src/test/java/com/spectrayan/spector/index/HnswIndexTest.java
+++ b/spector-index/src/test/java/com/spectrayan/spector/index/HnswIndexTest.java
@@ -1,30 +1,9 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.index;
 
-import com.spectrayan.spector.commons.error.SpectorException;
-
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-
-
-import com.spectrayan.spector.config.HnswParams;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 
-import com.spectrayan.spector.core.similarity.SimilarityFunction;
+import com.spectrayan.spector.core.SimilarityFunction;
 
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
@@ -163,7 +142,7 @@ void euclideanRecallAtK() {
     void wrongDimensionsThrows() {
         try (var idx = new HnswIndex(DIM, 100, SimilarityFunction.COSINE)) {
             assertThatThrownBy(() -> idx.add("x", 0, new float[DIM + 1]))
-                    .isInstanceOf(SpectorValidationException.class);
+                    .isInstanceOf(IllegalArgumentException.class);
         }
     }
 
@@ -173,7 +152,7 @@ void fullIndexThrows() {
             idx.add("a", 0, new float[]{1, 0, 0});
             idx.add("b", 1, new float[]{0, 1, 0});
             assertThatThrownBy(() -> idx.add("c", 2, new float[]{0, 0, 1}))
-                    .isInstanceOf(SpectorException.class);
+                    .isInstanceOf(IllegalStateException.class);
         }
     }
 
diff --git a/spector-index/src/test/java/com/spectrayan/spector/index/HnswPersistenceTest.java b/spector-index/src/test/java/com/spectrayan/spector/index/HnswPersistenceTest.java
index 6b4f990..d08100c 100644
--- a/spector-index/src/test/java/com/spectrayan/spector/index/HnswPersistenceTest.java
+++ b/spector-index/src/test/java/com/spectrayan/spector/index/HnswPersistenceTest.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.index;
 
 import java.io.IOException;
@@ -29,7 +14,7 @@
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.io.TempDir;
 
-import com.spectrayan.spector.core.similarity.SimilarityFunction;
+import com.spectrayan.spector.core.SimilarityFunction;
 
 /**
  * Unit tests for {@link HnswPersistenceImpl}.
diff --git a/spector-index/src/test/java/com/spectrayan/spector/index/NeighborQueueTest.java b/spector-index/src/test/java/com/spectrayan/spector/index/NeighborQueueTest.java
index 662ff90..8d5cfc5 100644
--- a/spector-index/src/test/java/com/spectrayan/spector/index/NeighborQueueTest.java
+++ b/spector-index/src/test/java/com/spectrayan/spector/index/NeighborQueueTest.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.index;
 
 import static org.assertj.core.api.Assertions.assertThat;
diff --git a/spector-index/src/test/java/com/spectrayan/spector/index/ParallelHnswBuilderTest.java b/spector-index/src/test/java/com/spectrayan/spector/index/ParallelHnswBuilderTest.java
index fffed46..2679bbc 100644
--- a/spector-index/src/test/java/com/spectrayan/spector/index/ParallelHnswBuilderTest.java
+++ b/spector-index/src/test/java/com/spectrayan/spector/index/ParallelHnswBuilderTest.java
@@ -1,31 +1,12 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.index;
 
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-
-
-import com.spectrayan.spector.config.HnswParams;
 import java.util.Random;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import org.junit.jupiter.api.Test;
 
-import com.spectrayan.spector.core.similarity.SimilarityFunction;
+import com.spectrayan.spector.core.SimilarityFunction;
 
 /**
  * Unit tests for {@link ParallelHnswBuilder}.
@@ -135,13 +116,13 @@ void parallelBuild_euclideanDistance() {
     @Test
     void build_nullVectors_throwsException() {
         assertThatThrownBy(() -> builder.build(null, HnswParams.DEFAULT, SimilarityFunction.COSINE))
-                .isInstanceOf(SpectorValidationException.class);
+                .isInstanceOf(IllegalArgumentException.class);
     }
 
     @Test
     void build_emptyVectors_throwsException() {
         assertThatThrownBy(() -> builder.build(new float[0][], HnswParams.DEFAULT, SimilarityFunction.COSINE))
-                .isInstanceOf(SpectorValidationException.class);
+                .isInstanceOf(IllegalArgumentException.class);
     }
 
     @Test
@@ -151,8 +132,8 @@ void build_inconsistentDimensions_throwsException() {
                 new float[]{1.0f, 2.0f} // different dimensions
         };
         assertThatThrownBy(() -> builder.build(vectors, HnswParams.DEFAULT, SimilarityFunction.COSINE))
-                .isInstanceOf(SpectorValidationException.class)
-                .hasMessageContaining("dimensions");
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessageContaining("Inconsistent dimensions");
     }
 
     // ─────────────── Helpers ───────────────
diff --git a/spector-index/src/test/java/com/spectrayan/spector/index/QuantizedHnswIndexTest.java b/spector-index/src/test/java/com/spectrayan/spector/index/QuantizedHnswIndexTest.java
index b8a0f9c..edfb86a 100644
--- a/spector-index/src/test/java/com/spectrayan/spector/index/QuantizedHnswIndexTest.java
+++ b/spector-index/src/test/java/com/spectrayan/spector/index/QuantizedHnswIndexTest.java
@@ -1,32 +1,15 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.index;
 
-
-import com.spectrayan.spector.config.HnswParams;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 import org.junit.jupiter.api.Test;
 
-import com.spectrayan.spector.core.quantization.NonUniformQuantizer;
-import com.spectrayan.spector.core.quantization.QuantizationType;
-import com.spectrayan.spector.core.quantization.ScalarQuantizer;
-import com.spectrayan.spector.core.similarity.SimilarityFunction;
+import com.spectrayan.spector.core.NonUniformQuantizer;
+import com.spectrayan.spector.core.QuantizationType;
+import com.spectrayan.spector.core.ScalarQuantizer;
+import com.spectrayan.spector.core.SimilarityFunction;
 
 /**
  * Tests for {@link QuantizedHnswIndex} — quantized search with re-ranking.
@@ -45,7 +28,7 @@ void basicSearch_returnsResults() {
         }
 
         // Pre-calibrate so quantized path is used
-        var sq = com.spectrayan.spector.core.quantization.ScalarQuantizer.calibrate(vectors, dims);
+        var sq = com.spectrayan.spector.core.ScalarQuantizer.calibrate(vectors, dims);
         var index = new QuantizedHnswIndex(dims, 100,
                 SimilarityFunction.COSINE, HnswParams.DEFAULT, sq);
 
diff --git a/spector-index/src/test/java/com/spectrayan/spector/index/StandardAnalyzerTest.java b/spector-index/src/test/java/com/spectrayan/spector/index/StandardAnalyzerTest.java
index dc92a18..fb90ff5 100644
--- a/spector-index/src/test/java/com/spectrayan/spector/index/StandardAnalyzerTest.java
+++ b/spector-index/src/test/java/com/spectrayan/spector/index/StandardAnalyzerTest.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.index;
 
 import static org.assertj.core.api.Assertions.assertThat;
diff --git a/spector-index/src/test/java/com/spectrayan/spector/index/StemmingAnalyzerTest.java b/spector-index/src/test/java/com/spectrayan/spector/index/StemmingAnalyzerTest.java
index ced1e71..82a996c 100644
--- a/spector-index/src/test/java/com/spectrayan/spector/index/StemmingAnalyzerTest.java
+++ b/spector-index/src/test/java/com/spectrayan/spector/index/StemmingAnalyzerTest.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.index;
 
 import static org.assertj.core.api.Assertions.assertThat;
diff --git a/spector-index/src/test/java/com/spectrayan/spector/index/SvasqHnswIndexTest.java b/spector-index/src/test/java/com/spectrayan/spector/index/SvasqHnswIndexTest.java
deleted file mode 100644
index 450314c..0000000
--- a/spector-index/src/test/java/com/spectrayan/spector/index/SvasqHnswIndexTest.java
+++ /dev/null
@@ -1,212 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.index;
-
-
-import com.spectrayan.spector.config.HnswParams;
-import com.spectrayan.spector.core.quantization.QuantizationType;
-import com.spectrayan.spector.core.similarity.SimilarityFunction;
-import org.junit.jupiter.api.Test;
-
-import java.util.HashSet;
-import java.util.Random;
-import java.util.Set;
-
-import static org.junit.jupiter.api.Assertions.*;
-
-/**
- * End-to-end recall and correctness tests for SVASQ-quantized HNSW index.
- *
- * <p>These tests validate the full pipeline:
- * auto-calibration → retroactive encoding → asymmetric distance traversal → rescore.</p>
- */
-class SvasqHnswIndexTest {
-
-    private static final int    DIMS        = 128;
-    private static final int    NUM_DOCS    = 1000;
-    private static final int    K           = 10;
-    private static final int    QUERY_COUNT = 20;
-    private static final double MIN_RECALL  = 0.75;  // ≥ 75% recall@10 vs exact HNSW
-
-    // ── Smoke tests ───────────────────────────────────────────────────────────
-
-    @Test
-    void svasq_factory_creates_correct_type() {
-        var index = QuantizedHnswIndex.svasq(64, 100, SimilarityFunction.COSINE,
-                HnswParams.DEFAULT, 1);
-        assertEquals(QuantizationType.SVASQ, index.quantizationType());
-        assertFalse(index.isCalibrated(), "Should not be calibrated before any insertions");
-    }
-
-    @Test
-    void svasq_emptyIndex_returnsEmpty() {
-        var index = QuantizedHnswIndex.svasq(32, 100, SimilarityFunction.EUCLIDEAN,
-                HnswParams.DEFAULT, 1);
-        ScoredResult[] results = index.search(new float[32], 5);
-        assertEquals(0, results.length);
-    }
-
-    @Test
-    void svasq_autoCalibrates_after_threshold() {
-        int dims = 32;
-        var index = QuantizedHnswIndex.svasq(dims, 1000, SimilarityFunction.COSINE,
-                HnswParams.DEFAULT, 1);
-
-        assertFalse(index.isCalibrated());
-
-        Random rng = new Random(42L);
-        for (int i = 0; i < 1000; i++) {
-            index.add("doc-" + i, i, randomUnit(rng, dims));
-        }
-
-        assertTrue(index.isCalibrated(), "SVASQ should auto-calibrate after filling buffer");
-    }
-
-    @Test
-    void svasq_basicSearch_returnsAndSorts() {
-        int dims = 64;
-        // Set capacity == numDocs so calibrationBuffer fills exactly when all docs are inserted
-        int numDocs = 150;
-        var index = QuantizedHnswIndex.svasq(dims, numDocs, SimilarityFunction.COSINE,
-                HnswParams.DEFAULT, 1);
-
-        Random rng = new Random(1L);
-        for (int i = 0; i < numDocs; i++) {
-            index.add("doc-" + i, i, randomUnit(rng, dims));
-        }
-
-        assertTrue(index.isCalibrated(), "Should be calibrated after filling capacity");
-
-        float[] query = randomUnit(rng, dims);
-        ScoredResult[] results = index.search(query, 5);
-
-        assertNotNull(results);
-        assertTrue(results.length > 0, "Should return results");
-        assertTrue(results.length <= 5);
-
-        // Cosine: higher is better → descending score order
-        for (int i = 1; i < results.length; i++) {
-            assertTrue(results[i - 1].score() >= results[i].score() - 1e-5f,
-                    "Results must be sorted descending: " + results[i-1].score()
-                    + " vs " + results[i].score());
-        }
-    }
-
-
-    // ── Recall tests ──────────────────────────────────────────────────────────
-
-    @Test
-    void svasq_recall_cosine_noRescore() {
-        double recall = measureRecall(SimilarityFunction.COSINE, /*oversample=*/1);
-        assertTrue(recall >= MIN_RECALL,
-                "SVASQ recall@" + K + " (no rescore) should be ≥ " + MIN_RECALL
-                + " but was " + recall);
-    }
-
-    @Test
-    void svasq_recall_cosine_withRescore3x() {
-        double recall = measureRecall(SimilarityFunction.COSINE, /*oversample=*/3);
-        // With 3× rescore, recall should be significantly better
-        assertTrue(recall >= 0.85,
-                "SVASQ recall@" + K + " (3× rescore) should be ≥ 0.85 but was " + recall);
-    }
-
-    @Test
-    void svasq_recall_euclidean_noRescore() {
-        double recall = measureRecall(SimilarityFunction.EUCLIDEAN, /*oversample=*/1);
-        assertTrue(recall >= MIN_RECALL,
-                "SVASQ L2 recall@" + K + " should be ≥ " + MIN_RECALL
-                + " but was " + recall);
-    }
-
-    @Test
-    void svasq_recall_euclidean_withRescore() {
-        double recall = measureRecall(SimilarityFunction.EUCLIDEAN, /*oversample=*/3);
-        assertTrue(recall >= 0.85,
-                "SVASQ L2 recall@" + K + " (3× rescore) should be ≥ 0.85 but was " + recall);
-    }
-
-    // ── Correctness: same ID never appears twice ───────────────────────────────
-
-    @Test
-    void svasq_noDuplicates_inResults() {
-        int dims = 64;
-        var index = QuantizedHnswIndex.svasq(dims, 200, SimilarityFunction.COSINE,
-                HnswParams.DEFAULT, 3);
-
-        Random rng = new Random(2L);
-        for (int i = 0; i < 100; i++) {
-            index.add("doc-" + i, i, randomUnit(rng, dims));
-        }
-
-        float[] query = randomUnit(rng, dims);
-        ScoredResult[] results = index.search(query, 10);
-
-        Set<String> seen = new HashSet<>();
-        for (ScoredResult r : results) {
-            assertTrue(seen.add(r.id()), "Duplicate id in results: " + r.id());
-        }
-    }
-
-    // ── Helpers ───────────────────────────────────────────────────────────────
-
-    private double measureRecall(SimilarityFunction fn, int oversample) {
-        Random rng = new Random(42L);
-        HnswParams params = new HnswParams(16, 128, 64);
-
-        // SVASQ index
-        var svasqIndex = QuantizedHnswIndex.svasq(DIMS, NUM_DOCS + 10, fn, params, oversample);
-
-        // Exact HNSW for ground truth
-        var exactIndex = new HnswIndex(DIMS, NUM_DOCS + 10, fn);
-
-        float[][] vectors = new float[NUM_DOCS][DIMS];
-        for (int i = 0; i < NUM_DOCS; i++) {
-            vectors[i] = randomUnit(rng, DIMS);
-            svasqIndex.add("doc-" + i, i, vectors[i]);
-            exactIndex.add("doc-" + i, i, vectors[i]);
-        }
-
-        int totalHits = 0;
-        for (int q = 0; q < QUERY_COUNT; q++) {
-            float[] query = randomUnit(rng, DIMS);
-            ScoredResult[] svasqResults  = svasqIndex.search(query, K);
-            ScoredResult[] exactResults = exactIndex.search(query, K);
-
-            Set<String> exactIds = new HashSet<>();
-            for (ScoredResult r : exactResults) exactIds.add(r.id());
-
-            for (ScoredResult r : svasqResults) {
-                if (exactIds.contains(r.id())) totalHits++;
-            }
-        }
-
-        return (double) totalHits / ((double) QUERY_COUNT * K);
-    }
-
-    /** Returns a random L2-normalized float vector. */
-    private static float[] randomUnit(Random rng, int dims) {
-        float[] v = new float[dims];
-        double norm = 0;
-        for (int i = 0; i < dims; i++) {
-            v[i] = (float) rng.nextGaussian();
-            norm += (double) v[i] * v[i];
-        }
-        float scale = (float) (1.0 / Math.sqrt(norm));
-        for (int i = 0; i < dims; i++) v[i] *= scale;
-        return v;
-    }
-}
diff --git a/spector-index/src/test/java/com/spectrayan/spector/index/ivf/IvfConcurrencyTest.java b/spector-index/src/test/java/com/spectrayan/spector/index/ivf/IvfConcurrencyTest.java
deleted file mode 100644
index 324c619..0000000
--- a/spector-index/src/test/java/com/spectrayan/spector/index/ivf/IvfConcurrencyTest.java
+++ /dev/null
@@ -1,188 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.index.ivf;
-
-import com.spectrayan.spector.core.similarity.SimilarityFunction;
-import com.spectrayan.spector.index.ScoredResult;
-
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.Timeout;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Random;
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.atomic.AtomicInteger;
-
-import static org.assertj.core.api.Assertions.*;
-
-/**
- * Concurrent add + search stress tests for the IVF family of indexes.
- *
- * <p>These tests exercise the {@code StampedLock} optimistic-read path by running
- * concurrent writers (triggering writeLock) and readers (triggering the
- * optimistic-read fast path and falling back to readLock when a race is detected).
- * They validate that:</p>
- * <ul>
- *   <li>No {@link NullPointerException} or {@link ArrayIndexOutOfBoundsException}
- *       occurs from torn reads of the posting lists</li>
- *   <li>No deadlock occurs under sustained concurrent load</li>
- *   <li>All search results have finite scores (no NaN/Inf from partial reads)</li>
- * </ul>
- */
-class IvfConcurrencyTest {
-
-    private static final int DIMS         = 64;
-    private static final int TRAIN_N      = 300;
-    private static final int NUM_CELLS    = 16;
-    private static final int DURATION_MS  = 1_500;
-    private static final int WRITERS      = 4;
-    private static final int READERS      = 8;
-
-    // ── IvfFlatIndex ──────────────────────────────────────────────────────────
-
-    @Test
-    @Timeout(15)
-    void ivfFlat_concurrent_addAndSearch_noCorruption() throws InterruptedException {
-        float[][] training = randomVectors(TRAIN_N, DIMS, 1L);
-        var index = new IvfFlatIndex(DIMS, SimilarityFunction.COSINE);
-        index.train(training, NUM_CELLS);
-
-        runConcurrentStress(
-                index::search,
-                (id, storeIdx, vec) -> index.add(id, storeIdx, vec),
-                DIMS, WRITERS, READERS, DURATION_MS
-        );
-    }
-
-    // ── IvfPqIndex ────────────────────────────────────────────────────────────
-
-    @Test
-    @Timeout(15)
-    void ivfPq_concurrent_addAndSearch_noCorruption() throws InterruptedException {
-        float[][] training = randomVectors(TRAIN_N, DIMS, 2L);
-        var index = new IvfPqIndex(DIMS, NUM_CELLS, 8 /* nProbe */, 8 /* M */,
-                SimilarityFunction.COSINE);
-        index.train(training);
-
-        runConcurrentStress(
-                (q, k) -> index.search(q, k),
-                (id, storeIdx, vec) -> index.add(id, storeIdx, vec),
-                DIMS, WRITERS, READERS, DURATION_MS
-        );
-    }
-
-    // ── QuantizedIvfPqIndex ───────────────────────────────────────────────────
-
-    @Test
-    @Timeout(15)
-    void quantizedIvfPq_concurrent_addAndSearch_noCorruption() throws InterruptedException {
-        float[][] training = randomVectors(TRAIN_N, DIMS, 3L);
-        var index = new QuantizedIvfPqIndex(DIMS, NUM_CELLS, 8 /* nProbe */, 8 /* M */,
-                SimilarityFunction.COSINE);
-        index.train(training);
-
-        runConcurrentStress(
-                (q, k) -> index.search(q, k),
-                (id, storeIdx, vec) -> index.add(id, storeIdx, vec),
-                DIMS, WRITERS, READERS, DURATION_MS
-        );
-    }
-
-    // ── Helpers ───────────────────────────────────────────────────────────────
-
-    @FunctionalInterface
-    interface Searcher {
-        ScoredResult[] search(float[] query, int k);
-    }
-
-    @FunctionalInterface
-    interface Adder {
-        void add(String id, int storeIndex, float[] vector);
-    }
-
-    private static void runConcurrentStress(Searcher searcher, Adder adder,
-                                             int dims, int writers, int readers,
-                                             long durationMs) throws InterruptedException {
-        AtomicInteger errorCount  = new AtomicInteger(0);
-        AtomicInteger addedCount  = new AtomicInteger(0);
-        CountDownLatch startLatch = new CountDownLatch(1);
-        List<Thread> threads      = new ArrayList<>();
-
-        // Writers
-        for (int w = 0; w < writers; w++) {
-            final Random rng = new Random(w * 77L);
-            Thread t = Thread.ofVirtual().start(() -> {
-                try {
-                    startLatch.await();
-                    long end = System.currentTimeMillis() + durationMs;
-                    while (System.currentTimeMillis() < end) {
-                        int id = addedCount.incrementAndGet();
-                        adder.add("doc-" + id, id, randomVector(rng, dims));
-                    }
-                } catch (Exception e) {
-                    errorCount.incrementAndGet();
-                    System.err.println("Writer error: " + e);
-                }
-            });
-            threads.add(t);
-        }
-
-        // Readers
-        for (int r = 0; r < readers; r++) {
-            final Random rng = new Random(r * 33L + 1000);
-            Thread t = Thread.ofVirtual().start(() -> {
-                try {
-                    startLatch.await();
-                    long end = System.currentTimeMillis() + durationMs;
-                    while (System.currentTimeMillis() < end) {
-                        float[] query = randomVector(rng, dims);
-                        ScoredResult[] results = searcher.search(query, 5);
-                        for (ScoredResult result : results) {
-                            if (!Float.isFinite(result.score())) {
-                                errorCount.incrementAndGet();
-                            }
-                        }
-                    }
-                } catch (Exception e) {
-                    errorCount.incrementAndGet();
-                    System.err.println("Reader error: " + e);
-                }
-            });
-            threads.add(t);
-        }
-
-        startLatch.countDown();
-        for (Thread t : threads) t.join();
-
-        assertThat(errorCount.get())
-                .as("No errors (data races, NPE, AIOOBE, NaN scores) during concurrent add+search")
-                .isZero();
-    }
-
-    private static float[][] randomVectors(int n, int dims, long seed) {
-        Random rng = new Random(seed);
-        float[][] vs = new float[n][dims];
-        for (float[] v : vs) for (int i = 0; i < dims; i++) v[i] = rng.nextFloat() * 2 - 1;
-        return vs;
-    }
-
-    private static float[] randomVector(Random rng, int dims) {
-        float[] v = new float[dims];
-        for (int i = 0; i < dims; i++) v[i] = rng.nextFloat() * 2 - 1;
-        return v;
-    }
-}
diff --git a/spector-index/src/test/java/com/spectrayan/spector/index/ivf/IvfFlatIndexTest.java b/spector-index/src/test/java/com/spectrayan/spector/index/ivf/IvfFlatIndexTest.java
index 51aae55..d3647df 100644
--- a/spector-index/src/test/java/com/spectrayan/spector/index/ivf/IvfFlatIndexTest.java
+++ b/spector-index/src/test/java/com/spectrayan/spector/index/ivf/IvfFlatIndexTest.java
@@ -1,31 +1,12 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.index.ivf;
 
-import com.spectrayan.spector.commons.error.SpectorException;
-
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 import org.junit.jupiter.api.Test;
 
-import com.spectrayan.spector.core.similarity.SimilarityFunction;
+import com.spectrayan.spector.core.SimilarityFunction;
 import com.spectrayan.spector.index.ScoredResult;
 
 /**
@@ -59,7 +40,7 @@ void trainAndSearch_returnsResults() {
     @Test
     void searchBeforeTraining_throws() {
         var index = new IvfFlatIndex(32, SimilarityFunction.COSINE);
-        var ex = assertThrows(SpectorException.class,
+        var ex = assertThrows(IllegalStateException.class,
                 () -> index.search(new float[32], 5));
         assertTrue(ex.getMessage().contains("trained"));
     }
@@ -67,7 +48,7 @@ void searchBeforeTraining_throws() {
     @Test
     void addBeforeTraining_throws() {
         var index = new IvfFlatIndex(32, SimilarityFunction.COSINE);
-        assertThrows(SpectorException.class,
+        assertThrows(IllegalStateException.class,
                 () -> index.add("doc-0", 0, new float[32]));
     }
 
@@ -75,7 +56,7 @@ void addBeforeTraining_throws() {
     void trainWithTooFewVectors_throws() {
         var index = new IvfFlatIndex(32, SimilarityFunction.COSINE);
         float[][] vectors = randomVectors(5, 32, 42);
-        var ex = assertThrows(SpectorValidationException.class,
+        var ex = assertThrows(IllegalArgumentException.class,
                 () -> index.train(vectors, 10));
         assertTrue(ex.getMessage().contains("at least 10"));
     }
@@ -85,11 +66,11 @@ void trainWithCellsOutOfRange_throws() {
         var index = new IvfFlatIndex(32, SimilarityFunction.COSINE);
         float[][] vectors = randomVectors(100, 32, 42);
 
-        assertThrows(SpectorValidationException.class,
+        assertThrows(IllegalArgumentException.class,
                 () -> index.train(vectors, 1)); // below MIN_CELLS
 
         var index2 = new IvfFlatIndex(32, SimilarityFunction.COSINE);
-        assertThrows(SpectorValidationException.class,
+        assertThrows(IllegalArgumentException.class,
                 () -> index2.train(vectors, 65_537)); // above MAX_CELLS
     }
 
@@ -200,10 +181,10 @@ void invalidNprobe_throws() {
         index.train(trainData, 8);
         index.add("doc-0", 0, trainData[0]);
 
-        assertThrows(SpectorValidationException.class,
+        assertThrows(IllegalArgumentException.class,
                 () -> index.search(trainData[0], 0, 5)); // nprobe < 1
 
-        assertThrows(SpectorValidationException.class,
+        assertThrows(IllegalArgumentException.class,
                 () -> index.search(trainData[0], 9, 5)); // nprobe > numCells
     }
 
diff --git a/spector-index/src/test/java/com/spectrayan/spector/index/ivf/IvfPqIndexTest.java b/spector-index/src/test/java/com/spectrayan/spector/index/ivf/IvfPqIndexTest.java
index 42258f4..641a98d 100644
--- a/spector-index/src/test/java/com/spectrayan/spector/index/ivf/IvfPqIndexTest.java
+++ b/spector-index/src/test/java/com/spectrayan/spector/index/ivf/IvfPqIndexTest.java
@@ -1,23 +1,6 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.index.ivf;
 
-import com.spectrayan.spector.commons.error.SpectorException;
-
-import com.spectrayan.spector.core.similarity.SimilarityFunction;
+import com.spectrayan.spector.core.SimilarityFunction;
 import com.spectrayan.spector.index.ScoredResult;
 
 import org.junit.jupiter.api.Test;
@@ -63,14 +46,14 @@ void trainAndSearch_returnsResults() {
     @Test
     void searchWithoutTraining_throws() {
         var index = new IvfPqIndex(32, 16, 4, 8, SimilarityFunction.COSINE);
-        assertThrows(SpectorException.class,
+        assertThrows(IllegalStateException.class,
                 () -> index.search(new float[32], 5));
     }
 
     @Test
     void addWithoutTraining_throws() {
         var index = new IvfPqIndex(32, 16, 4, 8, SimilarityFunction.COSINE);
-        assertThrows(SpectorException.class,
+        assertThrows(IllegalStateException.class,
                 () -> index.add("doc-0", 0, new float[32]));
     }
 
diff --git a/spector-index/src/test/java/com/spectrayan/spector/index/pq/ParallelPqTrainerTest.java b/spector-index/src/test/java/com/spectrayan/spector/index/pq/ParallelPqTrainerTest.java
index dda162a..8a35b2f 100644
--- a/spector-index/src/test/java/com/spectrayan/spector/index/pq/ParallelPqTrainerTest.java
+++ b/spector-index/src/test/java/com/spectrayan/spector/index/pq/ParallelPqTrainerTest.java
@@ -1,22 +1,5 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.index.pq;
 
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-
 import java.util.Random;
 
 import static org.junit.jupiter.api.Assertions.assertArrayEquals;
@@ -112,14 +95,14 @@ void train_withCustomIterations() {
     @Test
     void train_throwsOnNullVectors() {
         ParallelPqTrainer trainer = new ParallelPqTrainer();
-        assertThrows(SpectorValidationException.class,
+        assertThrows(IllegalArgumentException.class,
                 () -> trainer.train(null, 4, 256));
     }
 
     @Test
     void train_throwsOnEmptyVectors() {
         ParallelPqTrainer trainer = new ParallelPqTrainer();
-        assertThrows(SpectorValidationException.class,
+        assertThrows(IllegalArgumentException.class,
                 () -> trainer.train(new float[0][], 4, 256));
     }
 
@@ -127,7 +110,7 @@ void train_throwsOnEmptyVectors() {
     void train_throwsOnIndivisibleDimensions() {
         float[][] vectors = randomVectors(100, 15, 42);
         ParallelPqTrainer trainer = new ParallelPqTrainer();
-        assertThrows(SpectorValidationException.class,
+        assertThrows(IllegalArgumentException.class,
                 () -> trainer.train(vectors, 4, 256));
     }
 
@@ -135,9 +118,9 @@ void train_throwsOnIndivisibleDimensions() {
     void train_throwsOnInvalidNumCentroids() {
         float[][] vectors = randomVectors(100, 16, 42);
         ParallelPqTrainer trainer = new ParallelPqTrainer();
-        assertThrows(SpectorValidationException.class,
+        assertThrows(IllegalArgumentException.class,
                 () -> trainer.train(vectors, 4, 0));
-        assertThrows(SpectorValidationException.class,
+        assertThrows(IllegalArgumentException.class,
                 () -> trainer.train(vectors, 4, 257));
     }
 
@@ -145,7 +128,7 @@ void train_throwsOnInvalidNumCentroids() {
     void train_throwsOnInvalidNumSubspaces() {
         float[][] vectors = randomVectors(100, 16, 42);
         ParallelPqTrainer trainer = new ParallelPqTrainer();
-        assertThrows(SpectorValidationException.class,
+        assertThrows(IllegalArgumentException.class,
                 () -> trainer.train(vectors, 0, 256));
     }
 
diff --git a/spector-index/src/test/java/com/spectrayan/spector/index/pq/ProductQuantizerTest.java b/spector-index/src/test/java/com/spectrayan/spector/index/pq/ProductQuantizerTest.java
index 1fcf055..ea52c7a 100644
--- a/spector-index/src/test/java/com/spectrayan/spector/index/pq/ProductQuantizerTest.java
+++ b/spector-index/src/test/java/com/spectrayan/spector/index/pq/ProductQuantizerTest.java
@@ -1,22 +1,5 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.index.pq;
 
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-
 import org.junit.jupiter.api.Test;
 
 import static org.junit.jupiter.api.Assertions.*;
@@ -125,7 +108,7 @@ void batchEncode_matchesSingleEncode() {
     @Test
     void dimensionsMustBeDivisibleByM() {
         float[][] samples = randomVectors(100, 15, 42);
-        assertThrows(SpectorValidationException.class,
+        assertThrows(IllegalArgumentException.class,
                 () -> ProductQuantizer.train(samples, 15, 4),
                 "15 not divisible by 4");
     }
diff --git a/spector-index/src/test/java/com/spectrayan/spector/index/spectrum/SemanticMarkdownSearchTest.java b/spector-index/src/test/java/com/spectrayan/spector/index/spectrum/SemanticMarkdownSearchTest.java
deleted file mode 100644
index ccfd5a2..0000000
--- a/spector-index/src/test/java/com/spectrayan/spector/index/spectrum/SemanticMarkdownSearchTest.java
+++ /dev/null
@@ -1,307 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.index.spectrum;
-
-import com.spectrayan.spector.core.similarity.SimilarityFunction;
-import com.spectrayan.spector.embed.ollama.OllamaEmbeddingProvider;
-import com.spectrayan.spector.config.HnswParams;
-import com.spectrayan.spector.index.ScoredResult;
-
-import org.junit.jupiter.api.BeforeAll;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.condition.EnabledIfSystemProperty;
-
-import java.io.IOException;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.nio.file.Paths;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Random;
-import java.util.stream.Stream;
-
-import static org.assertj.core.api.Assertions.*;
-
-/**
- * End-to-end semantic search test using Ollama embeddings and the project's own markdown files.
- *
- * <h3>What this tests</h3>
- * <ol>
- *   <li>Real embedding → SpectorIndex pipeline: ensures the quantization (SVASQ) and IVF routing
- *       work correctly with 768-dim real-valued vectors, not just random synthetic data.</li>
- *   <li>Semantic relevance: given a query, the top result must contain expected keywords
- *       (e.g. searching "FWHT rotation quantization" returns a chunk from SVASQ_whitepaper.txt).</li>
- *   <li>Quantization recall: the SpectorIndex recall vs brute-force is ≥ 80% on real embeddings.</li>
- * </ol>
- *
- * <h3>Prerequisites (not run in CI by default)</h3>
- * Run with {@code -Dollama.enabled=true} to activate:
- * <pre>
- *   mvn test -pl spector-index -Dollama.enabled=true
- * </pre>
- * Requires Ollama running at {@code http://localhost:11434} with {@code nomic-embed-text} pulled:
- * <pre>
- *   ollama pull nomic-embed-text
- * </pre>
- */
-@EnabledIfSystemProperty(named = "ollama.enabled", matches = "true",
-        disabledReason = "Ollama not enabled. Run with -Dollama.enabled=true")
-class SemanticMarkdownSearchTest {
-
-    // nomic-embed-text produces 768-dim vectors
-    private static final int DIMS = 768;
-    private static final String MODEL = "nomic-embed-text";
-
-    private static OllamaEmbeddingProvider embedder;
-    private static SpectorIndex index;
-
-    /** (chunkId, text, vector) triple — built once for all tests */
-    private static final List<ChunkRecord> chunks = new ArrayList<>();
-
-    record ChunkRecord(String id, String text, float[] vector) {}
-
-    /**
-     * Ingests all markdown + text files in the project root using 512-char chunks with 64-char overlap.
-     * Training is done on the first 500 chunks (or all of them if fewer).
-     */
-    @BeforeAll
-    static void ingestMarkdownCorpus() throws IOException {
-        embedder = OllamaEmbeddingProvider.create(MODEL);
-
-        // Collect markdown + text files from project root
-        Path projectRoot = Paths.get("d:/git/spector");
-        List<Path> files;
-        try (Stream<Path> stream = Files.walk(projectRoot, 2)) {
-            files = stream
-                    .filter(p -> !Files.isDirectory(p))
-                    .filter(p -> {
-                        String name = p.getFileName().toString().toLowerCase();
-                        return name.endsWith(".md") || name.endsWith(".txt");
-                    })
-                    .filter(p -> !p.toString().contains("target"))
-                    .filter(p -> !p.toString().contains(".git"))
-                    .toList();
-        }
-
-        System.out.println("Found " + files.size() + " markdown/text files to ingest");
-
-        // Chunk and embed each file
-        int chunkId = 0;
-        for (Path file : files) {
-            String content;
-            try {
-                content = Files.readString(file);
-            } catch (Exception e) {
-                continue; // skip unreadable files
-            }
-            String docId = file.getFileName().toString();
-
-            // Simple character-level chunker: 512 chars, 64 overlap
-            List<String> fileChunks = chunkText(content, 512, 64);
-            System.out.println("  " + docId + ": " + fileChunks.size() + " chunks");
-
-            for (int i = 0; i < fileChunks.size(); i++) {
-                String text = fileChunks.get(i);
-                if (text.isBlank()) continue;
-                try {
-                    float[] vec = embedder.embed(text).vector();
-                    chunks.add(new ChunkRecord(docId + "-chunk-" + i, text, vec));
-                    chunkId++;
-                } catch (Exception e) {
-                    System.err.println("Embedding failed for " + docId + " chunk " + i + ": " + e.getMessage());
-                }
-            }
-        }
-
-        System.out.println("Total chunks embedded: " + chunks.size());
-        assertThat(chunks).as("Must have at least 20 chunks to run semantic tests").hasSizeGreaterThan(20);
-
-        // Build SpectorIndex
-        // Training sample: up to first 300 chunks (or all if fewer)
-        int trainN = Math.min(300, chunks.size());
-        float[][] trainVecs = new float[trainN][DIMS];
-        for (int i = 0; i < trainN; i++) trainVecs[i] = chunks.get(i).vector();
-
-        index = SpectorIndex.builder()
-                .dimensions(DIMS)
-                .nCentroids(Math.max(8, trainN / 20))   // ~5% of training set
-                .nProbe(8)
-                .shardThreshold(500)
-                .oversamplingFactor(3)
-                .similarityFunction(SimilarityFunction.COSINE)
-                .hnswParams(HnswParams.DEFAULT)
-                .build();
-
-        index.train(trainVecs);
-
-        for (int i = 0; i < chunks.size(); i++) {
-            ChunkRecord c = chunks.get(i);
-            index.add(c.id(), i, c.vector());
-        }
-
-        System.out.println("SpectorIndex built: " + index.size() + " vectors");
-    }
-
-    // ── Semantic relevance tests ───────────────────────────────────────────────
-
-    /**
-     * Searching for SVASQ/FWHT concepts should surface the whitepaper.
-     */
-    @Test
-    void query_svasqQuantization_returnsWhitepaperChunk() {
-        float[] query = embedder.embed("FWHT rotation quantization INT8 SVASQ").vector();
-        ScoredResult[] results = index.search(query, 5);
-
-        assertThat(results).isNotEmpty();
-
-        // At least one top-5 result should come from the SVASQ whitepaper
-        boolean foundWhitepaper = false;
-        for (ScoredResult r : results) {
-            if (r.id().toLowerCase().contains("svasq")) {
-                foundWhitepaper = true;
-                break;
-            }
-        }
-        assertThat(foundWhitepaper)
-                .as("Top-5 results for SVASQ query should include SVASQ_whitepaper chunk. " +
-                    "Got: " + java.util.Arrays.toString(java.util.Arrays.stream(results)
-                        .map(ScoredResult::id).toArray()))
-                .isTrue();
-    }
-
-    /**
-     * Searching for HNSW graph construction should surface relevant documentation.
-     */
-    @Test
-    void query_hnswGraphConstruction_returnsRelevantChunk() {
-        float[] query = embedder.embed("HNSW graph neighbor connection layer search").vector();
-        ScoredResult[] results = index.search(query, 5);
-
-        assertThat(results).isNotEmpty();
-
-        // Top results should have reasonable cosine similarity (> 0.5)
-        assertThat(results[0].score())
-                .as("Top HNSW result should have cosine similarity > 0.4")
-                .isGreaterThan(0.4f);
-    }
-
-    /**
-     * Searching for performance benchmarking should surface README or benchmark docs.
-     */
-    @Test
-    void query_performanceBenchmark_returnsReadmeOrChangelog() {
-        float[] query = embedder.embed("performance benchmark QPS throughput latency").vector();
-        ScoredResult[] results = index.search(query, 10);
-
-        assertThat(results).isNotEmpty();
-        assertThat(results[0].score())
-                .as("Performance query should find relevant chunk (score > 0.3)")
-                .isGreaterThan(0.3f);
-
-        System.out.println("Performance query top results:");
-        for (ScoredResult r : results) {
-            System.out.printf("  %-50s score=%.4f%n", r.id(), r.score());
-        }
-    }
-
-    /**
-     * Scores must be sorted descending (best first).
-     */
-    @Test
-    void results_areSortedDescendingByScore() {
-        float[] query = embedder.embed("vector search index retrieval").vector();
-        ScoredResult[] results = index.search(query, 10);
-
-        assertThat(results).isNotEmpty();
-        for (int i = 1; i < results.length; i++) {
-            assertThat(results[i].score())
-                    .as("Result[%d] score %.4f should be ≤ result[%d] score %.4f",
-                        i, results[i].score(), i - 1, results[i - 1].score())
-                    .isLessThanOrEqualTo(results[i - 1].score());
-        }
-    }
-
-    // ── Recall@10 on real embeddings ──────────────────────────────────────────
-
-    /**
-     * Recall@10 on real embeddings: SpectorIndex vs brute-force cosine similarity.
-     * Uses 20 random chunks as queries. Expects ≥ 75% average recall@10.
-     *
-     * <p>This is lower than the synthetic test (80%) because real high-dim embeddings
-     * (D=768) have a harder quantization challenge than D=128 random vectors.</p>
-     */
-    @Test
-    void recall10_onRealEmbeddings_atLeast75Percent() {
-        int k = 10, queries = 20;
-        Random rng = new Random(42L);
-
-        float[][] corpus = new float[chunks.size()][DIMS];
-        for (int i = 0; i < chunks.size(); i++) corpus[i] = chunks.get(i).vector();
-
-        double totalRecall = 0;
-        List<Integer> queryIndices = new ArrayList<>();
-        for (int i = 0; i < queries; i++) {
-            queryIndices.add(rng.nextInt(chunks.size()));
-        }
-
-        for (int qIdx : queryIndices) {
-            float[] query = corpus[qIdx];
-
-            // Brute-force top-k
-            java.util.TreeMap<Float, String> exactMap = new java.util.TreeMap<>(java.util.Comparator.reverseOrder());
-            for (int i = 0; i < chunks.size(); i++) {
-                float sim = SimilarityFunction.COSINE.compute(query, corpus[i]);
-                exactMap.put(sim, chunks.get(i).id());
-            }
-            java.util.Set<String> exactTop = new java.util.HashSet<>();
-            exactMap.entrySet().stream().limit(k).forEach(e -> exactTop.add(e.getValue()));
-
-            // SpectorIndex top-k
-            ScoredResult[] approx = index.search(query, k);
-            java.util.Set<String> approxIds = new java.util.HashSet<>();
-            for (ScoredResult r : approx) approxIds.add(r.id());
-
-            long overlap = exactTop.stream().filter(approxIds::contains).count();
-            totalRecall += (double) overlap / k;
-        }
-
-        double avgRecall = totalRecall / queries;
-        System.out.printf("Recall@10 on real embeddings (D=768, n=%d): %.1f%%%n",
-                chunks.size(), avgRecall * 100);
-
-        assertThat(avgRecall)
-                .as("Average recall@10 on real embeddings should be ≥ 75%%. Got: %.1f%%", avgRecall * 100)
-                .isGreaterThanOrEqualTo(0.75);
-    }
-
-    // ── Helpers ───────────────────────────────────────────────────────────────
-
-    /**
-     * Simple character-level chunker with overlap.
-     */
-    private static List<String> chunkText(String text, int chunkSize, int overlap) {
-        List<String> chunks = new ArrayList<>();
-        int len = text.length();
-        int start = 0;
-        while (start < len) {
-            int end = Math.min(start + chunkSize, len);
-            chunks.add(text.substring(start, end).strip());
-            if (end == len) break;
-            start = end - overlap;
-        }
-        return chunks;
-    }
-}
diff --git a/spector-index/src/test/java/com/spectrayan/spector/index/spectrum/SpectorIndexTest.java b/spector-index/src/test/java/com/spectrayan/spector/index/spectrum/SpectorIndexTest.java
deleted file mode 100644
index 2c1f80d..0000000
--- a/spector-index/src/test/java/com/spectrayan/spector/index/spectrum/SpectorIndexTest.java
+++ /dev/null
@@ -1,383 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.index.spectrum;
-
-import com.spectrayan.spector.commons.error.SpectorException;
-
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-
-import com.spectrayan.spector.core.similarity.SimilarityFunction;
-import com.spectrayan.spector.config.HnswParams;
-import com.spectrayan.spector.index.ScoredResult;
-
-import org.junit.jupiter.api.Test;
-
-import java.util.ArrayList;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Random;
-import java.util.Set;
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.atomic.AtomicInteger;
-
-import static org.assertj.core.api.Assertions.*;
-
-/**
- * Correctness, recall, and concurrency tests for {@link SpectorIndex}.
- *
- * <h3>Test Strategy</h3>
- * <ol>
- *   <li><b>Smoke</b>: basic add/search lifecycle</li>
- *   <li><b>Recall@10</b>: compare SpectorIndex top-10 against brute-force exact search.
- *       Requires ≥ 80% overlap. This validates SVASQ quantization + IVF routing accuracy.</li>
- *   <li><b>Promotion</b>: verify flat→HNSW promotion occurs at shardThreshold; shard reports promoted.</li>
- *   <li><b>Concurrent stress</b>: 8 writer threads + 8 reader threads hammering the same index
- *       for 3 seconds. No exceptions, no deadlocks, no data corruption.</li>
- * </ol>
- */
-class SpectorIndexTest {
-
-    // ── Smoke ────────────────────────────────────────────────────────────────
-
-    @Test
-    void emptyIndex_returnsNoResults() {
-        var index = buildIndex(64, 32, 8);
-        float[][] training = randomVectors(100, 64, 1L);
-        index.train(training);
-
-        ScoredResult[] results = index.search(randomVectors(1, 64, 2L)[0], 10);
-        assertThat(results).isEmpty();
-    }
-
-    @Test
-    void trainThenAddThenSearch_returnsResults() {
-        int dims = 64, n = 500;
-        float[][] vectors = randomVectors(n, dims, 42L);
-        var index = buildIndex(dims, 32, 8);
-
-        index.train(vectors);
-        for (int i = 0; i < n; i++) {
-            index.add("doc-" + i, i, vectors[i]);
-        }
-
-        assertThat(index.size()).isEqualTo(n);
-
-        ScoredResult[] results = index.search(vectors[0], 10);
-        assertThat(results).isNotEmpty();
-        assertThat(results[0].id()).isEqualTo("doc-0"); // query == vectors[0], should be top-1
-    }
-
-    @Test
-    void addBeforeTrain_throws() {
-        var index = buildIndex(32, 16, 4);
-        assertThatThrownBy(() -> index.add("x", 0, new float[32]))
-                .isInstanceOf(SpectorException.class);
-    }
-
-    @Test
-    void searchBeforeTrain_throws() {
-        var index = buildIndex(32, 16, 4);
-        assertThatThrownBy(() -> index.search(new float[32], 5))
-                .isInstanceOf(SpectorException.class);
-    }
-
-    @Test
-    void wrongDimension_throws() {
-        int dims = 32;
-        float[][] vecs = randomVectors(50, dims, 1L);
-        var index = buildIndex(dims, 16, 4);
-        index.train(vecs);
-        assertThatThrownBy(() -> index.add("x", 0, new float[dims + 1]))
-                .isInstanceOf(SpectorValidationException.class);
-        assertThatThrownBy(() -> index.search(new float[dims + 1], 5))
-                .isInstanceOf(SpectorValidationException.class);
-    }
-
-    // ── Recall@10 ────────────────────────────────────────────────────────────
-
-    /**
-     * Recall@10 test: SpectorIndex must return ≥ 80% of the brute-force top-10.
-     *
-     * <p>Uses EUCLIDEAN (L2) distance, which is <b>centroid-invariant</b>:
-     * {@code ||q - x||² = ||(q - c) - (x - c)||²}. This means the brute-force ranking
-     * in absolute space is identical to the residual-space ranking inside each shard.
-     * Cosine similarity is NOT centroid-invariant ({@code cos(a-c, b-c) ≠ cos(a, b)}),
-     * so using it here would produce a misleading recall measurement — the brute-force
-     * baseline ranks differently from the residual-space search.</p>
-     *
-     * <p>SpectorIndex uses IVF routing (nProbe=16 of 32 cells) + flat shards (below threshold).
-     * 80% recall is a conservative floor — typical values are 90-95%.</p>
-     */
-    @Test
-    void recall10_atLeast80Percent() {
-        int dims = 128, n = 2_000, queries = 50, k = 10;
-        float[][] corpus = randomVectors(n, dims, 7L);
-
-        var index = SpectorIndex.builder()
-                .dimensions(dims)
-                .nCentroids(32)
-                .nProbe(32)             // probe ALL centroids → recall loss is 0% from IVF routing
-                .shardThreshold(5_000)  // keep shards in flat mode for this test
-                .oversamplingFactor(3)
-                .similarityFunction(SimilarityFunction.EUCLIDEAN)
-                .hnswParams(HnswParams.DEFAULT)
-                .build();
-
-        index.train(corpus);
-        for (int i = 0; i < n; i++) {
-            index.add("doc-" + i, i, corpus[i]);
-        }
-
-        Random rng = new Random(99L);
-        double totalRecall = 0;
-
-        for (int q = 0; q < queries; q++) {
-            float[] query = randomVector(rng, dims);
-
-            // Brute-force exact top-k in absolute space (L2 is centroid-invariant)
-            Set<String> exactTop = bruteForceTopK(corpus, query, k, SimilarityFunction.EUCLIDEAN);
-
-            // SpectorIndex result
-            ScoredResult[] approx = index.search(query, k);
-            Set<String> approxIds = new HashSet<>();
-            for (ScoredResult r : approx) approxIds.add(r.id());
-
-            long overlap = exactTop.stream().filter(approxIds::contains).count();
-            totalRecall += (double) overlap / k;
-        }
-
-        double avgRecall = totalRecall / queries;
-        assertThat(avgRecall)
-                .as("Average recall@10 over %d queries should be ≥ 95%%; got %.1f%%", queries, avgRecall * 100)
-                .isGreaterThanOrEqualTo(0.95);
-    }
-
-    // ── Promotion ─────────────────────────────────────────────────────────────
-
-    @Test
-    void shard_promotesToHnsw_afterThreshold() {
-        int dims = 64, threshold = 200;
-        float[][] corpus = randomVectors(threshold + 50, dims, 13L);
-
-        var index = SpectorIndex.builder()
-                .dimensions(dims)
-                .nCentroids(4)          // few cells → one shard fills quickly
-                .nProbe(4)
-                .shardThreshold(threshold)
-                .similarityFunction(SimilarityFunction.COSINE)
-                .build();
-
-        index.train(corpus);
-        for (int i = 0; i < corpus.length; i++) {
-            index.add("doc-" + i, i, corpus[i]);
-        }
-
-        // After enough inserts, search should still return results (promotion didn't break anything)
-        ScoredResult[] results = index.search(corpus[0], 5);
-        assertThat(results).isNotEmpty();
-        assertThat(index.size()).isEqualTo(corpus.length);
-    }
-
-    // ── Concurrent stress ─────────────────────────────────────────────────────
-
-    /**
-     * Concurrent add + search: 8 writer VTs + 8 reader VTs for 2 seconds.
-     *
-     * <p>Success criteria:
-     * <ul>
-     *   <li>No exception thrown by any thread</li>
-     *   <li>No deadlock (test completes within 10-second timeout)</li>
-     *   <li>Final index size equals the number of successful adds</li>
-     * </ul>
-     * </p>
-     */
-    @Test
-    void concurrent_addAndSearch_noDeadlockNoCorruption() throws InterruptedException {
-        int dims = 64;
-        float[][] training = randomVectors(200, dims, 1L);
-
-        var index = SpectorIndex.builder()
-                .dimensions(dims)
-                .nCentroids(16)
-                .nProbe(4)
-                .shardThreshold(100_000)  // high threshold: no promotion during test
-                .similarityFunction(SimilarityFunction.COSINE)
-                .build();
-
-        index.train(training);
-
-        int writerCount = 8, readerCount = 8;
-        long durationMs = 2_000;
-        AtomicInteger addedCount = new AtomicInteger(0);
-        AtomicInteger errorCount = new AtomicInteger(0);
-        CountDownLatch startLatch = new CountDownLatch(1);
-
-        // Volatile stop flag — immune to system load affecting timing checks
-        // Unlike System.currentTimeMillis() polling, a volatile read is a single
-        // CPU instruction that cannot be delayed by lock contention or GC pauses.
-        var stop = new Object() { volatile boolean value = false; };
-
-        List<Thread> threads = new ArrayList<>();
-
-        // Writers: continuously add random vectors
-        Random[] rngs = new Random[writerCount];
-        for (int i = 0; i < writerCount; i++) {
-            rngs[i] = new Random(i * 100L);
-        }
-
-        for (int w = 0; w < writerCount; w++) {
-            final int wIdx = w;
-            Thread t = Thread.ofVirtual().name("writer-" + w).start(() -> {
-                try {
-                    startLatch.await();
-                    while (!stop.value) {
-                        int id = addedCount.incrementAndGet();
-                        float[] vec = randomVector(rngs[wIdx], dims);
-                        index.add("concurrent-" + id, id, vec);
-                    }
-                } catch (InterruptedException e) {
-                    Thread.currentThread().interrupt();
-                } catch (Exception e) {
-                    System.err.println("[SpectorIndexTest] Writer thread " + wIdx + " error: " + e);
-                    e.printStackTrace(System.err);
-                    errorCount.incrementAndGet();
-                }
-            });
-            threads.add(t);
-        }
-
-        // Readers: continuously search — each reader gets its own Random for thread safety
-        for (int r = 0; r < readerCount; r++) {
-            final int rIdx = r;
-            Thread t = Thread.ofVirtual().name("reader-" + r).start(() -> {
-                Random localRng = new Random(999L + rIdx);
-                try {
-                    startLatch.await();
-                    while (!stop.value) {
-                        float[] query = randomVector(localRng, dims);
-                        ScoredResult[] results = index.search(query, 5);
-                        // Results may be empty (index might have been empty initially) — that's fine
-                        for (ScoredResult r2 : results) {
-                            assertThat(r2.score()).isFinite();
-                        }
-                    }
-                } catch (InterruptedException e) {
-                    Thread.currentThread().interrupt();
-                } catch (Exception e) {
-                    System.err.println("[SpectorIndexTest] Reader thread " + rIdx + " error: " + e);
-                    e.printStackTrace(System.err);
-                    errorCount.incrementAndGet();
-                }
-            });
-            threads.add(t);
-        }
-
-        startLatch.countDown();
-
-        // Let the stress test run for the configured duration
-        Thread.sleep(durationMs);
-        stop.value = true;
-
-        // Join with generous per-thread timeout — if any thread is stuck in a lock,
-        // it will see stop=true immediately after acquiring the lock and exit.
-        for (Thread t : threads) {
-            t.join(10_000);
-            if (t.isAlive()) {
-                t.interrupt();
-                t.join(1_000);
-            }
-        }
-
-        assertThat(errorCount.get())
-                .as("No exceptions should occur during concurrent add+search")
-                .isZero();
-
-        assertThat(index.size())
-                .as("Index size should equal number of successful adds")
-                .isEqualTo(addedCount.get());
-    }
-
-    // ── Helpers ───────────────────────────────────────────────────────────────
-
-    private static SpectorIndex buildIndex(int dims, int nCentroids, int nProbe) {
-        return SpectorIndex.builder()
-                .dimensions(dims)
-                .nCentroids(nCentroids)
-                .nProbe(nProbe)
-                .similarityFunction(SimilarityFunction.COSINE)
-                .build();
-    }
-
-    /**
-     * Brute-force exact top-k. Returns the set of document IDs.
-     * Respects {@link SimilarityFunction#higherIsBetter()} for correct ranking.
-     */
-    private static Set<String> bruteForceTopK(float[][] corpus, float[] query, int k,
-                                               SimilarityFunction fn) {
-        boolean higherIsBetter = fn.higherIsBetter();
-        record Scored(String id, float score) {}
-        List<Scored> all = new ArrayList<>(corpus.length);
-        for (int i = 0; i < corpus.length; i++) {
-            all.add(new Scored("doc-" + i, fn.compute(query, corpus[i])));
-        }
-        // Sort: best first. For cosine/dot (higher=better): descending. For L2 (lower=better): ascending.
-        if (higherIsBetter) {
-            all.sort((a, b) -> Float.compare(b.score(), a.score()));
-        } else {
-            all.sort((a, b) -> Float.compare(a.score(), b.score()));
-        }
-        Set<String> top = new HashSet<>();
-        for (int i = 0; i < k && i < all.size(); i++) top.add(all.get(i).id());
-        return top;
-    }
-
-    private static float[][] randomVectors(int n, int dims, long seed) {
-        Random rng = new Random(seed);
-        float[][] vs = new float[n][dims];
-        for (float[] v : vs) for (int i = 0; i < dims; i++) v[i] = rng.nextFloat() * 2 - 1;
-        return vs;
-    }
-
-    private static float[][] normalizedVectors(int n, int dims, long seed) {
-        Random rng = new Random(seed);
-        float[][] vs = new float[n][dims];
-        for (float[] v : vs) {
-            for (int i = 0; i < dims; i++) v[i] = rng.nextFloat() * 2 - 1;
-            normalize(v);
-        }
-        return vs;
-    }
-
-    private static float[] normalizedVector(Random rng, int dims) {
-        float[] v = new float[dims];
-        for (int i = 0; i < dims; i++) v[i] = rng.nextFloat() * 2 - 1;
-        normalize(v);
-        return v;
-    }
-
-    private static float[] randomVector(Random rng, int dims) {
-        float[] v = new float[dims];
-        for (int i = 0; i < dims; i++) v[i] = rng.nextFloat() * 2 - 1;
-        return v;
-    }
-
-    private static void normalize(float[] v) {
-        float norm = 0;
-        for (float x : v) norm += x * x;
-        norm = (float) Math.sqrt(norm);
-        if (norm > 0) for (int i = 0; i < v.length; i++) v[i] /= norm;
-    }
-}
diff --git a/spector-ingestion/README.md b/spector-ingestion/README.md
deleted file mode 100644
index 3a17815..0000000
--- a/spector-ingestion/README.md
+++ /dev/null
@@ -1,119 +0,0 @@
-# spector-ingestion 📥
-
-> **Unified ingestion pipeline — builder-configured chunk → embed → store orchestration.**
-
-`spector-ingestion` defines the core `IngestionPipeline` and `IngestionTarget` interface. It has **no dependency on engine, runtime, or memory** — downstream modules implement the `IngestionTarget` interface for their storage backends.
-
----
-
-## 🏗️ Architecture
-
-```
-spector-ingestion (core pipeline + interface)
-├── IngestionPipeline       — builder-configured: chunk → embed → store
-├── IngestionTarget         — interface for storage backends
-├── IngestionResult         — result record for ingestion operations
-├── FileDiscoveryService    — file discovery + title extraction
-└── StreamingChunker bridge — bounded-memory file processing
-
-Dependencies:
-├── spector-config     (configuration)
-├── spector-commons    (TextChunker, StreamingChunker)
-└── spector-embed-api  (EmbeddingProvider, ParallelEmbeddingPipeline)
-```
-
-> [!IMPORTANT]
-> This module does **NOT** depend on `spector-engine` or `spector-memory`. Those modules depend on `spector-ingestion` to implement `IngestionTarget`.
-
----
-
-## 🚀 Key APIs
-
-### Builder Pattern
-
-```java
-// Read config from spector.yml
-var config = SpectorConfigFactory.ingestionDefaults(props);
-
-var pipeline = IngestionPipeline.builder()
-    .target(myTarget)                          // required
-    .embeddingProvider(embedder)               // optional (not needed for pre-embedded)
-    .chunking(new TextChunker(config.chunkSize(), config.chunkOverlap()))
-    .chunkThreshold(config.chunkSize())        // auto-chunk if content > this
-    .build();
-
-// Single API — pipeline decides strategy internally
-IngestionResult result = pipeline.ingest("doc-1", content);
-```
-
-### IngestionTarget Interface
-
-```java
-public interface IngestionTarget {
-    void ingest(String id, String text, float[] vector);
-    default void storeParentMetadata(String parentId, int chunkCount) {}
-    default void onBatchComplete() {}
-}
-```
-
-**Implementations:**
-
-| Target | Module | Storage path |
-|--------|--------|-------------|
-| `EngineIngestionTarget` | `spector-engine` | VectorStore → VectorIndex → KeywordIndex |
-| `CognitiveIngestionTarget` | `spector-memory` | Quantize → Surprise → Tier route → WAL |
-
-### File Discovery
-
-```java
-var discovery = FileDiscoveryService.fromProperties(props, rootDir);
-List<Path> files = discovery.discover();
-
-// Title extraction
-String title = FileDiscoveryService.extractTitle(content, "fallback.md");
-```
-
-### Ingestion Modes
-
-```java
-// Auto-chunked text (pipeline decides based on content length)
-IngestionResult result = pipeline.ingest("doc-1", longText);
-
-// Pre-embedded (skip embedding)
-IngestionResult result = pipeline.ingest("doc-1", text, precomputedVector);
-
-// Streaming file (bounded memory for large files)
-IngestionResult result = pipeline.ingest(Path.of("corpus.txt"), "corpus");
-```
-
----
-
-## 📊 Result Tracking
-
-```java
-public record IngestionResult(
-    String documentId,
-    int chunksStored,
-    List<String> failures,
-    long durationMs
-) {
-    boolean isFullSuccess();  // true if no failures
-}
-```
-
----
-
-## 🔗 How It Fits
-
-All entry points (CLI, MCP, Server) route through `SpectorRuntime`:
-
-```
-CLI/MCP/Server → SpectorRuntime.ingestion() → IngestionHandler → IngestionPipeline
-                                                                        │
-                                                                  ┌─────┴─────┐
-                                                                  ▼           ▼
-                                                       EngineIngestionTarget  CognitiveIngestionTarget
-                                                       (SEARCH mode)          (MEMORY mode)
-```
-
-`SpectorRuntime.ingestion()` builds the pipeline with the right target based on the active mode and reads chunking config from `spector.yml`.
diff --git a/spector-ingestion/pom.xml b/spector-ingestion/pom.xml
deleted file mode 100644
index 3d8c5b5..0000000
--- a/spector-ingestion/pom.xml
+++ /dev/null
@@ -1,44 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0"
-         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
-    <modelVersion>4.0.0</modelVersion>
-
-    <parent>
-        <groupId>com.spectrayan</groupId>
-        <artifactId>spector</artifactId>
-        <version>0.1.0-SNAPSHOT</version>
-    </parent>
-
-    <artifactId>spector-ingestion</artifactId>
-    <name>Spector Ingestion</name>
-    <description>Pure ingestion utilities: file discovery, text chunking, title extraction.
-        No dependency on runtime or engine — used as a utility by spector-runtime.</description>
-
-    <dependencies>
-
-        <!-- ── Config (SpectorProperties for fromProperties factory) ── -->
-        <dependency>
-            <groupId>com.spectrayan</groupId>
-            <artifactId>spector-config</artifactId>
-        </dependency>
-
-        <!-- ── Embedding API (EmbeddingProvider interface) ── -->
-        <dependency>
-            <groupId>com.spectrayan</groupId>
-            <artifactId>spector-embed-api</artifactId>
-        </dependency>
-
-        <!-- ── Ollama Embedding Provider (runtime — loaded via reflection) ── -->
-        <dependency>
-            <groupId>com.spectrayan</groupId>
-            <artifactId>spector-embed-ollama</artifactId>
-            <scope>runtime</scope>
-        </dependency>
-        <dependency>
-            <groupId>com.spectrayan</groupId>
-            <artifactId>spector-commons</artifactId>
-        </dependency>
-    </dependencies>
-
-</project>
diff --git a/spector-ingestion/src/main/java/com/spectrayan/spector/ingestion/EmbeddingProviderFactory.java b/spector-ingestion/src/main/java/com/spectrayan/spector/ingestion/EmbeddingProviderFactory.java
deleted file mode 100644
index 64713ae..0000000
--- a/spector-ingestion/src/main/java/com/spectrayan/spector/ingestion/EmbeddingProviderFactory.java
+++ /dev/null
@@ -1,60 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.ingestion;
-
-import com.spectrayan.spector.embed.EmbeddingProvider;
-import com.spectrayan.spector.commons.error.SpectorEmbeddingException;
-import com.spectrayan.spector.embed.error.SpectorEmbeddingUnavailableException;
-import com.spectrayan.spector.commons.error.SpectorServerException;
-import com.spectrayan.spector.commons.error.ErrorCode;
-
-/**
- * Factory for creating {@link EmbeddingProvider} instances.
- *
- * <p>Uses reflection to instantiate the Ollama provider since
- * {@code spector-embed-ollama} is an optional runtime dependency.</p>
- */
-public final class EmbeddingProviderFactory {
-
-    private EmbeddingProviderFactory() {}
-
-    /**
-     * Creates an Ollama embedding provider.
-     *
-     * @param baseUrl Ollama server URL (e.g., "http://localhost:11434")
-     * @param model   embedding model name (e.g., "nomic-embed-text")
-     * @return configured embedding provider
-     * @throws SpectorEmbeddingException if spector-embed-ollama is not on the classpath
-     */
-    public static EmbeddingProvider create(String baseUrl, String model) {
-        try {
-            var configClass = Class.forName("com.spectrayan.spector.embed.EmbeddingConfig");
-            var ollamaFactory = configClass.getMethod("ollama", String.class);
-            Object config = ollamaFactory.invoke(null, model);
-            var withBaseUrl = configClass.getMethod("withBaseUrl", String.class);
-            config = withBaseUrl.invoke(config, baseUrl);
-
-            var providerClass = Class.forName(
-                    "com.spectrayan.spector.embed.ollama.OllamaEmbeddingProvider");
-            var constructor = providerClass.getConstructor(configClass);
-            return (EmbeddingProvider) constructor.newInstance(config);
-        } catch (ClassNotFoundException e) {
-            throw new SpectorEmbeddingUnavailableException("Ollama (spector-embed-ollama not on classpath)", e);
-        } catch (Exception e) {
-            throw new SpectorServerException(ErrorCode.INTERNAL_ERROR, e, "Failed to create OllamaEmbeddingProvider");
-        }
-    }
-}
diff --git a/spector-ingestion/src/main/java/com/spectrayan/spector/ingestion/FileDiscoveryService.java b/spector-ingestion/src/main/java/com/spectrayan/spector/ingestion/FileDiscoveryService.java
deleted file mode 100644
index 92b773f..0000000
--- a/spector-ingestion/src/main/java/com/spectrayan/spector/ingestion/FileDiscoveryService.java
+++ /dev/null
@@ -1,190 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.ingestion;
-
-import java.io.IOException;
-import java.nio.file.FileVisitResult;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.nio.file.SimpleFileVisitor;
-import java.nio.file.attribute.BasicFileAttributes;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-import java.util.Set;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import com.spectrayan.spector.config.SpectorConfigFactory;
-import com.spectrayan.spector.config.SpectorProperties;
-
-/**
- * File discovery service — finds files matching patterns in a directory tree.
- *
- * <p>This is a pure utility service that discovers files without performing
- * ingestion. It reads configuration from {@link SpectorProperties} and
- * provides the file list to be ingested via {@link IngestionPipeline}.</p>
- *
- * <h3>Usage</h3>
- * <pre>{@code
- *   var discovery = FileDiscoveryService.fromProperties(props, rootDir);
- *   List<Path> files = discovery.discover();
- *
- *   for (Path file : files) {
- *       pipeline.ingest(file, file.getFileName().toString());
- *   }
- * }</pre>
- */
-public class FileDiscoveryService {
-
-    private static final Logger log = LoggerFactory.getLogger(FileDiscoveryService.class);
-
-    private final Path rootDirectory;
-    private final String filePattern;
-    private final Set<String> skipDirs;
-    private final int chunkSize;
-    private final int chunkOverlap;
-
-    private FileDiscoveryService(Builder builder) {
-        this.rootDirectory = builder.rootDirectory.toAbsolutePath().normalize();
-        this.filePattern = builder.filePattern;
-        this.skipDirs = Set.copyOf(builder.skipDirs);
-        this.chunkSize = builder.chunkSize;
-        this.chunkOverlap = builder.chunkOverlap;
-    }
-
-    // ─────────────── Factory Methods ───────────────
-
-    /**
-     * Creates a service from hierarchical properties.
-     *
-     * @param props   configuration properties
-     * @param rootDir the root directory to discover files from
-     * @return configured file discovery service
-     */
-    public static FileDiscoveryService fromProperties(SpectorProperties props, Path rootDir) {
-        var ingestion = SpectorConfigFactory.ingestionDefaults(props);
-        return builder()
-                .rootDirectory(rootDir)
-                .filePattern(ingestion.filePattern())
-                .skipDirs(ingestion.skipDirs().split(","))
-                .chunkSize(ingestion.chunkSize())
-                .chunkOverlap(ingestion.chunkOverlap())
-                .build();
-    }
-
-    /** Creates a new builder. */
-    public static Builder builder() {
-        return new Builder();
-    }
-
-    // ─────────────── Discovery ───────────────
-
-    /**
-     * Discovers files matching the configured pattern in the root directory.
-     *
-     * @return sorted list of matching file paths
-     * @throws IOException if directory traversal fails
-     */
-    public List<Path> discover() throws IOException {
-        List<Path> files = new ArrayList<>();
-        String extension = extractExtension(filePattern);
-
-        Files.walkFileTree(rootDirectory, new SimpleFileVisitor<>() {
-            @Override
-            public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) {
-                String dirName = dir.getFileName().toString();
-                if (skipDirs.contains(dirName)) {
-                    return FileVisitResult.SKIP_SUBTREE;
-                }
-                return FileVisitResult.CONTINUE;
-            }
-
-            @Override
-            public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) {
-                if (matchesPattern(file, extension)) {
-                    files.add(file);
-                }
-                return FileVisitResult.CONTINUE;
-            }
-        });
-
-        files.sort(Path::compareTo);
-        log.info("Discovered {} files matching '{}' in {}", files.size(), filePattern, rootDirectory);
-        return files;
-    }
-
-    // ─────────────── Accessors ───────────────
-
-    /** Returns the root directory. */
-    public Path rootDirectory() { return rootDirectory; }
-
-    /** Returns the file pattern. */
-    public String filePattern() { return filePattern; }
-
-    /** Returns the chunk size. */
-    public int chunkSize() { return chunkSize; }
-
-    /** Returns the chunk overlap. */
-    public int chunkOverlap() { return chunkOverlap; }
-
-    // ─────────────── Utilities ───────────────
-
-    /**
-     * Extracts a title from the first heading in the content, or uses the filename as fallback.
-     */
-    public static String extractTitle(String content, String fallback) {
-        for (String line : content.split("\n", 10)) {
-            String trimmed = line.trim();
-            if (trimmed.startsWith("# ")) {
-                return trimmed.substring(2).trim();
-            }
-        }
-        int lastDot = fallback.lastIndexOf('.');
-        return (lastDot > 0 ? fallback.substring(0, lastDot) : fallback)
-                .replace('/', ' ')
-                .replace('\\', ' ');
-    }
-
-    private static String extractExtension(String pattern) {
-        int lastDot = pattern.lastIndexOf('.');
-        return lastDot >= 0 ? pattern.substring(lastDot) : "";
-    }
-
-    private static boolean matchesPattern(Path file, String extension) {
-        if (extension.isEmpty()) return true;
-        return file.getFileName().toString().endsWith(extension);
-    }
-
-    // ─────────────── Builder ───────────────
-
-    public static class Builder {
-        private Path rootDirectory = Path.of(".");
-        private String filePattern = "**/*.md";
-        private List<String> skipDirs = List.of(".git", ".idea", ".mvn", "target", "node_modules", ".github");
-        private int chunkSize = 800;
-        private int chunkOverlap = 100;
-
-        public Builder rootDirectory(Path rootDirectory) { this.rootDirectory = rootDirectory; return this; }
-        public Builder filePattern(String filePattern) { this.filePattern = filePattern; return this; }
-        public Builder skipDirs(String... dirs) { this.skipDirs = Arrays.asList(dirs); return this; }
-        public Builder skipDirs(List<String> dirs) { this.skipDirs = dirs; return this; }
-        public Builder chunkSize(int chunkSize) { this.chunkSize = chunkSize; return this; }
-        public Builder chunkOverlap(int chunkOverlap) { this.chunkOverlap = chunkOverlap; return this; }
-        public FileDiscoveryService build() { return new FileDiscoveryService(this); }
-    }
-}
diff --git a/spector-ingestion/src/main/java/com/spectrayan/spector/ingestion/IngestionPipeline.java b/spector-ingestion/src/main/java/com/spectrayan/spector/ingestion/IngestionPipeline.java
deleted file mode 100644
index eeff0db..0000000
--- a/spector-ingestion/src/main/java/com/spectrayan/spector/ingestion/IngestionPipeline.java
+++ /dev/null
@@ -1,337 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.ingestion;
-
-import java.io.IOException;
-import java.nio.file.Path;
-import java.util.ArrayList;
-import java.util.List;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import com.spectrayan.spector.commons.StreamingChunker;
-import com.spectrayan.spector.commons.TextChunker;
-import com.spectrayan.spector.embed.EmbeddingProvider;
-import com.spectrayan.spector.embed.EmbedConfig;
-import com.spectrayan.spector.embed.ParallelEmbeddingPipeline;
-import com.spectrayan.spector.embed.PipelineEmbeddingResult;
-import com.spectrayan.spector.commons.error.SpectorInternalException;
-import com.spectrayan.spector.commons.error.ErrorCode;
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-
-/**
- * Unified ingestion pipeline: chunk → embed → store.
- *
- * <p>Configured via a {@link Builder} and exposes a single {@link #ingest}
- * entry point. The pipeline decides the strategy (direct, chunked, streaming)
- * based on builder configuration and content characteristics.</p>
- *
- * <h3>Strategy Selection</h3>
- * <ul>
- *   <li><b>Direct</b>: content ≤ chunkThreshold or no chunker configured</li>
- *   <li><b>Chunked</b>: content > chunkThreshold and chunker configured</li>
- *   <li><b>Streaming</b>: file path provided — reads lazily via {@link StreamingChunker}</li>
- *   <li><b>Pre-embedded</b>: vector provided — skips embedding entirely</li>
- * </ul>
- *
- * <h3>Usage</h3>
- * <pre>{@code
- *   var pipeline = IngestionPipeline.builder()
- *       .target(engineTarget)
- *       .embeddingProvider(embedder)
- *       .chunking(new TextChunker(800, 100))
- *       .chunkThreshold(800)
- *       .build();
- *
- *   IngestionResult result = pipeline.ingest("doc-1", content);
- * }</pre>
- *
- * @see IngestionTarget
- * @see Builder
- */
-public class IngestionPipeline {
-
-    private static final Logger log = LoggerFactory.getLogger(IngestionPipeline.class);
-
-    private final IngestionTarget target;
-    private final EmbeddingProvider embeddingProvider; // nullable for pre-embedded mode
-    private final ParallelEmbeddingPipeline parallelPipeline; // nullable
-    private final TextChunker chunker;   // nullable (no chunking if absent)
-    private final int chunkThreshold;    // auto-chunk if content length exceeds this
-
-    private IngestionPipeline(Builder builder) {
-        this.target = builder.target;
-        this.embeddingProvider = builder.embeddingProvider;
-        this.chunker = builder.chunker;
-        this.chunkThreshold = builder.chunkThreshold;
-
-        // Initialize parallel embedding pipeline if provider is available
-        this.parallelPipeline = builder.embeddingProvider != null
-                ? new ParallelEmbeddingPipeline(builder.embeddingProvider) : null;
-
-        log.info("IngestionPipeline created: chunker={}, chunkThreshold={}, hasEmbedder={}, target={}",
-                chunker != null ? chunker.getClass().getSimpleName() : "none",
-                chunkThreshold,
-                embeddingProvider != null,
-                target.getClass().getSimpleName());
-    }
-
-    /** Creates a new builder. */
-    public static Builder builder() {
-        return new Builder();
-    }
-
-    // ═══════════════════════════════════════════════════════════════
-    // PUBLIC API — single ingest() method with overloads
-    // ═══════════════════════════════════════════════════════════════
-
-    /**
-     * Ingests text content with auto-embedding.
-     *
-     * <p>The pipeline automatically selects the strategy based on configuration:
-     * <ul>
-     *   <li>If content length > chunkThreshold and a chunker is configured → chunk then embed</li>
-     *   <li>Otherwise → embed the entire text as a single document</li>
-     * </ul>
-     *
-     * @param id      document ID
-     * @param content text content
-     * @return ingestion result
-     * @throws SpectorValidationException if no embedding provider is configured
-     */
-    public IngestionResult ingest(String id, String content) {
-        requireEmbeddingProvider();
-        long start = System.nanoTime();
-
-        if (shouldChunk(content)) {
-            return chunkAndIngest(id, content, start);
-        }
-        return directIngest(id, content, start);
-    }
-
-    /**
-     * Ingests text content with a pre-computed embedding vector.
-     *
-     * <p>Skips embedding entirely — the provided vector is passed directly
-     * to the target. No chunking is applied (pre-embedded implies the
-     * caller has already handled chunking if needed).</p>
-     *
-     * @param id      document ID
-     * @param content text content
-     * @param vector  pre-computed embedding vector
-     * @return ingestion result
-     */
-    public IngestionResult ingest(String id, String content, float[] vector) {
-        long start = System.nanoTime();
-
-        target.ingest(id, content, vector);
-
-        long elapsed = (System.nanoTime() - start) / 1_000_000;
-        return IngestionResult.single(id, elapsed);
-    }
-
-    /**
-     * Ingests a file by streaming its content chunk-by-chunk.
-     *
-     * <p>Uses {@link StreamingChunker} for bounded-memory file processing.
-     * Each chunk is embedded and stored independently — the full file content
-     * is never held in memory.</p>
-     *
-     * @param file       path to the text file
-     * @param documentId parent document ID
-     * @return ingestion result
-     * @throws IOException if the file cannot be read
-     */
-    public IngestionResult ingest(Path file, String documentId) throws IOException {
-        requireEmbeddingProvider();
-        long start = System.nanoTime();
-
-        int chunkSize = chunker != null ? chunker.chunkSize() : 800;
-        int overlap = chunker != null ? chunker.overlap() : 100;
-
-        int count = 0;
-        List<String> failures = new ArrayList<>();
-
-        try (var stream = StreamingChunker.chunkFile(file, documentId, chunkSize, overlap)) {
-            var iter = stream.iterator();
-            while (iter.hasNext()) {
-                var chunk = iter.next();
-                try {
-                    float[] vector = embeddingProvider.embed(chunk.text()).vector();
-                    target.ingest(chunk.chunkId(), chunk.text(), vector);
-                    count++;
-                } catch (Exception e) {
-                    failures.add(chunk.chunkId());
-                    log.warn("Streaming ingestion failed for chunk '{}': {}",
-                            chunk.chunkId(), e.getMessage());
-                }
-            }
-        }
-
-        target.storeParentMetadata(documentId, count);
-        target.onBatchComplete();
-
-        long elapsed = (System.nanoTime() - start) / 1_000_000;
-        log.info("Stream-ingested '{}' → {} chunks ({} failed) in {}ms",
-                file.getFileName(), count, failures.size(), elapsed);
-        return IngestionResult.chunked(documentId, count, failures, elapsed);
-    }
-
-    // ═══════════════════════════════════════════════════════════════
-    // INTERNAL STRATEGIES — selected by ingest() based on config
-    // ═══════════════════════════════════════════════════════════════
-
-    /**
-     * Direct single-document ingestion: embed → store.
-     */
-    private IngestionResult directIngest(String id, String content, long startNanos) {
-        float[] vector = embeddingProvider.embed(content).vector();
-        target.ingest(id, content, vector);
-        target.storeParentMetadata(id, 1);
-
-        long elapsed = (System.nanoTime() - startNanos) / 1_000_000;
-        return IngestionResult.single(id, elapsed);
-    }
-
-    /**
-     * Chunked ingestion with parallel embedding.
-     *
-     * <p>Splits content into chunks via the configured chunker, embeds all
-     * chunks in parallel using virtual threads, then stores each chunk.</p>
-     */
-    private IngestionResult chunkAndIngest(String id, String content, long startNanos) {
-        var chunks = chunker.chunk(id, content);
-        List<String> texts = chunks.stream().map(TextChunker.Chunk::text).toList();
-
-        // Parallel embedding using virtual threads
-        List<PipelineEmbeddingResult> embeddings = parallelPipeline.embed(texts, EmbedConfig.DEFAULT);
-
-        List<String> failures = new ArrayList<>();
-        int stored = 0;
-
-        for (int i = 0; i < chunks.size(); i++) {
-            var chunk = chunks.get(i);
-            var embedding = embeddings.get(i);
-
-            if (embedding.success()) {
-                target.ingest(chunk.chunkId(), chunk.text(), embedding.embedding());
-                stored++;
-            } else {
-                failures.add(chunk.chunkId());
-                log.warn("Embedding failed for chunk '{}': {}", chunk.chunkId(), embedding.error());
-            }
-        }
-
-        target.storeParentMetadata(id, stored);
-        target.onBatchComplete();
-
-        long elapsed = (System.nanoTime() - startNanos) / 1_000_000;
-        log.info("Ingested '{}' as {} chunks ({} failed) in {}ms",
-                id, stored, failures.size(), elapsed);
-        return IngestionResult.chunked(id, stored, failures, elapsed);
-    }
-
-    // ═══════════════════════════════════════════════════════════════
-    // INTERNAL HELPERS
-    // ═══════════════════════════════════════════════════════════════
-
-    private boolean shouldChunk(String content) {
-        return chunker != null && content.length() > chunkThreshold;
-    }
-
-    private void requireEmbeddingProvider() {
-        if (embeddingProvider == null) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_INVALID, "No EmbeddingProvider configured. Use builder().embeddingProvider(provider) " + "or use ingest(id, content, vector) with a pre-computed vector.");
-        }
-    }
-
-    /** Returns true if an embedding provider is configured. */
-    public boolean hasEmbeddingProvider() {
-        return embeddingProvider != null;
-    }
-
-    /** Returns the configured chunker (nullable). */
-    public TextChunker chunker() {
-        return chunker;
-    }
-
-    // ═══════════════════════════════════════════════════════════════
-    // BUILDER
-    // ═══════════════════════════════════════════════════════════════
-
-    /**
-     * Builder for {@link IngestionPipeline}.
-     *
-     * <p>Required: {@link #target(IngestionTarget)}. All other fields are optional.</p>
-     */
-    public static final class Builder {
-        private IngestionTarget target;
-        private EmbeddingProvider embeddingProvider;
-        private TextChunker chunker;
-        private int chunkThreshold = 800;
-
-        private Builder() {}
-
-        /** Sets the target that receives ingested chunks. Required. */
-        public Builder target(IngestionTarget target) {
-            this.target = target;
-            return this;
-        }
-
-        /** Sets the embedding provider for auto-embedding. */
-        public Builder embeddingProvider(EmbeddingProvider embeddingProvider) {
-            this.embeddingProvider = embeddingProvider;
-            return this;
-        }
-
-        /**
-         * Sets the chunker for splitting large documents.
-         *
-         * <p>If not set, all content is ingested as a single document.</p>
-         */
-        public Builder chunking(TextChunker chunker) {
-            this.chunker = chunker;
-            return this;
-        }
-
-        /**
-         * Sets the content length threshold for auto-chunking.
-         *
-         * <p>Content shorter than this is ingested directly; longer content
-         * is split using the configured chunker.</p>
-         *
-         * @param threshold content length in characters (default: 800)
-         */
-        public Builder chunkThreshold(int threshold) {
-            this.chunkThreshold = threshold;
-            return this;
-        }
-
-        /**
-         * Builds the pipeline.
-         *
-         * @return configured ingestion pipeline
-         * @throws SpectorValidationException if no target is set
-         */
-        public IngestionPipeline build() {
-            if (target == null) {
-                throw new SpectorInternalException(ErrorCode.ARGUMENT_NULL, "IngestionTarget");
-            }
-            return new IngestionPipeline(this);
-        }
-    }
-}
\ No newline at end of file
diff --git a/spector-ingestion/src/main/java/com/spectrayan/spector/ingestion/IngestionResult.java b/spector-ingestion/src/main/java/com/spectrayan/spector/ingestion/IngestionResult.java
deleted file mode 100644
index 25cf96a..0000000
--- a/spector-ingestion/src/main/java/com/spectrayan/spector/ingestion/IngestionResult.java
+++ /dev/null
@@ -1,48 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.ingestion;
-
-import java.util.List;
-
-/**
- * Outcome of an ingestion operation.
- *
- * @param documentId   the parent document ID
- * @param chunksStored number of chunks successfully stored
- * @param failures     list of chunk IDs that failed (empty on full success)
- * @param durationMs   total time spent in milliseconds
- */
-public record IngestionResult(
-        String documentId,
-        int chunksStored,
-        List<String> failures,
-        long durationMs
-) {
-    /** Creates a successful single-document result. */
-    public static IngestionResult single(String documentId, long durationMs) {
-        return new IngestionResult(documentId, 1, List.of(), durationMs);
-    }
-
-    /** Creates a chunked result. */
-    public static IngestionResult chunked(String documentId, int chunks, List<String> failures, long durationMs) {
-        return new IngestionResult(documentId, chunks, failures, durationMs);
-    }
-
-    /** Returns true if all chunks were stored successfully. */
-    public boolean isFullSuccess() {
-        return failures.isEmpty();
-    }
-}
diff --git a/spector-ingestion/src/main/java/com/spectrayan/spector/ingestion/IngestionTarget.java b/spector-ingestion/src/main/java/com/spectrayan/spector/ingestion/IngestionTarget.java
deleted file mode 100644
index 416f284..0000000
--- a/spector-ingestion/src/main/java/com/spectrayan/spector/ingestion/IngestionTarget.java
+++ /dev/null
@@ -1,71 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.ingestion;
-
-/**
- * Abstraction for the storage target that ingestion writes to.
- *
- * <p>This decouples the ingestion pipeline from concrete implementations,
- * allowing both search-engine and cognitive-memory targets to receive
- * chunks from the same unified pipeline.</p>
- *
- * <h3>Implementations</h3>
- * <ul>
- *   <li><b>EngineIngestionTarget</b> (spector-engine): VectorStore → HNSW → BM25</li>
- *   <li><b>CognitiveIngestionTarget</b> (spector-memory): quantize → surprise → tier route → WAL</li>
- * </ul>
- *
- * <p>The pipeline calls {@link #ingest(String, String, float[])} for each
- * chunk after embedding. The target handles all downstream storage.</p>
- */
-public interface IngestionTarget {
-
-    /**
-     * Ingests a single chunk/document with its text and embedding vector.
-     *
-     * <p>Called by the pipeline once per chunk after chunking and embedding.
-     * The implementation handles all downstream storage, indexing, and
-     * persistence.</p>
-     *
-     * @param id     document or chunk ID
-     * @param text   the text content of this chunk
-     * @param vector the embedding vector for this chunk
-     */
-    void ingest(String id, String text, float[] vector);
-
-    /**
-     * Stores lightweight parent document metadata after all chunks are ingested.
-     *
-     * <p>Called once per parent document with the total chunk count. This allows
-     * targets to maintain a registry of ingested documents without storing
-     * the full content.</p>
-     *
-     * <p>Default is no-op — cognitive targets may not need parent tracking.</p>
-     *
-     * @param parentId   the parent document ID
-     * @param chunkCount number of chunks the document was split into
-     */
-    default void storeParentMetadata(String parentId, int chunkCount) {}
-
-    /**
-     * Called when a batch of ingestion operations completes.
-     *
-     * <p>Targets can use this for flush operations (WAL sync, index compaction, etc.).</p>
-     *
-     * <p>Default is no-op.</p>
-     */
-    default void onBatchComplete() {}
-}
diff --git a/spector-ingestion/src/main/java/com/spectrayan/spector/ingestion/package-info.java b/spector-ingestion/src/main/java/com/spectrayan/spector/ingestion/package-info.java
deleted file mode 100644
index c68b7dc..0000000
--- a/spector-ingestion/src/main/java/com/spectrayan/spector/ingestion/package-info.java
+++ /dev/null
@@ -1,30 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-/**
- * Document ingestion pipeline for Spector.
- *
- * <p>Orchestrates the flow: document → chunk → embed → store → index.
- * Uses virtual threads and structured concurrency for parallel embedding
- * without introducing reactive complexity.</p>
- *
- * <h3>Key Classes</h3>
- * <ul>
- *   <li>{@link com.spectrayan.spector.ingestion.IngestionPipeline} — main pipeline orchestrator</li>
- *   <li>{@link com.spectrayan.spector.ingestion.IngestionTarget} — abstraction for index + store operations</li>
- *   <li>{@link com.spectrayan.spector.ingestion.IngestionResult} — outcome of an ingestion operation</li>
- * </ul>
- */
-package com.spectrayan.spector.ingestion;
diff --git a/spector-mcp/README.md b/spector-mcp/README.md
deleted file mode 100644
index c3a2ff0..0000000
--- a/spector-mcp/README.md
+++ /dev/null
@@ -1,217 +0,0 @@
-# ⚡ Spector MCP Server
-
-**Agent-native search and cognitive memory integration for the Spector AI Memory Backbone.**
-
-Give any AI agent (Claude Desktop, Cursor, autonomous agents) instant access to Spector's SIMD-accelerated vector search engine and cognitive memory — with zero network overhead. The MCP server runs in-process via `SpectorRuntime`, calling the engine and memory directly on virtual threads for **88µs p50** query latency.
-
-## Architecture
-
-```
-AI Agent ──JSON-RPC (stdio)──► SpectorMcpServer (thin orchestrator)
-                                ├── SpectorRuntime
-                                │   ├── SpectorEngine (search, ingest, RAG)
-                                │   └── SpectorMemory (cognitive — optional)
-                                ├── SpectorToolRegistry
-                                │   ├── SemanticSearchTool  ──► engine.search()
-                                │   ├── HybridSearchTool    ──► engine.keywordSearch()
-                                │   ├── RagQueryTool        ──► engine.search() + formatting
-                                │   ├── IngestDocumentTool  ──► engine.ingest()
-                                │   ├── DeleteDocumentTool  ──► engine.delete()
-                                │   ├── EngineStatusTool    ──► engine metadata
-                                │   ├── CoreMemoryAppendTool    ──► memory.remember()
-                                │   ├── RecallContextTool       ──► memory.recall()
-                                │   ├── MemoryStatusTool        ──► memory.introspect()
-                                │   ├── MemoryReinforceTool     ──► memory.reinforce()
-                                │   ├── MemoryForgetTool        ──► memory.forget()
-                                │   ├── MemoryIntrospectTool    ──► memory.introspect()
-                                │   └── WorkingMemoryScratchpadTool ──► memory.remember()
-                                ├── SpectorResourceProvider
-                                └── SpectorPromptProvider
-
-Total overhead: 88µs p50 per query (23–113× faster than Python MCP servers)
-```
-
-### Module Structure
-
-```
-spector-mcp/src/main/java/com/spectrayan/spector/mcp/
-├── SpectorMcpServer.java          ← Thin orchestrator (accepts SpectorRuntime)
-├── SpectorMcpMain.java            ← CLI entry point
-├── schema/
-│   └── ToolSchemaBuilder.java     ← Type-safe fluent builder for JSON schemas
-├── tools/
-│   ├── McpToolHandler.java        ← Abstract base with timing, error handling
-│   ├── SpectorToolRegistry.java   ← Tool discovery & registration
-│   ├── SemanticSearchTool.java
-│   ├── HybridSearchTool.java
-│   ├── RagQueryTool.java
-│   ├── IngestDocumentTool.java
-│   ├── DeleteDocumentTool.java
-│   ├── EngineStatusTool.java
-│   ├── CoreMemoryAppendTool.java
-│   ├── RecallContextTool.java
-│   ├── MemoryStatusTool.java
-│   ├── MemoryReinforceTool.java
-│   ├── MemoryForgetTool.java
-│   ├── MemoryIntrospectTool.java
-│   └── WorkingMemoryScratchpadTool.java
-├── resources/
-│   └── SpectorResourceProvider.java
-├── prompts/
-│   └── SpectorPromptProvider.java
-└── util/
-    └── ResultFormatter.java
-```
-
-## MCP Tools
-
-### Search Tools (always available)
-
-| Tool | Description |
-|:---|:---|
-| `semantic_search` | Semantic similarity search with auto-embedding |
-| `hybrid_search` | Combined keyword (BM25) + vector search with RRF |
-| `rag_query` | Retrieval-Augmented Generation with source citations |
-| `ingest_document` | Document ingestion with auto-embedding + chunking |
-| `delete_document` | Document deletion by ID |
-| `engine_status` | Engine metadata, SIMD capabilities, GPU status |
-
-### Cognitive Memory Tools (enabled via `spector.memory.enabled: true`)
-
-| Tool | Description |
-|:---|:---|
-| `core_memory_append` | Store a semantic memory with tags and source |
-| `recall_context` | Cognitive recall with fused scoring across tiers |
-| `memory_status` | Memory tier counts and persistence info |
-| `memory_reinforce` | Report positive/negative outcome for a memory |
-| `memory_forget` | Tombstone a memory by ID |
-| `memory_introspect` | Metamemory self-analysis on a topic |
-| `working_memory_scratchpad` | Quick-write to working memory |
-
-## Quick Start
-
-### 1. Build
-
-```bash
-mvn package -pl spector-dist -am -DskipTests
-```
-
-### 2. Configuration
-
-Create a `spector.yml` with your settings:
-
-```yaml
-spector:
-  engine:
-    dimensions: 768
-    persistence-mode: DISK
-    data-directory: .spector/index
-  embedding:
-    model: nomic-embed-text
-    base-url: http://localhost:11434
-  memory:
-    enabled: true                # Enable cognitive memory tools
-    persistence-path: .spector-memory
-```
-
-### 3. Claude Desktop Configuration
-
-Add to your `claude_desktop_config.json`:
-
-```json
-{
-  "mcpServers": {
-    "spector": {
-      "command": "java",
-      "args": [
-        "--add-modules", "jdk.incubator.vector",
-        "--enable-native-access=ALL-UNNAMED",
-        "--enable-preview",
-        "-jar", "/path/to/spector-dist/target/spector.jar",
-        "--config", "/path/to/spector.yml"
-      ]
-    }
-  }
-}
-```
-
-### 4. CLI Options
-
-```
---config <FILE>        Explicit config file (YAML or .properties)
---profile <NAME>       Configuration profile (loads spector-{profile}.yml)
---dims <N>             Vector dimensionality (default: 384)
---capacity <N>         Max document capacity (default: 100000)
---data-dir <DIR>       Persistence directory (auto-enables DISK mode)
---ollama-url <URL>     Ollama embedding server URL
---ollama-model <NAME>  Ollama embedding model name
---help, -h             Show help
-```
-
-> **Recommended:** Use a `spector.yml` config file. CLI flags override config file values.
-
-## Why Spector MCP is Different
-
-| Feature | Python Vector DB MCP | **Spector MCP** |
-|:---|:---|:---|
-| Search latency | 2–10ms (network + Python GIL) | **88µs p50** (in-process SIMD) |
-| Network overhead | HTTP/gRPC round-trip | **Zero** (direct method call) |
-| GC pauses | Python/JVM heap pressure | **≤0.01%** (100% off-heap Panama) |
-| Concurrent queries | Limited by Python GIL | **61,000 QPS** (Virtual Threads) |
-| Dependencies | Python framework stack | **Single JAR** (zero Python) |
-| Cognitive memory | External service (Mem0, Zep) | **Built-in** (opt-in via config) |
-
-## Design Patterns
-
-### Adding a New Tool
-
-To add a new MCP tool, create a class extending `McpToolHandler` and register it:
-
-```java
-// 1. Create the tool (one focused class)
-public final class MyTool extends McpToolHandler {
-    @Override public String name() { return "my_tool"; }
-    @Override public String description() { return "Does something useful."; }
-    @Override public Map<String, Object> inputSchema() {
-        return ToolSchemaBuilder.object()
-                .requiredString("input", "The input.")
-                .optionalInt("count", "How many.", 5)
-                .build();
-    }
-    @Override public CallToolResult execute(SpectorEngine engine, Map<String, Object> args) {
-        String input = requireString(args, "input");
-        int count = optionalInt(args, "count", 5);
-        return textResult("Result: " + input);
-    }
-}
-
-// 2. Register in SpectorToolRegistry.handlers() — one line:
-List.of(
-    new SemanticSearchTool(),
-    // ... existing tools ...
-    new MyTool()  // ← add here
-);
-```
-
-### Key Design Decisions
-
-- **Template Method** (`McpToolHandler`) — timing, error handling, and arg parsing in the base class
-- **Builder Pattern** (`ToolSchemaBuilder`) — type-safe JSON schema, no nested `Map.of()`
-- **Open/Closed Principle** (`SpectorToolRegistry`) — add a tool = 1 class + 1 line
-- **Zero runtime overhead** — schemas built once, reused forever
-
-## Protocol Support
-
-- **Transport:** Stdio (JSON-RPC 2.0 over stdin/stdout)
-- **MCP SDK:** Official Anthropic Java SDK (`io.modelcontextprotocol.sdk:mcp`)
-- **Capabilities:** Tools, Resources, Prompts
-- **Java Version:** 25+ (Virtual Threads, Vector API, Panama FFM)
-
-## Test Suite
-
-```
-Tests run: 15, Failures: 0, Errors: 0, Skipped: 0
-BUILD SUCCESS
-```
-
-Covers: tool registry, all tool handlers, schema builder, argument validation.
diff --git a/spector-mcp/pom.xml b/spector-mcp/pom.xml
deleted file mode 100644
index 3fdc25b..0000000
--- a/spector-mcp/pom.xml
+++ /dev/null
@@ -1,66 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0"
-         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
-    <modelVersion>4.0.0</modelVersion>
-
-    <parent>
-        <groupId>com.spectrayan</groupId>
-        <artifactId>spector</artifactId>
-        <version>0.1.0-SNAPSHOT</version>
-    </parent>
-
-    <artifactId>spector-mcp</artifactId>
-    <name>Spector MCP Server</name>
-    <description>High-performance Model Context Protocol (MCP) server for Spector.
-        Provides AI agents (Claude Desktop, Cursor, etc.) direct in-process access to
-        Spector's SIMD-accelerated vector search engine via JSON-RPC over stdio or HTTP.
-        Uses the official Anthropic MCP Java SDK for protocol compliance.</description>
-
-    <dependencies>
-
-        <dependency>
-            <groupId>com.spectrayan</groupId>
-            <artifactId>spector-config</artifactId>
-        </dependency>
-        <!-- ── Spector Runtime (engine + memory + config) ── -->
-        <dependency>
-            <groupId>com.spectrayan</groupId>
-            <artifactId>spector-runtime</artifactId>
-        </dependency>
-
-        <!-- ── Ingestion (EmbeddingProviderFactory) ── -->
-        <dependency>
-            <groupId>com.spectrayan</groupId>
-            <artifactId>spector-ingestion</artifactId>
-        </dependency>
-
-        <!-- ── Ollama Embedding Provider (runtime — loaded via reflection by SpectorMcpMain) ── -->
-        <dependency>
-            <groupId>com.spectrayan</groupId>
-            <artifactId>spector-embed-ollama</artifactId>
-            <scope>runtime</scope>
-        </dependency>
-
-        <!-- ── Official Anthropic MCP Java SDK ── -->
-        <dependency>
-            <groupId>io.modelcontextprotocol.sdk</groupId>
-            <artifactId>mcp</artifactId>
-            <version>${mcp-sdk.version}</version>
-        </dependency>
-
-        <!-- ── JSON serialization (JSON-RPC 2.0 message handling) ── -->
-        <dependency>
-            <groupId>tools.jackson.core</groupId>
-            <artifactId>jackson-databind</artifactId>
-        </dependency>
-
-        <!-- ── Logging runtime ── -->
-        <dependency>
-            <groupId>ch.qos.logback</groupId>
-            <artifactId>logback-classic</artifactId>
-            <scope>runtime</scope>
-        </dependency>
-    </dependencies>
-
-</project>
diff --git a/spector-mcp/src/main/java/com/spectrayan/spector/mcp/SpectorMcpMain.java b/spector-mcp/src/main/java/com/spectrayan/spector/mcp/SpectorMcpMain.java
deleted file mode 100644
index 6bd9372..0000000
--- a/spector-mcp/src/main/java/com/spectrayan/spector/mcp/SpectorMcpMain.java
+++ /dev/null
@@ -1,191 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.mcp;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import com.spectrayan.spector.config.SpectorProperties;
-import com.spectrayan.spector.config.SpectorConfigFactory;
-import com.spectrayan.spector.embed.EmbeddingProvider;
-import com.spectrayan.spector.ingestion.EmbeddingProviderFactory;
-import com.spectrayan.spector.runtime.SpectorRuntime;
-
-/**
- * CLI entry point for the Spector MCP Server.
- *
- * <p>Starts an MCP server on stdio transport, allowing AI agents
- * (Claude Desktop, Cursor, etc.) to connect via JSON-RPC 2.0.</p>
- *
- * <h3>Configuration Hierarchy (highest priority wins)</h3>
- * <ol>
- *   <li>CLI arguments ({@code --dims 768})</li>
- *   <li>System properties ({@code -Dspector.engine.dimensions=768})</li>
- *   <li>Environment variables ({@code SPECTOR_ENGINE_DIMENSIONS=768})</li>
- *   <li>Profile config file ({@code spector-{profile}.yml})</li>
- *   <li>User config file ({@code spector.yml} in working directory)</li>
- *   <li>{@code --config /path/to/config.yml} (explicit file)</li>
- *   <li>Classpath defaults ({@code spector-defaults.yml} in JAR)</li>
- * </ol>
- *
- * <h3>Usage</h3>
- * <pre>
- *   # With config file (all settings from YAML)
- *   java --add-modules jdk.incubator.vector -jar spector-mcp.jar --config spector.yml
- *
- *   # CLI overrides on top of config file
- *   java --add-modules jdk.incubator.vector -jar spector-mcp.jar --dims 768 --ollama-model qwen3-embedding
- *
- *   # Minimal (all defaults from spector-defaults.yml)
- *   java --add-modules jdk.incubator.vector -jar spector-mcp.jar
- * </pre>
- */
-public class SpectorMcpMain {
-
-    private static final Logger log = LoggerFactory.getLogger(SpectorMcpMain.class);
-
-    public static void main(String[] args) {
-        // ── Handle --help ──
-        if (hasFlag(args, "--help") || hasFlag(args, "-h")) {
-            printHelp();
-            return;
-        }
-
-        // ── Load hierarchical configuration ──
-        SpectorProperties.Builder propsBuilder = SpectorProperties.builder();
-
-        // Explicit config file
-        String configFile = getStringArg(args, "--config", null);
-        if (configFile != null) {
-            propsBuilder.configFile(java.nio.file.Path.of(configFile));
-        }
-
-        // Profile
-        String profile = getStringArg(args, "--profile", null);
-        if (profile != null) {
-            propsBuilder.profile(profile);
-        }
-
-        // CLI args as overrides (highest priority after system props / env vars)
-        String cliDims = getStringArg(args, "--dims", null);
-        if (cliDims != null) propsBuilder.override("spector.engine.dimensions", cliDims);
-
-        String cliCapacity = getStringArg(args, "--capacity", null);
-        if (cliCapacity != null) propsBuilder.override("spector.engine.capacity", cliCapacity);
-
-        String cliOllamaUrl = getStringArg(args, "--ollama-url", null);
-        if (cliOllamaUrl != null) propsBuilder.override("spector.embedding.base-url", cliOllamaUrl);
-
-        String cliOllamaModel = getStringArg(args, "--ollama-model", null);
-        if (cliOllamaModel != null) propsBuilder.override("spector.embedding.model", cliOllamaModel);
-
-        String cliDataDir = getStringArg(args, "--data-dir", null);
-        if (cliDataDir != null) {
-            propsBuilder.override("spector.engine.data-directory", cliDataDir);
-            propsBuilder.override("spector.engine.persistence-mode", "DISK");
-        }
-
-        SpectorProperties props = propsBuilder.build();
-
-        // ── Create embedding provider ──
-        var embedDefaults = SpectorConfigFactory.embeddingDefaults(props);
-        EmbeddingProvider embedder = EmbeddingProviderFactory.create(
-                embedDefaults.baseUrl(), embedDefaults.model());
-        log.info("[Spector MCP] Embedding: {} @ {}", embedDefaults.model(), embedDefaults.baseUrl());
-
-        // ── Create runtime (engine + optional memory) ──
-        SpectorRuntime runtime = SpectorRuntime.from(props, embedder);
-
-        // ── Start the MCP server ──
-        SpectorMcpServer server = new SpectorMcpServer(runtime);
-
-        // Graceful shutdown hook
-        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
-            server.stop();
-            runtime.close();
-            log.info("[Spector MCP] Shutdown complete");
-        }));
-
-        server.start();
-    }
-
-
-
-    // ─────────────── CLI Parsing Helpers ───────────────
-
-    private static String getStringArg(String[] args, String name, String defaultValue) {
-        for (int i = 0; i < args.length - 1; i++) {
-            if (name.equals(args[i])) {
-                return args[i + 1];
-            }
-        }
-        return defaultValue;
-    }
-
-    private static int getIntArg(String[] args, String name, int defaultValue) {
-        String val = getStringArg(args, name, null);
-        if (val == null) return defaultValue;
-        try {
-            return Integer.parseInt(val);
-        } catch (NumberFormatException e) {
-            return defaultValue;
-        }
-    }
-
-    private static boolean hasFlag(String[] args, String flag) {
-        for (String arg : args) {
-            if (flag.equals(arg)) return true;
-        }
-        return false;
-    }
-
-    private static void printHelp() {
-        System.err.println("""
-                ⚡ Spector MCP Server — AI-Native Memory Backbone
-                
-                Usage:
-                  java --add-modules jdk.incubator.vector -jar spector-mcp.jar [options]
-                
-                Configuration:
-                  --config <FILE>        Explicit config file (YAML or .properties)
-                  --profile <NAME>       Active profile (loads spector-{profile}.yml)
-                
-                Override Options (highest priority):
-                  --dims <N>             Vector dimensionality
-                  --capacity <N>         Max document capacity
-                  --data-dir <PATH>      Data directory (enables DISK persistence)
-                  --ollama-url <URL>     Ollama server URL
-                  --ollama-model <NAME>  Ollama embedding model
-                  --help, -h             Show this help message
-                
-                Config Hierarchy (highest priority wins):
-                  1. CLI arguments (--dims, --capacity, etc.)
-                  2. System properties (-Dspector.engine.dimensions=768)
-                  3. Environment variables (SPECTOR_ENGINE_DIMENSIONS=768)
-                  4. spector-{profile}.yml (profile-specific)
-                  5. spector.yml (working directory)
-                  6. spector-defaults.yml (bundled in JAR)
-                
-                MCP Tools:
-                  semantic_search     Semantic similarity search with auto-embedding
-                  hybrid_search       Keyword (BM25) + vector hybrid search
-                  rag_query           Retrieval-Augmented Generation with citations
-                  ingest_document     Document ingestion with auto-embedding
-                  delete_document     Document deletion by ID
-                  engine_status       Engine status and capabilities
-                """);
-    }
-}
diff --git a/spector-mcp/src/main/java/com/spectrayan/spector/mcp/SpectorMcpServer.java b/spector-mcp/src/main/java/com/spectrayan/spector/mcp/SpectorMcpServer.java
deleted file mode 100644
index 29381d6..0000000
--- a/spector-mcp/src/main/java/com/spectrayan/spector/mcp/SpectorMcpServer.java
+++ /dev/null
@@ -1,147 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.mcp;
-
-import java.util.List;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import com.spectrayan.spector.core.simd.SimdCapability;
-import com.spectrayan.spector.engine.SpectorEngine;
-import com.spectrayan.spector.memory.SpectorMemory;
-import com.spectrayan.spector.runtime.SpectorRuntime;
-import com.spectrayan.spector.mcp.prompts.SpectorPromptProvider;
-import com.spectrayan.spector.mcp.resources.SpectorResourceProvider;
-import com.spectrayan.spector.mcp.tools.SpectorToolRegistry;
-
-import io.modelcontextprotocol.json.McpJsonMapper;
-import io.modelcontextprotocol.json.jackson3.JacksonMcpJsonMapper;
-
-import io.modelcontextprotocol.server.McpServer;
-import io.modelcontextprotocol.server.McpServerFeatures;
-import io.modelcontextprotocol.server.McpSyncServer;
-import io.modelcontextprotocol.server.transport.StdioServerTransportProvider;
-import io.modelcontextprotocol.spec.McpSchema;
-
-/**
- * High-performance MCP Server for Spector.
- *
- * <p>Thin orchestrator that assembles tool, resource, and prompt providers
- * into an MCP server. All search operations run in-process with zero
- * network overhead — tool handlers call {@link SpectorEngine} directly.</p>
- *
- * <h3>Responsibilities</h3>
- * <ul>
- *   <li>Transport setup (stdio via JSON-RPC)</li>
- *   <li>Capability declaration</li>
- *   <li>Provider assembly — delegates to:
- *     <ul>
- *       <li>{@link SpectorToolRegistry} — tool discovery and registration</li>
- *       <li>{@link SpectorResourceProvider} — resource definitions</li>
- *       <li>{@link SpectorPromptProvider} — prompt templates</li>
- *     </ul>
- *   </li>
- *   <li>Lifecycle management (start/stop)</li>
- * </ul>
- *
- * @see SpectorMcpMain
- * @see SpectorToolRegistry
- */
-public class SpectorMcpServer {
-
-    private static final Logger log = LoggerFactory.getLogger(SpectorMcpServer.class);
-
-    static final String SERVER_NAME = "spector-mcp";
-    static final String SERVER_VERSION = "0.1.0";
-
-    private final SpectorRuntime runtime;
-    private final SpectorEngine engine;
-    private final SpectorMemory memory; // nullable
-    private volatile McpSyncServer mcpServer;
-
-    /**
-     * Creates an MCP server backed by the given runtime.
-     *
-     * @param runtime the Spector runtime (engine + optional memory)
-     */
-    public SpectorMcpServer(SpectorRuntime runtime) {
-        this.runtime = runtime;
-        this.engine = runtime.engine();
-        this.memory = runtime.memory();
-    }
-
-    /**
-     * Starts the MCP server on stdio transport.
-     *
-     * <p>This method blocks indefinitely, reading JSON-RPC messages from stdin
-     * and writing responses to stdout. All logging is directed to stderr to
-     * prevent corruption of the JSON-RPC stream.</p>
-     */
-    public void start() {
-        log.info("[Spector MCP] Starting server: {}, dims={}, indexType={}, embedding={}, {}",
-                SERVER_NAME,
-                engine.config().dimensions(),
-                engine.config().indexType(),
-                engine.hasEmbeddingProvider() ? "configured" : "none",
-                SimdCapability.report());
-
-        // ── Assemble providers (runtime-aware for mode routing) ──
-        var toolSpecs  = SpectorToolRegistry.createAll(runtime, SERVER_VERSION);
-        var resources  = SpectorResourceProvider.create(engine, SERVER_VERSION);
-        var prompts    = SpectorPromptProvider.create(engine);
-
-        // ── Configure transport ──
-        McpJsonMapper jsonMapper = new JacksonMcpJsonMapper(
-                tools.jackson.databind.json.JsonMapper.builder().build());
-        var transportProvider = new StdioServerTransportProvider(jsonMapper);
-
-        // ── Build the MCP server ──
-        mcpServer = McpServer.sync(transportProvider)
-                .serverInfo(SERVER_NAME, SERVER_VERSION)
-                .capabilities(McpSchema.ServerCapabilities.builder()
-                        .tools(true)
-                        .resources(false, false)
-                        .prompts(false)
-                        .build())
-                .tools(toolSpecs)
-                .resources(resources)
-                .prompts(prompts)
-                .build();
-
-        log.info("[Spector MCP] Server initialized with {} tools, {} resources, {} prompts",
-                toolSpecs.size(), resources.size(), prompts.size());
-
-        // The SDK handles the stdio read loop internally.
-        // Block the main thread to keep the server alive.
-        try {
-            Thread.currentThread().join();
-        } catch (InterruptedException e) {
-            log.info("[Spector MCP] Server interrupted, shutting down");
-            Thread.currentThread().interrupt();
-        }
-    }
-
-    /**
-     * Stops the MCP server and releases resources.
-     */
-    public void stop() {
-        if (mcpServer != null) {
-            mcpServer.close();
-            log.info("[Spector MCP] Server stopped");
-        }
-    }
-}
diff --git a/spector-mcp/src/main/java/com/spectrayan/spector/mcp/package-info.java b/spector-mcp/src/main/java/com/spectrayan/spector/mcp/package-info.java
deleted file mode 100644
index f1692b7..0000000
--- a/spector-mcp/src/main/java/com/spectrayan/spector/mcp/package-info.java
+++ /dev/null
@@ -1,25 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-/**
- * Spector MCP — Model Context Protocol integration for Spector.
- *
- * <p>This package provides a high-performance MCP server that exposes
- * Spector's SIMD-accelerated vector search engine to AI agents
- * (Claude Desktop, Cursor, autonomous agents) via JSON-RPC 2.0.</p>
- *
- * <p>Uses the official Anthropic MCP Java SDK for protocol compliance.</p>
- */
-package com.spectrayan.spector.mcp;
diff --git a/spector-mcp/src/main/java/com/spectrayan/spector/mcp/prompts/SpectorPromptProvider.java b/spector-mcp/src/main/java/com/spectrayan/spector/mcp/prompts/SpectorPromptProvider.java
deleted file mode 100644
index be3de28..0000000
--- a/spector-mcp/src/main/java/com/spectrayan/spector/mcp/prompts/SpectorPromptProvider.java
+++ /dev/null
@@ -1,138 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.mcp.prompts;
-
-import java.util.List;
-import java.util.Map;
-
-import com.spectrayan.spector.engine.SpectorEngine;
-import com.spectrayan.spector.mcp.util.ResultFormatter;
-import com.spectrayan.spector.query.SearchResponse;
-
-import io.modelcontextprotocol.server.McpServerFeatures;
-import io.modelcontextprotocol.spec.McpSchema;
-
-/**
- * Factory for Spector MCP prompt specifications.
- *
- * <p>Prompts are reusable message templates that MCP clients can invoke
- * to get pre-formatted context for AI model interactions. Currently
- * provides:</p>
- * <ul>
- *   <li>{@code rag_with_citations} — RAG prompt with retrieved context and citation instructions</li>
- * </ul>
- */
-public final class SpectorPromptProvider {
-
-    /** System instruction template for RAG prompts. */
-    private static final String RAG_SYSTEM_INSTRUCTION =
-            "You are a helpful assistant. Use the following context "
-            + "retrieved from the Spector knowledge base to answer the user's "
-            + "question. Always cite your sources using the document IDs provided. "
-            + "If the context does not contain relevant information, say so.";
-
-    /** Fallback message when no embedding provider is configured. */
-    private static final String NO_EMBEDDING_PROVIDER_MSG =
-            "[No embedding provider configured — cannot perform semantic search]";
-
-    private SpectorPromptProvider() {} // static factory
-
-    /**
-     * Creates all prompt specifications for MCP server registration.
-     *
-     * @param engine the Spector engine instance
-     * @return list of prompt specifications
-     */
-    public static List<McpServerFeatures.SyncPromptSpecification> create(SpectorEngine engine) {
-        return List.of(
-                createRagPrompt(engine)
-        );
-    }
-
-    // ─────────────── RAG Prompt ───────────────
-
-    private static McpServerFeatures.SyncPromptSpecification createRagPrompt(SpectorEngine engine) {
-        var prompt = new McpSchema.Prompt(
-                "rag_with_citations",
-                "RAG prompt template that retrieves relevant context from the Spector index "
-                        + "and formats results with source citations for grounded responses.",
-                List.of(
-                        new McpSchema.PromptArgument("query",
-                                "The question or topic to search for", true),
-                        new McpSchema.PromptArgument("top_k",
-                                "Number of context chunks to retrieve (default: 5)", false),
-                        new McpSchema.PromptArgument("token_limit",
-                                "Maximum context tokens (default: 4096)", false)
-                )
-        );
-
-        return new McpServerFeatures.SyncPromptSpecification(prompt, (exchange, request) -> {
-            String query = extractStringArg(request.arguments(), "query", "");
-            int topK = extractIntArg(request.arguments(), "top_k", 5);
-
-            String contextText = retrieveContext(engine, query, topK);
-
-            String message = RAG_SYSTEM_INSTRUCTION + "\n\n"
-                    + "--- RETRIEVED CONTEXT ---\n" + contextText + "\n--- END CONTEXT ---"
-                    + "\n\nQuestion: " + query;
-
-            return new McpSchema.GetPromptResult(
-                    "RAG query with citations from Spector",
-                    List.of(new McpSchema.PromptMessage(
-                            McpSchema.Role.USER,
-                            new McpSchema.TextContent(message)
-                    ))
-            );
-        });
-    }
-
-    // ─────────────── Internal Helpers ───────────────
-
-    /**
-     * Retrieves search context for the RAG prompt, handling errors gracefully.
-     */
-    private static String retrieveContext(SpectorEngine engine, String query, int topK) {
-        try {
-            if (engine.hasEmbeddingProvider()) {
-                SearchResponse response = engine.search(query, topK);
-                return ResultFormatter.formatSearchResults(response, engine);
-            } else {
-                return NO_EMBEDDING_PROVIDER_MSG;
-            }
-        } catch (Exception e) {
-            return "[Search failed: " + e.getMessage() + "]";
-        }
-    }
-
-    private static String extractStringArg(Map<String, Object> args, String key,
-                                            String defaultValue) {
-        if (args == null) return defaultValue;
-        Object val = args.get(key);
-        return val != null ? val.toString() : defaultValue;
-    }
-
-    private static int extractIntArg(Map<String, Object> args, String key, int defaultValue) {
-        if (args == null) return defaultValue;
-        Object val = args.get(key);
-        if (val == null) return defaultValue;
-        if (val instanceof Number n) return n.intValue();
-        try {
-            return Integer.parseInt(val.toString());
-        } catch (NumberFormatException e) {
-            return defaultValue;
-        }
-    }
-}
diff --git a/spector-mcp/src/main/java/com/spectrayan/spector/mcp/resources/SpectorResourceProvider.java b/spector-mcp/src/main/java/com/spectrayan/spector/mcp/resources/SpectorResourceProvider.java
deleted file mode 100644
index b4696eb..0000000
--- a/spector-mcp/src/main/java/com/spectrayan/spector/mcp/resources/SpectorResourceProvider.java
+++ /dev/null
@@ -1,108 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.mcp.resources;
-
-import java.util.List;
-
-import com.spectrayan.spector.engine.SpectorEngine;
-import com.spectrayan.spector.mcp.util.ResultFormatter;
-
-import io.modelcontextprotocol.server.McpServerFeatures;
-import io.modelcontextprotocol.spec.McpSchema;
-
-/**
- * Factory for Spector MCP resource specifications.
- *
- * <p>Resources expose read-only data to MCP clients. Currently provides:</p>
- * <ul>
- *   <li>{@code spector://status} — real-time engine status as JSON</li>
- * </ul>
- *
- * <p>Resources are defined separately from the server orchestrator
- * for clean separation of concerns and independent extensibility.</p>
- */
-public final class SpectorResourceProvider {
-
-    /** URI scheme for Spector resources. */
-    private static final String SCHEME = "spector://";
-
-    private SpectorResourceProvider() {} // static factory
-
-    /**
-     * Creates all resource specifications for MCP server registration.
-     *
-     * @param engine        the Spector engine instance
-     * @param serverVersion the server version string
-     * @return list of resource specifications
-     */
-    public static List<McpServerFeatures.SyncResourceSpecification> create(
-            SpectorEngine engine, String serverVersion) {
-        return List.of(
-                createStatusResource(engine, serverVersion)
-        );
-    }
-
-    // ─────────────── Status Resource ───────────────
-
-    private static McpServerFeatures.SyncResourceSpecification createStatusResource(
-            SpectorEngine engine, String serverVersion) {
-
-        var resource = McpSchema.Resource.builder(SCHEME + "status", "Engine Status")
-                .description("Real-time Spector engine status including document count, "
-                        + "index type, SIMD capabilities, GPU status, and embedding configuration.")
-                .mimeType("application/json")
-                .build();
-
-        return new McpServerFeatures.SyncResourceSpecification(resource, (exchange, request) -> {
-            // Build status as a structured map, then serialize to JSON
-            var statusMap = ResultFormatter.buildEngineStatusMap(engine, serverVersion);
-            String json = mapToJson(statusMap);
-
-            return new McpSchema.ReadResourceResult(
-                    List.of(new McpSchema.TextResourceContents(
-                            request.uri(), "application/json", json))
-            );
-        });
-    }
-
-    // ─────────────── Internal ───────────────
-
-    /**
-     * Simple JSON serialization for flat maps — avoids adding Jackson
-     * as a direct dependency for the resource provider.
-     *
-     * <p>For nested or complex structures, inject an ObjectMapper instead.</p>
-     */
-    private static String mapToJson(java.util.Map<String, Object> map) {
-        var sb = new StringBuilder(256);
-        sb.append("{\n");
-        var entries = map.entrySet().iterator();
-        while (entries.hasNext()) {
-            var entry = entries.next();
-            sb.append("  \"").append(entry.getKey()).append("\": ");
-            Object val = entry.getValue();
-            if (val instanceof Number) {
-                sb.append(val);
-            } else {
-                sb.append('"').append(val).append('"');
-            }
-            if (entries.hasNext()) sb.append(',');
-            sb.append('\n');
-        }
-        sb.append('}');
-        return sb.toString();
-    }
-}
diff --git a/spector-mcp/src/main/java/com/spectrayan/spector/mcp/schema/ToolSchemaBuilder.java b/spector-mcp/src/main/java/com/spectrayan/spector/mcp/schema/ToolSchemaBuilder.java
deleted file mode 100644
index 57cb35d..0000000
--- a/spector-mcp/src/main/java/com/spectrayan/spector/mcp/schema/ToolSchemaBuilder.java
+++ /dev/null
@@ -1,192 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.mcp.schema;
-
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-
-/**
- * Type-safe fluent builder for MCP tool input schemas.
- *
- * <p>Replaces error-prone nested {@code Map.of()} literals with a
- * composable builder that generates the {@code Map<String, Object>}
- * structure expected by {@link io.modelcontextprotocol.spec.McpSchema.Tool}.</p>
- *
- * <h3>Usage</h3>
- * <pre>{@code
- *   Map<String, Object> schema = ToolSchemaBuilder.object()
- *       .requiredString("query", "Natural language search query.")
- *       .optionalInt("top_k", "Number of results to return.", 5)
- *       .optionalEnum("mode", "Search mode.", "hybrid", "hybrid", "keyword", "vector")
- *       .build();
- * }</pre>
- *
- * <p>The resulting map is structurally equivalent to a JSON Schema object
- * with the standard {@code type}, {@code properties}, and {@code required}
- * fields. Built maps are unmodifiable.</p>
- *
- * @see io.modelcontextprotocol.spec.McpSchema.Tool
- */
-public final class ToolSchemaBuilder {
-
-    private final LinkedHashMap<String, Map<String, Object>> properties = new LinkedHashMap<>();
-    private final List<String> required = new ArrayList<>();
-
-    private ToolSchemaBuilder() {}
-
-    /**
-     * Creates a new builder for an {@code "object"}-type JSON schema.
-     *
-     * @return a fresh builder instance
-     */
-    public static ToolSchemaBuilder object() {
-        return new ToolSchemaBuilder();
-    }
-
-    // ─────────────── Required Parameters ───────────────
-
-    /**
-     * Adds a required string parameter.
-     *
-     * @param name        parameter name (JSON key)
-     * @param description human-readable description for AI agents
-     * @return this builder for chaining
-     */
-    public ToolSchemaBuilder requiredString(String name, String description) {
-        properties.put(name, propertyOf("string", description));
-        required.add(name);
-        return this;
-    }
-
-    /**
-     * Adds a required integer parameter.
-     *
-     * @param name        parameter name
-     * @param description human-readable description
-     * @return this builder
-     */
-    public ToolSchemaBuilder requiredInt(String name, String description) {
-        properties.put(name, propertyOf("integer", description));
-        required.add(name);
-        return this;
-    }
-
-    // ─────────────── Optional Parameters ───────────────
-
-    /**
-     * Adds an optional string parameter with a default value.
-     *
-     * @param name         parameter name
-     * @param description  human-readable description
-     * @param defaultValue default value (may be {@code null})
-     * @return this builder
-     */
-    public ToolSchemaBuilder optionalString(String name, String description, String defaultValue) {
-        Map<String, Object> prop = propertyOf("string", description);
-        if (defaultValue != null) prop.put("default", defaultValue);
-        properties.put(name, prop);
-        return this;
-    }
-
-    /**
-     * Adds an optional integer parameter with a default value.
-     *
-     * @param name         parameter name
-     * @param description  human-readable description
-     * @param defaultValue default value
-     * @return this builder
-     */
-    public ToolSchemaBuilder optionalInt(String name, String description, int defaultValue) {
-        Map<String, Object> prop = propertyOf("integer", description);
-        prop.put("default", defaultValue);
-        properties.put(name, prop);
-        return this;
-    }
-
-    /**
-     * Adds an optional boolean parameter with a default value.
-     *
-     * @param name         parameter name
-     * @param description  human-readable description
-     * @param defaultValue default value
-     * @return this builder
-     */
-    public ToolSchemaBuilder optionalBoolean(String name, String description, boolean defaultValue) {
-        Map<String, Object> prop = propertyOf("boolean", description);
-        prop.put("default", defaultValue);
-        properties.put(name, prop);
-        return this;
-    }
-
-    /**
-     * Adds an optional enum (string) parameter with allowed values.
-     *
-     * @param name         parameter name
-     * @param description  human-readable description
-     * @param defaultValue default value
-     * @param values       allowed enum values
-     * @return this builder
-     */
-    public ToolSchemaBuilder optionalEnum(String name, String description,
-                                          String defaultValue, String... values) {
-        Map<String, Object> prop = propertyOf("string", description);
-        prop.put("enum", List.of(values));
-        prop.put("default", defaultValue);
-        properties.put(name, prop);
-        return this;
-    }
-
-    // ─────────────── Build ───────────────
-
-    /**
-     * Builds the final unmodifiable schema map.
-     *
-     * @return {@code Map<String, Object>} conforming to JSON Schema "object" type
-     */
-    public Map<String, Object> build() {
-        Map<String, Object> schema = new HashMap<>(4);
-        schema.put("type", "object");
-        schema.put("properties", Map.copyOf(properties));
-        if (!required.isEmpty()) {
-            schema.put("required", List.copyOf(required));
-        }
-        return Map.copyOf(schema);
-    }
-
-    // ─────────────── Empty Schema ───────────────
-
-    /**
-     * Convenience method for tools with no input parameters.
-     *
-     * @return an empty object schema
-     */
-    public static Map<String, Object> empty() {
-        return Map.of("type", "object", "properties", Map.of());
-    }
-
-    // ─────────────── Internal ───────────────
-
-    private static Map<String, Object> propertyOf(String type, String description) {
-        // Use HashMap so callers can add "default", "enum", etc.
-        Map<String, Object> prop = new HashMap<>(4);
-        prop.put("type", type);
-        prop.put("description", description);
-        return prop;
-    }
-}
diff --git a/spector-mcp/src/main/java/com/spectrayan/spector/mcp/tools/CoreMemoryAppendTool.java b/spector-mcp/src/main/java/com/spectrayan/spector/mcp/tools/CoreMemoryAppendTool.java
deleted file mode 100644
index ac90d5d..0000000
--- a/spector-mcp/src/main/java/com/spectrayan/spector/mcp/tools/CoreMemoryAppendTool.java
+++ /dev/null
@@ -1,81 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.mcp.tools;
-
-import java.util.Map;
-
-import com.spectrayan.spector.engine.SpectorEngine;
-import com.spectrayan.spector.memory.MemoryType;
-import com.spectrayan.spector.memory.SpectorMemory;
-import com.spectrayan.spector.memory.cortex.MemorySource;
-import com.spectrayan.spector.mcp.schema.ToolSchemaBuilder;
-
-import io.modelcontextprotocol.spec.McpSchema;
-
-/**
- * MCP tool: {@code core_memory_append} — stores a permanent semantic fact.
- *
- * <p>Maps to {@link SpectorMemory#remember} with {@link MemoryType#SEMANTIC}.</p>
- */
-public final class CoreMemoryAppendTool extends MemoryToolHandler {
-
-    public CoreMemoryAppendTool(SpectorMemory memory) {
-        super(memory);
-    }
-
-    @Override public String name() { return "core_memory_append"; }
-
-    @Override
-    public String description() {
-        return "Store a permanent fact in the agent's semantic memory. "
-                + "Use this to save key user preferences, important decisions, "
-                + "and factual knowledge that should persist across sessions. "
-                + "Tags help with contextual recall (e.g., 'preferences', 'architecture').";
-    }
-
-    @Override
-    public Map<String, Object> inputSchema() {
-        return ToolSchemaBuilder.object()
-                .requiredString("id", "Unique identifier for this memory (e.g., 'user-pref-dark-mode').")
-                .requiredString("text", "The fact or preference to remember.")
-                .optionalString("tags", "Comma-separated contextual tags for Bloom filter encoding.", "")
-                .optionalString("source",
-                        "Memory source: USER_STATED, OBSERVED, INFERRED, PROCEDURAL.", "OBSERVED")
-                .build();
-    }
-
-    @Override
-    protected McpSchema.CallToolResult executeMemory(SpectorMemory memory,
-                                                       SpectorEngine engine,
-                                                       Map<String, Object> args) throws Exception {
-        String id = requireString(args, "id");
-        String text = requireString(args, "text");
-        String[] tags = optionalTags(args, "tags");
-        String sourceName = optionalString(args, "source", "OBSERVED");
-
-        MemorySource source;
-        try {
-            source = MemorySource.valueOf(sourceName.toUpperCase());
-        } catch (IllegalArgumentException e) {
-            source = MemorySource.OBSERVED;
-        }
-
-        memory.remember(id, text, MemoryType.SEMANTIC, source, tags).join();
-
-        return textResult("✅ Stored semantic memory '" + id + "' with " + tags.length
-                + " tags (source=" + source + ").");
-    }
-}
diff --git a/spector-mcp/src/main/java/com/spectrayan/spector/mcp/tools/DeleteDocumentTool.java b/spector-mcp/src/main/java/com/spectrayan/spector/mcp/tools/DeleteDocumentTool.java
deleted file mode 100644
index 126df67..0000000
--- a/spector-mcp/src/main/java/com/spectrayan/spector/mcp/tools/DeleteDocumentTool.java
+++ /dev/null
@@ -1,68 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.mcp.tools;
-
-import java.util.Map;
-
-import com.spectrayan.spector.engine.SpectorEngine;
-import com.spectrayan.spector.mcp.schema.ToolSchemaBuilder;
-
-import io.modelcontextprotocol.spec.McpSchema;
-
-/**
- * Document deletion tool.
- *
- * <p>Removes a document from the keyword index and document store by ID.
- * Vector index entries become orphaned and are excluded from future
- * search results.</p>
- */
-public final class DeleteDocumentTool extends McpToolHandler {
-
-    @Override
-    public String name() {
-        return "delete_document";
-    }
-
-    @Override
-    public String description() {
-        return "Deletes a document from the Spector index by ID. Removes it from "
-                + "keyword index and document store. Vector index entries become orphaned "
-                + "and are excluded from future results.";
-    }
-
-    @Override
-    public Map<String, Object> inputSchema() {
-        return ToolSchemaBuilder.object()
-                .requiredString("id",
-                        "The document identifier to delete.")
-                .build();
-    }
-
-    @Override
-    public McpSchema.CallToolResult execute(SpectorEngine engine, Map<String, Object> args) {
-        String id = requireString(args, "id");
-
-        boolean deleted = engine.delete(id);
-        if (deleted) {
-            return textResult(String.format(
-                    "Document '%s' deleted. Remaining documents: %d",
-                    id, engine.documentCount()));
-        } else {
-            return textResult(String.format(
-                    "Document '%s' not found.", id));
-        }
-    }
-}
diff --git a/spector-mcp/src/main/java/com/spectrayan/spector/mcp/tools/EngineStatusTool.java b/spector-mcp/src/main/java/com/spectrayan/spector/mcp/tools/EngineStatusTool.java
deleted file mode 100644
index eea60aa..0000000
--- a/spector-mcp/src/main/java/com/spectrayan/spector/mcp/tools/EngineStatusTool.java
+++ /dev/null
@@ -1,63 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.mcp.tools;
-
-import java.util.Map;
-
-import com.spectrayan.spector.engine.SpectorEngine;
-import com.spectrayan.spector.mcp.schema.ToolSchemaBuilder;
-import com.spectrayan.spector.mcp.util.ResultFormatter;
-
-import io.modelcontextprotocol.spec.McpSchema;
-
-/**
- * Engine status and capabilities tool.
- *
- * <p>Returns a comprehensive status report including document count,
- * vector dimensionality, index type, SIMD capabilities, GPU status,
- * and embedding provider info.</p>
- */
-public final class EngineStatusTool extends McpToolHandler {
-
-    /** Server version — injected at construction to avoid hardcoding. */
-    private final String serverVersion;
-
-    public EngineStatusTool(String serverVersion) {
-        this.serverVersion = serverVersion;
-    }
-
-    @Override
-    public String name() {
-        return "engine_status";
-    }
-
-    @Override
-    public String description() {
-        return "Returns current Spector engine status including document count, vector "
-                + "dimensionality, index type (HNSW/IVF-PQ/SPECTRUM), SIMD capabilities, "
-                + "GPU acceleration status, and embedding provider info.";
-    }
-
-    @Override
-    public Map<String, Object> inputSchema() {
-        return ToolSchemaBuilder.empty();
-    }
-
-    @Override
-    public McpSchema.CallToolResult execute(SpectorEngine engine, Map<String, Object> args) {
-        return textResult(ResultFormatter.formatEngineStatus(engine, serverVersion));
-    }
-}
diff --git a/spector-mcp/src/main/java/com/spectrayan/spector/mcp/tools/HybridSearchTool.java b/spector-mcp/src/main/java/com/spectrayan/spector/mcp/tools/HybridSearchTool.java
deleted file mode 100644
index 1f16704..0000000
--- a/spector-mcp/src/main/java/com/spectrayan/spector/mcp/tools/HybridSearchTool.java
+++ /dev/null
@@ -1,100 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.mcp.tools;
-
-import java.util.Map;
-
-import com.spectrayan.spector.engine.SpectorEngine;
-import com.spectrayan.spector.mcp.schema.ToolSchemaBuilder;
-import com.spectrayan.spector.mcp.util.ResultFormatter;
-import com.spectrayan.spector.query.SearchResponse;
-
-import io.modelcontextprotocol.spec.McpSchema;
-
-/**
- * Combined keyword (BM25) + semantic (vector) search with mode selection.
- *
- * <p>Supports three modes:</p>
- * <ul>
- *   <li>{@code hybrid} — reciprocal rank fusion of BM25 + vector results (default)</li>
- *   <li>{@code keyword} — BM25 keyword matching only</li>
- *   <li>{@code vector} — semantic vector search only</li>
- * </ul>
- *
- * <p>Falls back to keyword-only if no embedding provider is configured
- * and {@code hybrid} mode is requested.</p>
- */
-public final class HybridSearchTool extends McpToolHandler {
-
-    @Override
-    public String name() {
-        return "hybrid_search";
-    }
-
-    @Override
-    public String description() {
-        return "Combined keyword (BM25) + semantic (vector) search with reciprocal rank fusion. "
-                + "Best for queries mixing specific terms with conceptual intent. "
-                + "Falls back to keyword-only if no embedding provider is configured.";
-    }
-
-    @Override
-    public Map<String, Object> inputSchema() {
-        return ToolSchemaBuilder.object()
-                .requiredString("query",
-                        "Search query for both keyword matching (BM25) and semantic similarity.")
-                .optionalInt("top_k",
-                        "Number of results to return (1-100).", 5)
-                .optionalEnum("mode",
-                        "Search mode. 'hybrid' combines keyword and vector.",
-                        "hybrid", "hybrid", "keyword", "vector")
-                .build();
-    }
-
-    @Override
-    public McpSchema.CallToolResult execute(SpectorEngine engine, Map<String, Object> args) {
-        String query = requireString(args, "query");
-        int topK = optionalInt(args, "top_k", 5);
-        String mode = optionalString(args, "mode", "hybrid");
-
-        long startNs = System.nanoTime();
-        SearchResponse response = dispatchSearch(engine, query, topK, mode);
-        long elapsedMs = (System.nanoTime() - startNs) / 1_000_000;
-
-        String text = ResultFormatter.formatSearchResults(response, engine);
-        return textResult(ResultFormatter.withTimingFooter(
-                text, "Hybrid search (" + mode + " mode)", elapsedMs));
-    }
-
-    private static SearchResponse dispatchSearch(SpectorEngine engine, String query,
-                                                  int topK, String mode) {
-        return switch (mode.toLowerCase()) {
-            case "keyword" -> engine.keywordSearch(query, topK);
-            case "vector" -> {
-                requireEmbeddingProvider(engine);
-                yield engine.search(query, topK);
-            }
-            default -> {
-                // hybrid: use vector if available, fallback to keyword
-                if (engine.hasEmbeddingProvider()) {
-                    yield engine.search(query, topK);
-                } else {
-                    yield engine.keywordSearch(query, topK);
-                }
-            }
-        };
-    }
-}
diff --git a/spector-mcp/src/main/java/com/spectrayan/spector/mcp/tools/IngestDocumentTool.java b/spector-mcp/src/main/java/com/spectrayan/spector/mcp/tools/IngestDocumentTool.java
deleted file mode 100644
index 509db53..0000000
--- a/spector-mcp/src/main/java/com/spectrayan/spector/mcp/tools/IngestDocumentTool.java
+++ /dev/null
@@ -1,89 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.mcp.tools;
-
-import java.util.Map;
-
-import com.spectrayan.spector.engine.SpectorEngine;
-import com.spectrayan.spector.mcp.schema.ToolSchemaBuilder;
-
-import io.modelcontextprotocol.spec.McpSchema;
-
-/**
- * Document ingestion tool with auto-embedding and optional chunking.
- *
- * <p>Ingests a document into the Spector index. The embedding provider
- * automatically generates vectors from the document content. For large
- * documents, enable {@code chunked} mode for automatic splitting.</p>
- */
-public final class IngestDocumentTool extends McpToolHandler {
-
-    @Override
-    public String name() {
-        return "ingest_document";
-    }
-
-    @Override
-    public String description() {
-        return "Ingest a document into the Spector index with automatic embedding generation. "
-                + "Supports chunked ingestion for large documents. "
-                + "Requires an embedding provider to be configured.";
-    }
-
-    @Override
-    public Map<String, Object> inputSchema() {
-        return ToolSchemaBuilder.object()
-                .requiredString("id",
-                        "Unique document identifier.")
-                .requiredString("content",
-                        "Document text content to ingest.")
-                .optionalString("title",
-                        "Optional document title.", null)
-                .optionalBoolean("chunked",
-                        "Enable automatic chunking for large documents.", false)
-                .build();
-    }
-
-    @Override
-    public McpSchema.CallToolResult execute(SpectorEngine engine, Map<String, Object> args) {
-        requireEmbeddingProvider(engine);
-        String id = requireString(args, "id");
-        String content = requireString(args, "content");
-        String title = optionalString(args, "title", null);
-        boolean chunked = optionalBoolean(args, "chunked", false);
-
-        long startNs = System.nanoTime();
-
-        if (chunked) {
-            int chunks = engine.ingestChunkedAuto(id, content);
-            long elapsedMs = (System.nanoTime() - startNs) / 1_000_000;
-            return textResult(String.format(
-                    "Document '%s' ingested as %d chunks in %dms.",
-                    id, chunks, elapsedMs));
-        }
-
-        if (title != null && !title.isBlank()) {
-            engine.ingest(id, title, content);
-        } else {
-            engine.ingest(id, content);
-        }
-
-        long elapsedMs = (System.nanoTime() - startNs) / 1_000_000;
-        return textResult(String.format(
-                "Document '%s' ingested successfully in %dms. Total documents: %d",
-                id, elapsedMs, engine.documentCount()));
-    }
-}
diff --git a/spector-mcp/src/main/java/com/spectrayan/spector/mcp/tools/McpToolHandler.java b/spector-mcp/src/main/java/com/spectrayan/spector/mcp/tools/McpToolHandler.java
deleted file mode 100644
index ce16dfe..0000000
--- a/spector-mcp/src/main/java/com/spectrayan/spector/mcp/tools/McpToolHandler.java
+++ /dev/null
@@ -1,265 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.mcp.tools;
-
-import java.util.List;
-import java.util.Map;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import com.spectrayan.spector.engine.SpectorEngine;
-import com.spectrayan.spector.runtime.SpectorRuntime;
-
-import io.modelcontextprotocol.server.McpServerFeatures;
-import io.modelcontextprotocol.spec.McpSchema;
-
-/**
- * Abstract base for all Spector MCP tool handlers.
- *
- * <p>Provides a structured contract for tool implementation with built-in
- * support for timing, error handling, argument parsing, and result
- * construction. Subclasses implement four methods:</p>
- *
- * <ul>
- *   <li>{@link #name()} — the MCP tool name (e.g., {@code "semantic_search"})</li>
- *   <li>{@link #description()} — human-readable description for AI agents</li>
- *   <li>{@link #inputSchema()} — JSON Schema map for tool parameters</li>
- *   <li>{@link #execute(SpectorEngine, Map)} — the actual tool logic</li>
- * </ul>
- *
- * <h3>What the base class provides</h3>
- * <ul>
- *   <li>Automatic nanosecond-precision timing of every invocation</li>
- *   <li>Structured exception handling with logging and error result wrapping</li>
- *   <li>Type-safe argument extraction ({@link #requireString}, {@link #optionalInt}, etc.)</li>
- *   <li>Factory methods for results ({@link #textResult}, {@link #errorResult})</li>
- *   <li>Embedding provider precondition check ({@link #requireEmbeddingProvider})</li>
- * </ul>
- *
- * <h3>Adding a new tool</h3>
- * <ol>
- *   <li>Create a class extending {@code McpToolHandler}</li>
- *   <li>Implement the four abstract methods</li>
- *   <li>Add one line to {@link SpectorToolRegistry}</li>
- * </ol>
- */
-public abstract class McpToolHandler {
-
-    private final Logger log = LoggerFactory.getLogger(getClass());
-
-    // ═══════════════════════════════════════════════════════════════
-    //  Contract — subclass must implement
-    // ═══════════════════════════════════════════════════════════════
-
-    /**
-     * The unique MCP tool name (e.g., {@code "semantic_search"}).
-     * Must be a valid JSON-RPC method identifier.
-     */
-    public abstract String name();
-
-    /**
-     * Human-readable description shown to AI agents for tool selection.
-     */
-    public abstract String description();
-
-    /**
-     * JSON Schema describing the tool's input parameters.
-     * Use {@link com.spectrayan.spector.mcp.schema.ToolSchemaBuilder} to construct.
-     *
-     * @return unmodifiable map conforming to JSON Schema "object" type
-     */
-    public abstract Map<String, Object> inputSchema();
-
-    /**
-     * Executes the tool logic against the engine.
-     *
-     * <p>This method is called inside the timing/error-handling wrapper
-     * provided by {@link #toToolSpecification}. Implementations should
-     * focus purely on business logic — no try/catch or timing needed.</p>
-     *
-     * @param engine the Spector engine instance
-     * @param args   the parsed arguments from the MCP request (never null)
-     * @return the tool result
-     * @throws ToolArgumentException if a required argument is missing or invalid
-     * @throws Exception             for any other failure (will be caught and wrapped)
-     */
-    public abstract McpSchema.CallToolResult execute(SpectorEngine engine,
-                                                      Map<String, Object> args) throws Exception;
-
-    // ═══════════════════════════════════════════════════════════════
-    //  Tool Specification Builder
-    // ═══════════════════════════════════════════════════════════════
-
-    /**
-     * Builds the MCP SDK {@link McpServerFeatures.SyncToolSpecification}
-     * for this tool, wrapping the handler with timing and error handling.
-     *
-     * @param engine the Spector engine instance
-     * @return fully-configured tool specification ready for server registration
-     */
-    public final McpServerFeatures.SyncToolSpecification toToolSpecification(SpectorEngine engine) {
-        return toToolSpecification(engine, null);
-    }
-
-    /**
-     * Builds the MCP tool specification with optional runtime for mode-aware routing.
-     *
-     * @param engine  the Spector engine instance
-     * @param runtime the Spector runtime (nullable, for mode-aware tools)
-     * @return fully-configured tool specification
-     */
-    public final McpServerFeatures.SyncToolSpecification toToolSpecification(
-            SpectorEngine engine, SpectorRuntime runtime) {
-        var tool = McpSchema.Tool.builder(name())
-                .description(description())
-                .inputSchema(inputSchema())
-                .build();
-
-        return new McpServerFeatures.SyncToolSpecification(tool, (exchange, request) -> {
-            Map<String, Object> args = request.arguments() != null
-                    ? request.arguments()
-                    : Map.of();
-            try {
-                long startNs = System.nanoTime();
-                McpSchema.CallToolResult result = execute(engine, args);
-                long elapsedMs = (System.nanoTime() - startNs) / 1_000_000;
-
-                if (log.isDebugEnabled()) {
-                    log.debug("{} completed in {}ms", name(), elapsedMs);
-                }
-                return result;
-
-            } catch (ToolArgumentException e) {
-                // Validation errors — expected, no stack trace
-                return errorResult(e.getMessage());
-
-            } catch (com.spectrayan.spector.commons.error.SpectorException e) {
-                log.error("{} failed", name(), e);
-                return errorResult(e.getMessage());
-
-            } catch (Exception e) {
-                log.error("{} failed", name(), e);
-                return errorResult(com.spectrayan.spector.commons.error.ErrorCode.INTERNAL_ERROR.format(e.getMessage()));
-            }
-        });
-    }
-
-    // ═══════════════════════════════════════════════════════════════
-    //  Argument Extraction — type-safe with validation
-    // ═══════════════════════════════════════════════════════════════
-
-    /**
-     * Extracts a required string argument.
-     *
-     * @param args the request arguments
-     * @param key  the parameter name
-     * @return the non-blank string value
-     * @throws ToolArgumentException if missing or blank
-     */
-    protected static String requireString(Map<String, Object> args, String key) {
-        Object val = args.get(key);
-        if (val == null || val.toString().isBlank()) {
-            throw new ToolArgumentException("Parameter '" + key + "' is required and must be non-empty.");
-        }
-        return val.toString();
-    }
-
-    /**
-     * Extracts an optional string argument with a default.
-     */
-    protected static String optionalString(Map<String, Object> args, String key, String defaultValue) {
-        Object val = args.get(key);
-        return val != null ? val.toString() : defaultValue;
-    }
-
-    /**
-     * Extracts an optional integer argument with a default.
-     */
-    protected static int optionalInt(Map<String, Object> args, String key, int defaultValue) {
-        Object val = args.get(key);
-        if (val == null) return defaultValue;
-        if (val instanceof Number n) return n.intValue();
-        try {
-            return Integer.parseInt(val.toString());
-        } catch (NumberFormatException e) {
-            return defaultValue;
-        }
-    }
-
-    /**
-     * Extracts an optional boolean argument with a default.
-     */
-    protected static boolean optionalBoolean(Map<String, Object> args, String key,
-                                              boolean defaultValue) {
-        Object val = args.get(key);
-        if (val == null) return defaultValue;
-        if (val instanceof Boolean b) return b;
-        return Boolean.parseBoolean(val.toString());
-    }
-
-    // ═══════════════════════════════════════════════════════════════
-    //  Precondition Checks
-    // ═══════════════════════════════════════════════════════════════
-
-    /**
-     * Validates that the engine has an embedding provider configured.
-     *
-     * @param engine the engine to check
-     * @throws ToolArgumentException if no embedding provider is available
-     */
-    protected static void requireEmbeddingProvider(SpectorEngine engine) {
-        if (!engine.hasEmbeddingProvider()) {
-            throw new ToolArgumentException(
-                    "This operation requires an embedding provider. "
-                    + "Configure the engine with --ollama-url and --ollama-model.");
-        }
-    }
-
-    // ═══════════════════════════════════════════════════════════════
-    //  Result Factories
-    // ═══════════════════════════════════════════════════════════════
-
-    /**
-     * Creates a successful text result.
-     */
-    protected static McpSchema.CallToolResult textResult(String text) {
-        return new McpSchema.CallToolResult(
-                List.of(new McpSchema.TextContent(text)), false, null, null);
-    }
-
-    /**
-     * Creates an error result.
-     */
-    protected static McpSchema.CallToolResult errorResult(String message) {
-        return new McpSchema.CallToolResult(
-                List.of(new McpSchema.TextContent("Error: " + message)), true, null, null);
-    }
-
-    // ═══════════════════════════════════════════════════════════════
-    //  Argument Validation Exception
-    // ═══════════════════════════════════════════════════════════════
-
-    /**
-     * Thrown when a tool argument is missing, invalid, or a precondition fails.
-     * Caught by the base handler and returned as an MCP error result without a stack trace.
-     */
-    public static final class ToolArgumentException extends com.spectrayan.spector.commons.error.SpectorValidationException {
-        public ToolArgumentException(String message) {
-            super(com.spectrayan.spector.commons.error.ErrorCode.ARGUMENT_INVALID, message);
-        }
-    }
-}
diff --git a/spector-mcp/src/main/java/com/spectrayan/spector/mcp/tools/MemoryForgetTool.java b/spector-mcp/src/main/java/com/spectrayan/spector/mcp/tools/MemoryForgetTool.java
deleted file mode 100644
index b5c76e5..0000000
--- a/spector-mcp/src/main/java/com/spectrayan/spector/mcp/tools/MemoryForgetTool.java
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.mcp.tools;
-
-import java.util.Map;
-
-import com.spectrayan.spector.engine.SpectorEngine;
-import com.spectrayan.spector.memory.SpectorMemory;
-import com.spectrayan.spector.mcp.schema.ToolSchemaBuilder;
-
-import io.modelcontextprotocol.spec.McpSchema;
-
-/**
- * MCP tool: {@code memory_forget} — explicitly forget a memory by ID.
- */
-public final class MemoryForgetTool extends MemoryToolHandler {
-
-    public MemoryForgetTool(SpectorMemory memory) {
-        super(memory);
-    }
-
-    @Override public String name() { return "memory_forget"; }
-
-    @Override
-    public String description() {
-        return "Explicitly forget a memory by ID. The memory is tombstoned (logical deletion) "
-                + "and will be cleaned up during the next Deep Sleep consolidation cycle.";
-    }
-
-    @Override
-    public Map<String, Object> inputSchema() {
-        return ToolSchemaBuilder.object()
-                .requiredString("memory_id", "The ID of the memory to forget.")
-                .build();
-    }
-
-    @Override
-    protected McpSchema.CallToolResult executeMemory(SpectorMemory memory,
-                                                       SpectorEngine engine,
-                                                       Map<String, Object> args) throws Exception {
-        String memoryId = requireString(args, "memory_id");
-        memory.forget(memoryId);
-        return textResult("🗑️ Memory '" + memoryId + "' has been forgotten (tombstoned).");
-    }
-}
diff --git a/spector-mcp/src/main/java/com/spectrayan/spector/mcp/tools/MemoryIntrospectTool.java b/spector-mcp/src/main/java/com/spectrayan/spector/mcp/tools/MemoryIntrospectTool.java
deleted file mode 100644
index 95b66b0..0000000
--- a/spector-mcp/src/main/java/com/spectrayan/spector/mcp/tools/MemoryIntrospectTool.java
+++ /dev/null
@@ -1,80 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.mcp.tools;
-
-import java.util.Map;
-
-import com.spectrayan.spector.engine.SpectorEngine;
-import com.spectrayan.spector.memory.SpectorMemory;
-import com.spectrayan.spector.memory.metamemory.MemoryInsight;
-import com.spectrayan.spector.mcp.schema.ToolSchemaBuilder;
-
-import io.modelcontextprotocol.spec.McpSchema;
-
-/**
- * MCP tool: {@code memory_introspect} — metamemory confidence/gaps analysis.
- *
- * <p>Lets the agent reason about what it knows and doesn't know.
- * Instead of hallucinating, the agent can say: "I don't have strong
- * memories about Kubernetes RBAC — let me ask you about that."</p>
- */
-public final class MemoryIntrospectTool extends MemoryToolHandler {
-
-    public MemoryIntrospectTool(SpectorMemory memory) {
-        super(memory);
-    }
-
-    @Override public String name() { return "memory_introspect"; }
-
-    @Override
-    public String description() {
-        return "Introspect the agent's knowledge about a topic. Returns confidence, "
-                + "knowledge gaps, staleness, and actionable recommendations. "
-                + "Use this before answering questions to check if you have reliable knowledge.";
-    }
-
-    @Override
-    public Map<String, Object> inputSchema() {
-        return ToolSchemaBuilder.object()
-                .requiredString("topic", "The topic to introspect (e.g., 'kubernetes', 'user preferences').")
-                .build();
-    }
-
-    @Override
-    protected McpSchema.CallToolResult executeMemory(SpectorMemory memory,
-                                                       SpectorEngine engine,
-                                                       Map<String, Object> args) throws Exception {
-        String topic = requireString(args, "topic");
-
-        MemoryInsight insight = memory.introspect(topic);
-
-        var sb = new StringBuilder();
-        sb.append("🔍 Memory Introspection: '").append(topic).append("'\n");
-        sb.append("===============================\n\n");
-
-        sb.append("Known: ").append(insight.isKnown() ? "Yes" : "No").append("\n");
-        sb.append("Confidence: ").append(String.format("%.2f", insight.confidence())).append("\n");
-        sb.append("Total Memories: ").append(insight.totalMemories()).append("\n");
-        sb.append("Average Importance: ").append(String.format("%.2f", insight.avgImportance())).append("\n");
-        sb.append("Average Age (days): ").append(String.format("%.1f", insight.avgAgeDays())).append("\n");
-        sb.append("Staleness: ").append(String.format("%.2f", insight.staleness())).append("\n");
-        sb.append("Stale: ").append(insight.isStale() ? "⚠️ Yes — knowledge may be outdated" : "No").append("\n\n");
-
-        sb.append("Recommendation: ").append(insight.recommendation()).append("\n");
-
-        return textResult(sb.toString());
-    }
-}
diff --git a/spector-mcp/src/main/java/com/spectrayan/spector/mcp/tools/MemoryReinforceTool.java b/spector-mcp/src/main/java/com/spectrayan/spector/mcp/tools/MemoryReinforceTool.java
deleted file mode 100644
index 1f8cbe9..0000000
--- a/spector-mcp/src/main/java/com/spectrayan/spector/mcp/tools/MemoryReinforceTool.java
+++ /dev/null
@@ -1,94 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.mcp.tools;
-
-import java.util.Map;
-
-import com.spectrayan.spector.engine.SpectorEngine;
-import com.spectrayan.spector.memory.SpectorMemory;
-import com.spectrayan.spector.mcp.schema.ToolSchemaBuilder;
-
-import io.modelcontextprotocol.spec.McpSchema;
-
-/**
- * MCP tool: {@code memory_reinforce} — report outcome (+/-) after using a memory.
- *
- * <p>Outcome-driven reinforcement learning. Valence is learned from results,
- * not guessed at encoding time.</p>
- */
-public final class MemoryReinforceTool extends MemoryToolHandler {
-
-    public MemoryReinforceTool(SpectorMemory memory) {
-        super(memory);
-    }
-
-    @Override public String name() { return "memory_reinforce"; }
-
-    @Override
-    public String description() {
-        return "Report the outcome after using a recalled memory. "
-                + "If the memory helped solve the problem, reinforce positively (+50). "
-                + "If it was misleading, reinforce negatively (-50). "
-                + "This teaches the memory system which facts are reliable.";
-    }
-
-    @Override
-    public Map<String, Object> inputSchema() {
-        return ToolSchemaBuilder.object()
-                .requiredString("memory_id", "The ID of the memory to reinforce.")
-                .requiredString("valence",
-                        "Outcome: 'strongly_positive' (+100), 'positive' (+50), "
-                        + "'neutral' (0), 'negative' (-50), 'strongly_negative' (-100), "
-                        + "or a numeric byte value (-128 to 127).")
-                .build();
-    }
-
-    @Override
-    protected McpSchema.CallToolResult executeMemory(SpectorMemory memory,
-                                                       SpectorEngine engine,
-                                                       Map<String, Object> args) throws Exception {
-        String memoryId = requireString(args, "memory_id");
-        String valenceStr = requireString(args, "valence");
-
-        byte valence = parseValence(valenceStr);
-
-        // Check if this was a lateral result before reinforcing
-        boolean wasLateral = memory.recallPipeline().wasLateral(memoryId);
-
-        memory.reinforce(memoryId, valence);
-
-        String emoji = valence > 0 ? "👍" : valence < 0 ? "👎" : "😐";
-        String lateralInfo = wasLateral ? " (lateral result — feedback recorded)" : "";
-        return textResult(emoji + " Reinforced '" + memoryId + "' with valence=" + valence + lateralInfo);
-    }
-
-    private static byte parseValence(String str) {
-        return switch (str.toLowerCase().replace("_", "").replace("-", "")) {
-            case "stronglypositive" -> 100;
-            case "positive" -> 50;
-            case "neutral" -> 0;
-            case "negative" -> -50;
-            case "stronglynegative" -> -100;
-            default -> {
-                try {
-                    yield Byte.parseByte(str);
-                } catch (NumberFormatException e) {
-                    yield 0;
-                }
-            }
-        };
-    }
-}
diff --git a/spector-mcp/src/main/java/com/spectrayan/spector/mcp/tools/MemoryStatusTool.java b/spector-mcp/src/main/java/com/spectrayan/spector/mcp/tools/MemoryStatusTool.java
deleted file mode 100644
index 883137a..0000000
--- a/spector-mcp/src/main/java/com/spectrayan/spector/mcp/tools/MemoryStatusTool.java
+++ /dev/null
@@ -1,85 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.mcp.tools;
-
-import java.util.Map;
-
-import com.spectrayan.spector.engine.SpectorEngine;
-import com.spectrayan.spector.memory.MemoryType;
-import com.spectrayan.spector.memory.SpectorMemory;
-import com.spectrayan.spector.memory.neurodivergent.LateralEvaluator;
-import com.spectrayan.spector.mcp.schema.ToolSchemaBuilder;
-
-import io.modelcontextprotocol.spec.McpSchema;
-
-/**
- * MCP tool: {@code memory_status} — memory stats per tier.
- */
-public final class MemoryStatusTool extends MemoryToolHandler {
-
-    public MemoryStatusTool(SpectorMemory memory) {
-        super(memory);
-    }
-
-    @Override public String name() { return "memory_status"; }
-
-    @Override
-    public String description() {
-        return "View memory system statistics: total memories, per-tier counts, "
-                + "WAL event count, suppression set size, and pending reminders.";
-    }
-
-    @Override
-    public Map<String, Object> inputSchema() {
-        return ToolSchemaBuilder.object().build();
-    }
-
-    @Override
-    protected McpSchema.CallToolResult executeMemory(SpectorMemory memory,
-                                                       SpectorEngine engine,
-                                                       Map<String, Object> args) {
-        var sb = new StringBuilder();
-        sb.append("🧠 Spector Memory Status\n");
-        sb.append("========================\n\n");
-
-        sb.append("Total Memories: ").append(memory.totalMemories()).append("\n\n");
-
-        sb.append("Per-Tier Breakdown:\n");
-        sb.append("  Working (Prefrontal Cortex):  ").append(memory.memoryCount(MemoryType.WORKING)).append("\n");
-        sb.append("  Episodic (Hippocampus):       ").append(memory.memoryCount(MemoryType.EPISODIC)).append("\n");
-        sb.append("  Semantic (Neocortex):         ").append(memory.memoryCount(MemoryType.SEMANTIC)).append("\n");
-        sb.append("  Procedural (Basal Ganglia):   ").append(memory.memoryCount(MemoryType.PROCEDURAL)).append("\n\n");
-
-        sb.append("Subsystem Status:\n");
-        sb.append("  WAL Events:          ").append(memory.wal().size()).append("\n");
-        sb.append("  WAL High-Water Mark: ").append(memory.wal().highWaterMark()).append("\n");
-        sb.append("  Suppressed Memories: ").append(memory.suppression().size()).append("\n");
-        sb.append("  Pending Reminders:   ").append(memory.prospective().pendingCount()).append("\n\n");
-
-        // Lateral evaluator metrics
-        LateralEvaluator lateral = memory.lateralEvaluator();
-        LateralEvaluator.LateralMetrics metrics = lateral.metrics();
-        sb.append("Lateral Retrieval:\n");
-        sb.append("  Enabled:    ").append(lateral.isLateralEnabled()).append("\n");
-        sb.append("  Threshold:  ").append(String.format("%.2f", lateral.currentDistanceThreshold())).append("\n");
-        sb.append("  Samples:    ").append(metrics.sampleSize()).append("\n");
-        sb.append("  LUR (util): ").append(String.format("%.2f", metrics.utilityRate())).append("\n");
-        sb.append("  LSR (supp): ").append(String.format("%.2f", metrics.suppressionRate())).append("\n");
-        sb.append("  LHI (hall): ").append(String.format("%.2f", metrics.hallucinationIndex())).append("\n");
-
-        return textResult(sb.toString());
-    }
-}
diff --git a/spector-mcp/src/main/java/com/spectrayan/spector/mcp/tools/MemoryToolHandler.java b/spector-mcp/src/main/java/com/spectrayan/spector/mcp/tools/MemoryToolHandler.java
deleted file mode 100644
index f3c2a8e..0000000
--- a/spector-mcp/src/main/java/com/spectrayan/spector/mcp/tools/MemoryToolHandler.java
+++ /dev/null
@@ -1,100 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.mcp.tools;
-
-import java.util.Map;
-
-import com.spectrayan.spector.engine.SpectorEngine;
-import com.spectrayan.spector.memory.SpectorMemory;
-
-import io.modelcontextprotocol.spec.McpSchema;
-
-/**
- * Base handler for memory-aware MCP tools.
- *
- * <p>Memory tools need both the {@link SpectorEngine} (for embedding) and
- * {@link SpectorMemory} (for cognitive operations). Subclasses implement
- * {@link #executeMemory(SpectorMemory, SpectorEngine, Map)} instead of
- * the standard {@code execute()} method.</p>
- */
-public abstract class MemoryToolHandler extends McpToolHandler {
-
-    private final SpectorMemory memory;
-
-    protected MemoryToolHandler(SpectorMemory memory) {
-        this.memory = memory;
-    }
-
-    /**
-     * Executes the memory tool logic.
-     *
-     * @param memory the cognitive memory instance
-     * @param engine the search engine (for embedding provider access)
-     * @param args   the parsed MCP request arguments
-     * @return the tool result
-     */
-    protected abstract McpSchema.CallToolResult executeMemory(SpectorMemory memory,
-                                                               SpectorEngine engine,
-                                                               Map<String, Object> args) throws Exception;
-
-    @Override
-    public final McpSchema.CallToolResult execute(SpectorEngine engine,
-                                                    Map<String, Object> args) throws Exception {
-        if (memory == null) {
-            return errorResult("SpectorMemory is not configured. Start the server with --memory-enabled.");
-        }
-        return executeMemory(memory, engine, args);
-    }
-
-    /**
-     * Extracts an optional float argument.
-     */
-    protected static float optionalFloat(Map<String, Object> args, String key, float defaultValue) {
-        Object val = args.get(key);
-        if (val == null) return defaultValue;
-        if (val instanceof Number n) return n.floatValue();
-        try {
-            return Float.parseFloat(val.toString());
-        } catch (NumberFormatException e) {
-            return defaultValue;
-        }
-    }
-
-    /**
-     * Extracts an optional byte argument.
-     */
-    protected static byte optionalByte(Map<String, Object> args, String key, byte defaultValue) {
-        Object val = args.get(key);
-        if (val == null) return defaultValue;
-        if (val instanceof Number n) return n.byteValue();
-        try {
-            return Byte.parseByte(val.toString());
-        } catch (NumberFormatException e) {
-            return defaultValue;
-        }
-    }
-
-    /**
-     * Extracts an optional string array argument (comma-separated).
-     */
-    protected static String[] optionalTags(Map<String, Object> args, String key) {
-        Object val = args.get(key);
-        if (val == null) return new String[0];
-        String str = val.toString().trim();
-        if (str.isEmpty()) return new String[0];
-        return str.split("\\s*,\\s*");
-    }
-}
diff --git a/spector-mcp/src/main/java/com/spectrayan/spector/mcp/tools/RagQueryTool.java b/spector-mcp/src/main/java/com/spectrayan/spector/mcp/tools/RagQueryTool.java
deleted file mode 100644
index 878721a..0000000
--- a/spector-mcp/src/main/java/com/spectrayan/spector/mcp/tools/RagQueryTool.java
+++ /dev/null
@@ -1,80 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.mcp.tools;
-
-import java.util.Map;
-
-import com.spectrayan.spector.engine.SpectorEngine;
-import com.spectrayan.spector.mcp.schema.ToolSchemaBuilder;
-import com.spectrayan.spector.mcp.util.ResultFormatter;
-import com.spectrayan.spector.query.SearchResponse;
-
-import io.modelcontextprotocol.spec.McpSchema;
-
-/**
- * Retrieval-Augmented Generation tool.
- *
- * <p>Retrieves relevant context from the Spector index and assembles
- * it with source attributions within a token budget. Designed for
- * grounded responses — each retrieved chunk includes its document ID
- * and relevance score for citation.</p>
- */
-public final class RagQueryTool extends McpToolHandler {
-
-    @Override
-    public String name() {
-        return "rag_query";
-    }
-
-    @Override
-    public String description() {
-        return "Retrieval-Augmented Generation: retrieves relevant context from the Spector "
-                + "index and assembles it within a token budget. Returns context text with "
-                + "source attributions for grounded responses.";
-    }
-
-    @Override
-    public Map<String, Object> inputSchema() {
-        return ToolSchemaBuilder.object()
-                .requiredString("query",
-                        "The question or topic to retrieve context for.")
-                .optionalInt("top_k",
-                        "Number of candidate chunks to consider (1-50).", 10)
-                .optionalInt("token_limit",
-                        "Maximum tokens in returned context (256-8192).", 4096)
-                .build();
-    }
-
-    @Override
-    public McpSchema.CallToolResult execute(SpectorEngine engine, Map<String, Object> args) {
-        requireEmbeddingProvider(engine);
-        String query = requireString(args, "query");
-        int topK = optionalInt(args, "top_k", 10);
-
-        long startNs = System.nanoTime();
-        SearchResponse response = engine.search(query, topK);
-        long elapsedMs = (System.nanoTime() - startNs) / 1_000_000;
-
-        String context = ResultFormatter.formatRagContext(response, engine);
-        int sourceCount = response.results() != null ? response.results().length : 0;
-
-        String footer = String.format(
-                "\n[%d sources retrieved in %dms via Spector SIMD search]",
-                sourceCount, elapsedMs);
-
-        return textResult(context + footer);
-    }
-}
diff --git a/spector-mcp/src/main/java/com/spectrayan/spector/mcp/tools/RecallContextTool.java b/spector-mcp/src/main/java/com/spectrayan/spector/mcp/tools/RecallContextTool.java
deleted file mode 100644
index 49ae8a4..0000000
--- a/spector-mcp/src/main/java/com/spectrayan/spector/mcp/tools/RecallContextTool.java
+++ /dev/null
@@ -1,125 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.mcp.tools;
-
-import java.util.Map;
-import java.util.List;
-
-import com.spectrayan.spector.engine.SpectorEngine;
-import com.spectrayan.spector.memory.CognitiveResult;
-import com.spectrayan.spector.memory.RecallOptions;
-import com.spectrayan.spector.memory.SpectorMemory;
-import com.spectrayan.spector.mcp.schema.ToolSchemaBuilder;
-
-import io.modelcontextprotocol.spec.McpSchema;
-
-/**
- * MCP tool: {@code recall_context} — cross-tier fused recall with rich provenance.
- *
- * <p>Performs the full 6-phase SIMD scoring pipeline across all memory tiers,
- * returning results with full provenance metadata for LLM grounding.</p>
- */
-public final class RecallContextTool extends MemoryToolHandler {
-
-    public RecallContextTool(SpectorMemory memory) {
-        super(memory);
-    }
-
-    @Override public String name() { return "recall_context"; }
-
-    @Override
-    public String description() {
-        return "Recall relevant memories using fused cognitive scoring across all memory tiers "
-                + "(Working, Episodic, Semantic, Procedural). Returns results with full provenance: "
-                + "confidence, age, importance, valence, source, and decay factors. "
-                + "Use synaptic_filter for contextual pre-filtering (e.g., 'debugging,database').";
-    }
-
-    @Override
-    public Map<String, Object> inputSchema() {
-        return ToolSchemaBuilder.object()
-                .requiredString("query", "Natural language query for memory recall.")
-                .optionalInt("top_k", "Number of results to return (1-50).", 5)
-                .optionalString("synaptic_filter",
-                        "Comma-separated tags for Bloom filter pre-filtering.", "")
-                .optionalString("min_importance",
-                        "Minimum importance threshold (0.0-10.0).", "0.0")
-                .optionalString("min_valence",
-                        "Minimum valence filter (e.g., -128 for all, 10 for positive only).", "")
-                .optionalString("max_valence",
-                        "Maximum valence filter (e.g., -10 for failures only).", "")
-                .build();
-    }
-
-    @Override
-    protected McpSchema.CallToolResult executeMemory(SpectorMemory memory,
-                                                       SpectorEngine engine,
-                                                       Map<String, Object> args) throws Exception {
-        String query = requireString(args, "query");
-        int topK = optionalInt(args, "top_k", 5);
-
-        var builder = RecallOptions.builder().topK(topK);
-
-        String[] filterTags = optionalTags(args, "synaptic_filter");
-        if (filterTags.length > 0) {
-            builder.synapticFilter(filterTags);
-        }
-
-        float minImp = optionalFloat(args, "min_importance", 0.0f);
-        if (minImp > 0) builder.minImportance(minImp);
-
-        byte minVal = optionalByte(args, "min_valence", Byte.MIN_VALUE);
-        byte maxVal = optionalByte(args, "max_valence", Byte.MAX_VALUE);
-        builder.minValence(minVal).maxValence(maxVal);
-
-        long startNs = System.nanoTime();
-        List<CognitiveResult> results = memory.recall(query, builder.build());
-        long elapsedMs = (System.nanoTime() - startNs) / 1_000_000;
-
-        if (results.isEmpty()) {
-            return textResult("No memories found for query: '" + query + "'");
-        }
-
-        var sb = new StringBuilder();
-        sb.append("🧠 Recalled ").append(results.size()).append(" memories (").append(elapsedMs).append("ms):\n\n");
-
-        for (int i = 0; i < results.size(); i++) {
-            CognitiveResult r = results.get(i);
-            sb.append("--- Memory ").append(i + 1).append(" ---\n");
-            sb.append("ID: ").append(r.id()).append("\n");
-            sb.append("Text: ").append(r.text()).append("\n");
-            sb.append("Score: ").append(String.format("%.4f", r.score())).append("\n");
-
-            // Rich provenance (from analysis doc §Explainability)
-            sb.append("Provenance:\n");
-            sb.append("  confidence: ").append(String.format("%.2f", r.ltpAdjustedDecay())).append("\n");
-            sb.append("  age_days: ").append(String.format("%.1f", r.ageDays())).append("\n");
-            sb.append("  importance: ").append(String.format("%.2f", r.importance())).append("\n");
-            sb.append("  memory_type: ").append(r.memoryType()).append("\n");
-            if (r.synapticTags() != null && r.synapticTags().length > 0) {
-                sb.append("  synaptic_context: [").append(String.join(", ", r.synapticTags())).append("]\n");
-            }
-            sb.append("  recall_count: ").append(r.recallCount()).append("\n");
-            sb.append("  valence: ").append(r.valence()).append("\n");
-            sb.append("  source: ").append(r.source()).append("\n");
-            sb.append("  decay_factor: ").append(String.format("%.3f", r.decayFactor())).append("\n");
-            sb.append("  ltp_adjusted_decay: ").append(String.format("%.3f", r.ltpAdjustedDecay())).append("\n");
-            sb.append("\n");
-        }
-
-        return textResult(sb.toString());
-    }
-}
diff --git a/spector-mcp/src/main/java/com/spectrayan/spector/mcp/tools/SemanticSearchTool.java b/spector-mcp/src/main/java/com/spectrayan/spector/mcp/tools/SemanticSearchTool.java
deleted file mode 100644
index 8fcd4ba..0000000
--- a/spector-mcp/src/main/java/com/spectrayan/spector/mcp/tools/SemanticSearchTool.java
+++ /dev/null
@@ -1,74 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.mcp.tools;
-
-import java.util.Map;
-
-import com.spectrayan.spector.engine.SpectorEngine;
-import com.spectrayan.spector.mcp.schema.ToolSchemaBuilder;
-import com.spectrayan.spector.mcp.util.ResultFormatter;
-import com.spectrayan.spector.query.SearchResponse;
-
-import io.modelcontextprotocol.spec.McpSchema;
-
-/**
- * Semantic similarity search via SIMD-accelerated vector index.
- *
- * <p>Queries are automatically embedded into vectors using the configured
- * {@link com.spectrayan.spector.embed.EmbeddingProvider} and matched
- * against the HNSW/IVF-SVASQ index for sub-millisecond latency.</p>
- */
-public final class SemanticSearchTool extends McpToolHandler {
-
-    @Override
-    public String name() {
-        return "semantic_search";
-    }
-
-    @Override
-    public String description() {
-        return "Perform semantic similarity search over the Spector vector index. "
-                + "Returns the most relevant documents based on meaning, powered by "
-                + "SIMD-accelerated HNSW/IVF-SVASQ indexes for sub-millisecond latency. "
-                + "Requires an embedding provider to be configured.";
-    }
-
-    @Override
-    public Map<String, Object> inputSchema() {
-        return ToolSchemaBuilder.object()
-                .requiredString("query",
-                        "Natural language search query. Text is automatically "
-                        + "embedded into a vector for similarity search.")
-                .optionalInt("top_k",
-                        "Number of results to return (1-100).", 5)
-                .build();
-    }
-
-    @Override
-    public McpSchema.CallToolResult execute(SpectorEngine engine, Map<String, Object> args) {
-        requireEmbeddingProvider(engine);
-        String query = requireString(args, "query");
-        int topK = optionalInt(args, "top_k", 5);
-
-        long startNs = System.nanoTime();
-        SearchResponse response = engine.search(query, topK);
-        long elapsedMs = (System.nanoTime() - startNs) / 1_000_000;
-
-        String text = ResultFormatter.formatSearchResults(response, engine);
-        return textResult(ResultFormatter.withTimingFooter(
-                text, "Spector SIMD search", elapsedMs));
-    }
-}
diff --git a/spector-mcp/src/main/java/com/spectrayan/spector/mcp/tools/SpectorToolRegistry.java b/spector-mcp/src/main/java/com/spectrayan/spector/mcp/tools/SpectorToolRegistry.java
deleted file mode 100644
index 1e9fe5a..0000000
--- a/spector-mcp/src/main/java/com/spectrayan/spector/mcp/tools/SpectorToolRegistry.java
+++ /dev/null
@@ -1,130 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.mcp.tools;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import com.spectrayan.spector.engine.SpectorEngine;
-import com.spectrayan.spector.memory.SpectorMemory;
-import com.spectrayan.spector.runtime.SpectorRuntime;
-
-import io.modelcontextprotocol.server.McpServerFeatures;
-
-/**
- * Central registry for all Spector MCP tool handlers.
- *
- * <p>To add a new tool:</p>
- * <ol>
- *   <li>Create a class extending {@link McpToolHandler}</li>
- *   <li>Add a single entry to the handlers list below</li>
- * </ol>
- *
- * <p>All tools are instantiated once and reused across requests.
- * The {@link McpToolHandler} base class ensures thread-safe execution
- * on concurrent virtual threads.</p>
- */
-public final class SpectorToolRegistry {
-
-    private SpectorToolRegistry() {} // static utility
-
-    /**
-     * Returns the list of all tool handlers registered in this server.
-     *
-     * @param serverVersion the server version string
-     * @return unmodifiable list of tool handlers
-     */
-    public static List<McpToolHandler> handlers(String serverVersion) {
-        return handlers(serverVersion, null);
-    }
-
-    /**
-     * Returns tool handlers including memory tools when SpectorMemory is available.
-     *
-     * @param serverVersion the server version string
-     * @param memory        optional SpectorMemory instance (null if memory is not enabled)
-     * @return list of tool handlers
-     */
-    public static List<McpToolHandler> handlers(String serverVersion, SpectorMemory memory) {
-        var handlers = new ArrayList<McpToolHandler>();
-
-        // Core search/ingest tools
-        handlers.add(new SemanticSearchTool());
-        handlers.add(new HybridSearchTool());
-        handlers.add(new RagQueryTool());
-        handlers.add(new IngestDocumentTool());
-        handlers.add(new DeleteDocumentTool());
-        handlers.add(new EngineStatusTool(serverVersion));
-
-        // Memory tools (available when SpectorMemory is configured)
-        if (memory != null) {
-            handlers.add(new CoreMemoryAppendTool(memory));
-            handlers.add(new WorkingMemoryScratchpadTool(memory));
-            handlers.add(new RecallContextTool(memory));
-            handlers.add(new MemoryReinforceTool(memory));
-            handlers.add(new MemoryForgetTool(memory));
-            handlers.add(new MemoryStatusTool(memory));
-            handlers.add(new MemoryIntrospectTool(memory));
-        }
-
-        return List.copyOf(handlers);
-    }
-
-    /**
-     * Creates all tool specifications for MCP server registration.
-     *
-     * @param engine        the Spector engine instance
-     * @param serverVersion the server version string
-     * @return list of MCP tool specifications ready for server builder
-     */
-    public static List<McpServerFeatures.SyncToolSpecification> createAll(
-            SpectorEngine engine, String serverVersion) {
-        return createAll(engine, serverVersion, null);
-    }
-
-    /**
-     * Creates all tool specifications including memory tools.
-     *
-     * @param engine        the Spector engine instance
-     * @param serverVersion the server version string
-     * @param memory        optional SpectorMemory instance
-     * @return list of MCP tool specifications
-     */
-    public static List<McpServerFeatures.SyncToolSpecification> createAll(
-            SpectorEngine engine, String serverVersion, SpectorMemory memory) {
-        return handlers(serverVersion, memory).stream()
-                .map(handler -> handler.toToolSpecification(engine))
-                .toList();
-    }
-
-    /**
-     * Creates all tool specifications with mode-aware runtime support.
-     *
-     * <p>When a {@link SpectorRuntime} is provided, tools can access the
-     * runtime for mode-aware search and ingestion routing.</p>
-     *
-     * @param runtime       the Spector runtime (engine + optional memory)
-     * @param serverVersion the server version string
-     * @return list of MCP tool specifications
-     */
-    public static List<McpServerFeatures.SyncToolSpecification> createAll(
-            SpectorRuntime runtime, String serverVersion) {
-        SpectorMemory memory = runtime.hasMemory() ? runtime.memory() : null;
-        return handlers(serverVersion, memory).stream()
-                .map(handler -> handler.toToolSpecification(runtime.engine(), runtime))
-                .toList();
-    }
-}
diff --git a/spector-mcp/src/main/java/com/spectrayan/spector/mcp/tools/WorkingMemoryScratchpadTool.java b/spector-mcp/src/main/java/com/spectrayan/spector/mcp/tools/WorkingMemoryScratchpadTool.java
deleted file mode 100644
index 3774592..0000000
--- a/spector-mcp/src/main/java/com/spectrayan/spector/mcp/tools/WorkingMemoryScratchpadTool.java
+++ /dev/null
@@ -1,63 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.mcp.tools;
-
-import java.util.Map;
-
-import com.spectrayan.spector.engine.SpectorEngine;
-import com.spectrayan.spector.memory.SpectorMemory;
-import com.spectrayan.spector.mcp.schema.ToolSchemaBuilder;
-
-import io.modelcontextprotocol.spec.McpSchema;
-
-/**
- * MCP tool: {@code working_memory_scratchpad} — stores in-progress reasoning.
- *
- * <p>Working memory is volatile (RAM-only). When capacity is reached,
- * the oldest items are evicted via FIFO.</p>
- */
-public final class WorkingMemoryScratchpadTool extends MemoryToolHandler {
-
-    public WorkingMemoryScratchpadTool(SpectorMemory memory) {
-        super(memory);
-    }
-
-    @Override public String name() { return "working_memory_scratchpad"; }
-
-    @Override
-    public String description() {
-        return "Store a short-lived scratchpad note in working memory. "
-                + "Use this for in-progress reasoning, temporary hypotheses, "
-                + "or chain-of-thought steps. Working memory is volatile and "
-                + "auto-evicts old entries when capacity is reached.";
-    }
-
-    @Override
-    public Map<String, Object> inputSchema() {
-        return ToolSchemaBuilder.object()
-                .requiredString("text", "The scratchpad note to store.")
-                .build();
-    }
-
-    @Override
-    protected McpSchema.CallToolResult executeMemory(SpectorMemory memory,
-                                                       SpectorEngine engine,
-                                                       Map<String, Object> args) throws Exception {
-        String text = requireString(args, "text");
-        memory.scratchpad(text).join();
-        return textResult("📝 Stored in working memory scratchpad.");
-    }
-}
diff --git a/spector-mcp/src/main/java/com/spectrayan/spector/mcp/util/ResultFormatter.java b/spector-mcp/src/main/java/com/spectrayan/spector/mcp/util/ResultFormatter.java
deleted file mode 100644
index dd6d650..0000000
--- a/spector-mcp/src/main/java/com/spectrayan/spector/mcp/util/ResultFormatter.java
+++ /dev/null
@@ -1,223 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.mcp.util;
-
-import java.util.LinkedHashMap;
-import java.util.Map;
-
-import com.spectrayan.spector.core.simd.SimdCapability;
-import com.spectrayan.spector.engine.SpectorEngine;
-import com.spectrayan.spector.index.ScoredResult;
-import com.spectrayan.spector.query.SearchResponse;
-
-/**
- * Shared formatting utilities for MCP tool and resource responses.
- *
- * <p>Centralizes all text and structured-data formatting that was previously
- * scattered across {@code SpectorMcpServer} and {@code SpectorToolProvider}.
- * Methods are stateless, thread-safe, and designed for zero-allocation
- * reuse across concurrent virtual-thread handlers.</p>
- */
-public final class ResultFormatter {
-
-    /** Maximum content length before truncation in search result summaries. */
-    private static final int CONTENT_TRUNCATION_LIMIT = 500;
-
-    /** Truncation suffix appended when content exceeds the limit. */
-    private static final String TRUNCATION_SUFFIX = "...";
-
-    private ResultFormatter() {} // static utility
-
-    // ═══════════════════════════════════════════════════════════════
-    //  Search Results
-    // ═══════════════════════════════════════════════════════════════
-
-    /**
-     * Formats search results for LLM consumption with score and truncated content.
-     *
-     * @param response the search response from the engine
-     * @param engine   the engine instance (for document store lookups)
-     * @return formatted text suitable for MCP tool responses
-     */
-    public static String formatSearchResults(SearchResponse response, SpectorEngine engine) {
-        if (response.results() == null || response.results().length == 0) {
-            return "No results found.";
-        }
-
-        var sb = new StringBuilder(1024);
-        sb.append("Found ").append(response.results().length)
-          .append(" results in ").append(response.queryTimeMs()).append("ms:\n\n");
-
-        for (ScoredResult r : response.results()) {
-            sb.append('[').append(r.id()).append("] (score: ");
-            appendScore(sb, r.score());
-            sb.append(')');
-
-            var doc = engine.documentStore().get(r.id());
-            if (doc != null && doc.content() != null) {
-                sb.append('\n');
-                appendTruncated(sb, doc.content(), CONTENT_TRUNCATION_LIMIT);
-            }
-            sb.append("\n\n");
-        }
-
-        return sb.toString();
-    }
-
-    // ═══════════════════════════════════════════════════════════════
-    //  RAG Context
-    // ═══════════════════════════════════════════════════════════════
-
-    /**
-     * Formats search results as RAG context with source attributions.
-     *
-     * @param response the search response
-     * @param engine   the engine instance
-     * @return formatted context block with source citations
-     */
-    public static String formatRagContext(SearchResponse response, SpectorEngine engine) {
-        if (response.results() == null || response.results().length == 0) {
-            return "No relevant context found for this query.";
-        }
-
-        var sb = new StringBuilder(2048);
-        sb.append("--- RETRIEVED CONTEXT ---\n\n");
-        int sourceIdx = 0;
-
-        for (ScoredResult r : response.results()) {
-            var doc = engine.documentStore().get(r.id());
-            if (doc != null && doc.content() != null) {
-                sourceIdx++;
-                sb.append("[Source ").append(sourceIdx).append(": ").append(r.id())
-                  .append(" (relevance: ");
-                appendScore(sb, r.score());
-                sb.append(")]\n");
-                sb.append(doc.content());
-                sb.append("\n\n");
-            }
-        }
-
-        sb.append("--- END CONTEXT ---");
-        return sb.toString();
-    }
-
-    // ═══════════════════════════════════════════════════════════════
-    //  Engine Status
-    // ═══════════════════════════════════════════════════════════════
-
-    /**
-     * Builds a structured map of engine status fields.
-     *
-     * <p>Returns a {@code Map<String, Object>} that can be serialized
-     * to JSON via Jackson or formatted as text — no {@code String.format}
-     * JSON construction.</p>
-     *
-     * @param engine  the engine instance
-     * @param version the server version string
-     * @return ordered map of status fields
-     */
-    public static Map<String, Object> buildEngineStatusMap(SpectorEngine engine, String version) {
-        var status = new LinkedHashMap<String, Object>(12);
-        status.put("engine", "spector");
-        status.put("version", version);
-        status.put("documents", engine.documentCount());
-        status.put("dimensions", engine.config().dimensions());
-        status.put("similarity", engine.config().similarityFunction().name());
-        status.put("indexType", engine.config().indexType().name());
-        status.put("quantization", engine.config().quantization().name());
-        status.put("gpu", engine.isGpuActive() ? "active" : "inactive");
-        status.put("reranker", engine.isRerankerActive() ? "active" : "disabled");
-        status.put("embedding", engine.hasEmbeddingProvider()
-                ? engine.embeddingProvider().modelName() : "none");
-        status.put("simd", SimdCapability.report());
-        return status;
-    }
-
-    /**
-     * Formats engine status as human-readable text for tool responses.
-     *
-     * @param engine  the engine instance
-     * @param version the server version string
-     * @return formatted status text
-     */
-    public static String formatEngineStatus(SpectorEngine engine, String version) {
-        Map<String, Object> status = buildEngineStatusMap(engine, version);
-
-        var sb = new StringBuilder(512);
-        sb.append("Spector Engine Status:\n");
-        sb.append("─────────────────────────────\n");
-        for (var entry : status.entrySet()) {
-            sb.append(String.format("%-15s %s%n",
-                    capitalize(entry.getKey()) + ":", entry.getValue()));
-        }
-        return sb.toString();
-    }
-
-    // ═══════════════════════════════════════════════════════════════
-    //  Timing Footer
-    // ═══════════════════════════════════════════════════════════════
-
-    /**
-     * Appends a timing footer to a result string.
-     *
-     * @param text      the result text
-     * @param label     operation label (e.g., "Spector SIMD search")
-     * @param elapsedMs elapsed time in milliseconds
-     * @return text with timing footer appended
-     */
-    public static String withTimingFooter(String text, String label, long elapsedMs) {
-        return text + "\n[" + label + " completed in " + elapsedMs + "ms]";
-    }
-
-    // ═══════════════════════════════════════════════════════════════
-    //  Internal Helpers
-    // ═══════════════════════════════════════════════════════════════
-
-    /**
-     * Appends a float score formatted to 4 decimal places without
-     * creating an intermediate String via String.format.
-     */
-    private static void appendScore(StringBuilder sb, float score) {
-        // Manual formatting avoids String.format overhead on hot path
-        int intPart = (int) score;
-        int fracPart = Math.round((score - intPart) * 10_000);
-        sb.append(intPart).append('.');
-        if (fracPart < 1000) sb.append('0');
-        if (fracPart < 100) sb.append('0');
-        if (fracPart < 10) sb.append('0');
-        sb.append(fracPart);
-    }
-
-    /**
-     * Appends content to a StringBuilder, truncating if longer than maxLength.
-     */
-    private static void appendTruncated(StringBuilder sb, String content, int maxLength) {
-        if (content.length() <= maxLength) {
-            sb.append(content);
-        } else {
-            sb.append(content, 0, maxLength).append(TRUNCATION_SUFFIX);
-        }
-    }
-
-    /**
-     * Capitalizes the first letter of a camelCase key for display.
-     * "indexType" → "IndexType", "gpu" → "Gpu"
-     */
-    private static String capitalize(String key) {
-        if (key == null || key.isEmpty()) return key;
-        return Character.toUpperCase(key.charAt(0)) + key.substring(1);
-    }
-}
diff --git a/spector-mcp/src/main/resources/logback.xml b/spector-mcp/src/main/resources/logback.xml
deleted file mode 100644
index e752582..0000000
--- a/spector-mcp/src/main/resources/logback.xml
+++ /dev/null
@@ -1,32 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-  Logback configuration for the Spector MCP Server.
-  
-  CRITICAL: All logging MUST go to stderr (System.err), NOT stdout.
-  Stdout is reserved exclusively for the JSON-RPC 2.0 message stream
-  between the MCP server and the AI agent client. Any text written to
-  stdout that is not valid JSON-RPC will corrupt the protocol stream
-  and crash the agent connection.
--->
-<configuration>
-    <appender name="STDERR" class="ch.qos.logback.core.ConsoleAppender">
-        <target>System.err</target>
-        <encoder>
-            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
-        </encoder>
-    </appender>
-
-    <!-- Suppress noisy framework loggers -->
-    <logger name="io.modelcontextprotocol" level="WARN" />
-    <logger name="com.fasterxml.jackson" level="WARN" />
-
-    <!-- Spector MCP at INFO for operational visibility -->
-    <logger name="com.spectrayan.spector.mcp" level="INFO" />
-
-    <!-- Engine internals at WARN to reduce noise -->
-    <logger name="com.spectrayan.spector" level="WARN" />
-
-    <root level="INFO">
-        <appender-ref ref="STDERR" />
-    </root>
-</configuration>
diff --git a/spector-mcp/src/test/java/com/spectrayan/spector/mcp/tools/SpectorToolRegistryTest.java b/spector-mcp/src/test/java/com/spectrayan/spector/mcp/tools/SpectorToolRegistryTest.java
deleted file mode 100644
index 99ecc7f..0000000
--- a/spector-mcp/src/test/java/com/spectrayan/spector/mcp/tools/SpectorToolRegistryTest.java
+++ /dev/null
@@ -1,288 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.mcp.tools;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-import java.util.List;
-import java.util.Map;
-
-import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.api.BeforeAll;
-import org.junit.jupiter.api.Test;
-
-import com.spectrayan.spector.embed.EmbeddingProvider;
-import com.spectrayan.spector.embed.EmbeddingResult;
-import com.spectrayan.spector.config.SpectorConfig;
-import com.spectrayan.spector.engine.DefaultSpectorEngine;
-import com.spectrayan.spector.engine.SpectorEngine;
-import com.spectrayan.spector.mcp.schema.ToolSchemaBuilder;
-
-import io.modelcontextprotocol.server.McpServerFeatures;
-import io.modelcontextprotocol.spec.McpSchema;
-
-/**
- * Unit tests for the refactored Spector MCP tool system.
- *
- * <p>Tests cover:</p>
- * <ul>
- *   <li>Tool registry — all 6 tools registered with correct names</li>
- *   <li>Individual tool handlers — correct behavior via the abstract base</li>
- *   <li>Schema builder — produces valid input schemas</li>
- *   <li>Argument validation — missing/empty required args produce errors</li>
- * </ul>
- */
-class SpectorToolRegistryTest {
-
-    private static final String TEST_VERSION = "0.1.0-test";
-
-    private static SpectorEngine engine;
-    private static List<McpServerFeatures.SyncToolSpecification> specs;
-
-    @BeforeAll
-    static void setUp() {
-        SpectorConfig config = SpectorConfig.DEFAULT.withDimensions(4);
-        engine = new DefaultSpectorEngine(config, new MockEmbeddingProvider());
-
-        engine.ingest("doc-1", "Java Panama SIMD vector search engine");
-        engine.ingest("doc-2", "Machine learning and artificial intelligence");
-        engine.ingest("doc-3", "Kubernetes container orchestration platform");
-
-        specs = SpectorToolRegistry.createAll(engine, TEST_VERSION);
-    }
-
-    @AfterAll
-    static void tearDown() {
-        if (engine != null) engine.close();
-    }
-
-    // ─────────────── Registry Tests ───────────────
-
-    @Test
-    void shouldRegister6Tools() {
-        assertThat(specs).hasSize(6);
-    }
-
-    @Test
-    void shouldHaveCorrectToolNames() {
-        var names = specs.stream()
-                .map(t -> t.tool().name())
-                .toList();
-        assertThat(names).containsExactlyInAnyOrder(
-                "semantic_search",
-                "hybrid_search",
-                "rag_query",
-                "ingest_document",
-                "delete_document",
-                "engine_status"
-        );
-    }
-
-    @Test
-    void allToolsShouldHaveDescriptions() {
-        for (var spec : specs) {
-            assertThat(spec.tool().description())
-                    .as("Description for tool: %s", spec.tool().name())
-                    .isNotBlank();
-        }
-    }
-
-    @Test
-    void allToolsShouldHaveInputSchemas() {
-        for (var spec : specs) {
-            assertThat(spec.tool().inputSchema())
-                    .as("Input schema for tool: %s", spec.tool().name())
-                    .isNotNull()
-                    .containsKey("type");
-        }
-    }
-
-    // ─────────────── Tool Handler Tests ───────────────
-
-    @Test
-    void semanticSearchShouldReturnResults() {
-        var result = callTool("semantic_search",
-                Map.of("query", "vector search", "top_k", 3));
-
-        assertThat(result.isError()).isNotEqualTo(true);
-        assertText(result).contains("Found").contains("results");
-    }
-
-    @Test
-    void semanticSearchShouldRejectEmptyQuery() {
-        var result = callTool("semantic_search", Map.of("query", ""));
-        assertThat(result.isError()).isTrue();
-    }
-
-    @Test
-    void semanticSearchInvalidTopKShouldReturnStructuredError() {
-        var result = callTool("semantic_search",
-                Map.of("query", "vector search", "top_k", 0));
-
-        assertThat(result.isError()).isTrue();
-        assertText(result).contains("[SPE-100-005]");
-    }
-
-    @Test
-    void hybridSearchShouldWork() {
-        var result = callTool("hybrid_search",
-                Map.of("query", "machine learning", "top_k", 2, "mode", "hybrid"));
-
-        assertThat(result.isError()).isNotEqualTo(true);
-        assertThat(result.content()).isNotEmpty();
-    }
-
-    @Test
-    void hybridSearchKeywordModeShouldWork() {
-        var result = callTool("hybrid_search",
-                Map.of("query", "kubernetes", "mode", "keyword"));
-
-        assertThat(result.isError()).isNotEqualTo(true);
-    }
-
-    @Test
-    void ragQueryShouldReturnContext() {
-        var result = callTool("rag_query",
-                Map.of("query", "Panama SIMD", "top_k", 5));
-
-        assertThat(result.isError()).isNotEqualTo(true);
-        assertText(result).containsAnyOf("RETRIEVED CONTEXT", "No relevant context");
-    }
-
-    @Test
-    void ingestDocumentShouldAddDocument() {
-        int countBefore = engine.documentCount();
-        var result = callTool("ingest_document",
-                Map.of("id", "test-mcp-doc", "content", "Test document for MCP"));
-
-        assertThat(result.isError()).isNotEqualTo(true);
-        assertThat(engine.documentCount()).isEqualTo(countBefore + 1);
-        assertText(result).contains("ingested successfully");
-    }
-
-    @Test
-    void deleteDocumentShouldRemoveDocument() {
-        engine.ingest("to-delete", "Document to be deleted via MCP");
-
-        var result = callTool("delete_document", Map.of("id", "to-delete"));
-
-        assertThat(result.isError()).isNotEqualTo(true);
-        assertText(result).contains("deleted");
-    }
-
-    @Test
-    void deleteNonexistentDocumentShouldReportNotFound() {
-        var result = callTool("delete_document",
-                Map.of("id", "nonexistent-doc"));
-
-        assertThat(result.isError()).isNotEqualTo(true);
-        assertText(result).contains("not found");
-    }
-
-    @Test
-    void engineStatusShouldReturnInfo() {
-        var result = callTool("engine_status", Map.of());
-
-        assertThat(result.isError()).isNotEqualTo(true);
-        assertText(result)
-                .contains("Documents:")
-                .contains("Dimensions:")
-                .contains("Simd:");
-    }
-
-    // ─────────────── Schema Builder Tests ───────────────
-
-    @Test
-    void schemaBuilderShouldProduceValidSchema() {
-        var schema = ToolSchemaBuilder.object()
-                .requiredString("name", "The name")
-                .optionalInt("count", "Number of items", 10)
-                .optionalBoolean("verbose", "Verbose output", false)
-                .optionalEnum("format", "Output format", "json", "json", "text", "csv")
-                .build();
-
-        assertThat(schema).containsEntry("type", "object");
-        assertThat(schema).containsKey("properties");
-        assertThat(schema).containsKey("required");
-
-        @SuppressWarnings("unchecked")
-        var properties = (Map<String, Object>) schema.get("properties");
-        assertThat(properties).containsKeys("name", "count", "verbose", "format");
-
-        @SuppressWarnings("unchecked")
-        var required = (List<String>) schema.get("required");
-        assertThat(required).containsExactly("name");
-    }
-
-    @Test
-    void emptySchemaIsValid() {
-        var schema = ToolSchemaBuilder.empty();
-        assertThat(schema).containsEntry("type", "object");
-        assertThat(schema).containsKey("properties");
-    }
-
-    // ─────────────── Helpers ───────────────
-
-    /**
-     * Calls a tool by name via its registered spec.
-     */
-    private McpSchema.CallToolResult callTool(String toolName, Map<String, Object> arguments) {
-        var spec = specs.stream()
-                .filter(s -> s.tool().name().equals(toolName))
-                .findFirst()
-                .orElseThrow(() -> new AssertionError("Tool not found: " + toolName));
-
-        var request = new McpSchema.CallToolRequest(toolName, arguments);
-        return spec.callHandler().apply(null, request);
-    }
-
-    /**
-     * Extracts text content for assertion chaining.
-     */
-    private static org.assertj.core.api.AbstractStringAssert<?> assertText(
-            McpSchema.CallToolResult result) {
-        assertThat(result.content()).isNotEmpty();
-        String text = ((McpSchema.TextContent) result.content().getFirst()).text();
-        return assertThat(text);
-    }
-
-    /**
-     * Mock embedding provider for deterministic tests.
-     */
-    static class MockEmbeddingProvider implements EmbeddingProvider {
-        @Override
-        public EmbeddingResult embed(String text) {
-            float[] vec = new float[4];
-            int hash = text.hashCode();
-            for (int i = 0; i < 4; i++) {
-                vec[i] = ((hash >> (i * 8)) & 0xFF) / 255.0f;
-            }
-            float norm = 0;
-            for (float v : vec) norm += v * v;
-            norm = (float) Math.sqrt(norm);
-            if (norm > 0) {
-                for (int i = 0; i < vec.length; i++) vec[i] /= norm;
-            }
-            return new EmbeddingResult(vec, text.split("\\s+").length, "mock-embed");
-        }
-
-        @Override
-        public int dimensions() { return 4; }
-
-        @Override
-        public String modelName() { return "mock-embed"; }
-    }
-}
diff --git a/spector-memory/LICENSE b/spector-memory/LICENSE
deleted file mode 100644
index 9644bdf..0000000
--- a/spector-memory/LICENSE
+++ /dev/null
@@ -1,55 +0,0 @@
-Business Source License 1.1
-
-Parameters
-
-Licensor:             Spectrayan
-Licensed Work:        Spector Memory (including all source code and documentation under the spector-memory directory and its subdirectories)
-Additional Use Grant: You may make any use of the Licensed Work, except that you may not offer the Licensed Work as a managed service, or embed or integrate the Licensed Work into a competing AI cognitive memory product or service.
-Change Date:          May 27, 2030
-Change License:       Apache License, Version 2.0
-
-License Text
-
-License text copyright © 2017 MariaDB Corporation Ab, All Rights Reserved.
-"Business Source License" is a trademark of MariaDB Corporation Ab.
-
-Terms
-
-The Licensor hereby grants you the right to copy, modify, create derivative
-works, redistribute, and make non-production use of the Licensed Work. The
-Licensor may make an Additional Use Grant, above, permitting limited
-production use.
-
-Effective on the Change Date, or the fourth anniversary of the first publicly
-available distribution of a specific version of the Licensed Work under this
-License, whichever comes first, the Licensor hereby grants you rights under
-the terms of the Change License, and the rights granted in the paragraph
-above terminate.
-
-If your use of the Licensed Work does not comply with the requirements
-currently in effect as described in this License, you must purchase a
-commercial license from the Licensor, its affiliated entities, or authorized
-resellers, or you must refrain from using the Licensed Work.
-
-All copies of the original and modified Licensed Work, and derivative works
-of the Licensed Work, are subject to this License. This License applies
-separately for each version of the Licensed Work and the Change Date may vary
-for each version of the Licensed Work released by Licensor.
-
-You must conspicuously display this License on each original or modified copy
-of the Licensed Work. If you receive the Licensed Work in original or
-modified form from a third party, the terms and conditions set forth in
-this License apply to your use of that work.
-
-Any use of the Licensed Work in violation of this License will automatically
-terminate your rights under this License for the current and all other versions
-of the Licensed Work.
-
-This License does not grant you any right in any trademark or logo of Licensor
-or its affiliates (provided that you may use a trademark or logo of Licensor
-as expressly required by this License).
-
-TO THE EXTENT PERMITTED BY APPLICABLE LAW, THE LICENSED WORK IS PROVIDED ON
-AN “AS IS” BASIS. LICENSOR HEREBY DISCLAIMS ALL WARRANTIES AND CONDITIONS,
-EXPRESS OR IMPLIED, INCLUDING (WITHOUT LIMITATION) WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NON-INFRINGEMENT, AND TITLE.
diff --git a/spector-memory/README.md b/spector-memory/README.md
deleted file mode 100644
index 3d17981..0000000
--- a/spector-memory/README.md
+++ /dev/null
@@ -1,242 +0,0 @@
-# 🧠 Spector Memory
-
-> **The Cognitive Memory Engine for Autonomous AI Agents.**
->
-> A biologically-inspired, off-heap memory system that gives AI agents the ability to **remember**, **forget**, **consolidate**, and **associate** — with microsecond latency and zero garbage collection pressure. Built on Java Project Panama, SIMD-accelerated vector math, and Virtual Threads.
-
-[![Java](https://img.shields.io/badge/Java-25-orange.svg)](https://openjdk.org/)
-[![License](https://img.shields.io/badge/License-BSL%201.1-blue.svg)](LICENSE)
-[![Panama](https://img.shields.io/badge/Panama-Off--Heap-blueviolet.svg)](#)
-[![SIMD](https://img.shields.io/badge/SIMD-AVX2%2FAVX--512-green.svg)](#)
-[![Virtual Threads](https://img.shields.io/badge/Loom-Virtual_Threads-blue.svg)](#)
-
----
-
-## Why Cognitive Memory?
-
-Traditional vector databases treat memories as static documents in a flat index. Real cognition is fundamentally different:
-
-| Traditional Vector DB | Spector Memory |
-|---|---|
-| Flat document store | **4-tier cognitive architecture** (Working → Episodic → Semantic → Procedural) |
-| Static similarity search | **Fused scoring** — similarity × importance × temporal decay in a single SIMD pass |
-| No temporal awareness | **Reconsolidation** — frequently recalled memories resist forgetting |
-| No emotional context | **Valence tracking** — memories carry emotional coloring |
-| No contextual gating | **Synaptic tags** — 64-bit Bloom filter eliminates 99% of candidates in 1 CPU cycle |
-| Python + network hops | **Zero-GC, off-heap Panama** — microsecond latency, no serialization |
-
----
-
-## Architecture
-
-```
-spector-memory/
-├── SpectorMemory.java              ← Façade (Builder pattern entry point)
-├── pipeline/                       ← "Neural Pathways" — ingestion + recall pipelines
-│     ├── IngestionPipeline.java        (10-step remember pipeline)
-│     ├── RecallPipeline.java           (parallel tier scanning + scoring)
-│     └── HebbianCoActivationListener   (Observer pattern post-recall)
-│
-├── cortex/                         ← "Cerebral Cortex" — 4 tier stores
-│     ├── TierStore.java                (Strategy interface)
-│     ├── TierRouter.java               (Registry + polymorphic dispatch)
-│     ├── WorkingMemoryStore.java       (Prefrontal Cortex — volatile circular buffer)
-│     ├── EpisodicMemoryStore.java      (Hippocampus — time-partitioned mmap)
-│     ├── SemanticMemoryStore.java      (Neocortex — permanent knowledge)
-│     └── ProceduralMemoryStore.java    (Basal Ganglia — learned procedures)
-│
-├── synapse/                        ← "Synaptic Machinery" — header layout + scoring
-│     ├── CognitiveRecordLayout.java    (32-byte aligned synaptic header)
-│     ├── CognitiveScorer.java          (6-phase fused scoring hot-loop)
-│     ├── SynapticTagEncoder.java       (64-bit inline Bloom filter)
-│     ├── SynapticHeaderConstants.java  (offsets, masks, field sizes)
-│     └── DecayStrategy.java            (SIMD-friendly temporal decay)
-│
-├── dopamine/                       ← "Dopamine System" — surprise & importance
-│     ├── SurpriseDetector.java         (Welford online statistics + Z-score)
-│     ├── FlashbulbPolicy.java          (extreme surprise → pinned memory)
-│     └── WelfordStats.java             (running mean/variance tracker)
-│
-├── amygdala/                       ← "Amygdala" — emotional valence
-│     └── ValenceTracker.java           (emotional coloring of memories)
-│
-├── hebbian/                        ← "Hebbian Learning" — associations
-│     ├── CoActivationTracker.java      (tag co-occurrence tracking)
-│     └── HebbianGraph.java             (associative memory network)
-│
-├── hippocampus/                    ← "Hippocampus" — consolidation & cleanup
-│     ├── ReflectDaemon.java            (sleep consolidation K-Means)
-│     └── TombstoneCompactor.java       (partition rebuild)
-│
-├── habituation/                    ← "Habituation" — anti-filter bubble
-│     └── HabituationPenalty.java       (frequency-based score decay)
-│
-├── inhibition/                     ← "Inhibition" — suppression
-│     └── SuppressionSet.java           (explicit memory blocking)
-│
-├── interference/                   ← "Proactive Interference" — deduplication
-│     └── SemanticDeduplicator.java     (near-duplicate detection + merge)
-│
-├── prospective/                    ← "Prospective Memory" — future intents
-│     ├── ProspectiveScheduler.java     (time-triggered reminders)
-│     └── Reminder.java                 (scheduled memory record)
-│
-├── metamemory/                     ← "Metamemory" — self-reflection
-│     └── MemoryIntrospector.java       (memory health stats & analytics)
-│
-├── index/                          ← O(1) reverse index
-│     └── MemoryIndex.java              (ConcurrentHashMap forward + reverse)
-│
-└── sync/                           ← Persistence & replication
-      ├── MemoryWal.java                (Write-Ahead Log)
-      └── CrdtMergeStrategy.java        (CRDT merge for distributed sync)
-```
-
-### Biological System → Package Mapping
-
-| Brain Region | Package | Java Classes | Function |
-|---|---|---|---|
-| 🧠 Cerebral Cortex | `cortex/` | `TierRouter`, `TierStore`, 4 stores | 4-tier memory storage (Working → Episodic → Semantic → Procedural) |
-| 🔗 Synapses | `synapse/` | `CognitiveScorer`, `SynapticTagEncoder`, `CognitiveRecordLayout` | 32-byte header, 6-phase scoring, Bloom filter gating |
-| ⚡ Dopamine System | `dopamine/` | `SurpriseDetector`, `FlashbulbPolicy` | Surprise detection, auto-importance, flashbulb pinning |
-| 😱 Amygdala | `amygdala/` | `ValenceTracker` | Emotional coloring (positive/negative/neutral) |
-| 🔄 Hebbian Learning | `hebbian/` | `CoActivationTracker`, `HebbianGraph` | "Neurons that fire together wire together" |
-| 🛏️ Hippocampus | `hippocampus/` | `ReflectDaemon`, `TombstoneCompactor` | Sleep consolidation, synaptic pruning, partition rebuild |
-| 😴 Habituation | `habituation/` | `HabituationPenalty` | Anti-filter bubble — penalizes repetitive recall |
-| 🚫 Inhibition | `inhibition/` | `SuppressionSet` | Explicit memory suppression (user redaction) |
-| 🔮 Prospective Memory | `prospective/` | `ProspectiveScheduler`, `Reminder` | Future-oriented intent reminders |
-| 🪞 Metamemory | `metamemory/` | `MemoryIntrospector` | Self-reflective memory health analytics |
-
----
-
-## Quick Start
-
-```java
-// 1. Create a cognitive memory with Ollama embeddings
-SpectorMemory memory = SpectorMemory.builder()
-    .dimensions(4096)
-    .embeddingProvider(OllamaEmbeddingProvider.create("qwen3-embedding"))
-    .workingCapacity(100)
-    .episodicPartitionCapacity(10_000)
-    .semanticCapacity(5_000)
-    .proceduralCapacity(500)
-    .build();
-
-// 2. Remember — 10-step ingestion pipeline
-memory.remember("pref-dark-mode",
-    "The user strongly prefers dark mode for all IDE editors.",
-    MemoryType.EPISODIC, MemorySource.USER_STATED,
-    "ui", "preferences", "coding");
-
-// 3. Recall — parallel SIMD-accelerated search with cognitive scoring
-List<CognitiveResult> results = memory.recall("dark theme settings",
-    RecallOptions.builder()
-        .topK(5)
-        .synapticFilter("preferences")    // Bloom filter pre-screen
-        .minImportance(0.3f)              // Skip low-importance memories
-        .build());
-
-for (CognitiveResult r : results) {
-    System.out.printf("%.4f [%s] %s%n", r.score(), r.memoryType(), r.text());
-}
-
-// 4. Forget — tombstone a memory
-memory.forget("pref-dark-mode");
-
-// 5. Suppress — temporarily hide from recall
-memory.suppress("noisy-memory-id", "Not relevant right now");
-
-// 6. Close — releases all off-heap memory
-memory.close();
-```
-
----
-
-## The 6-Phase Scoring Pipeline
-
-Every recall query executes a SIMD-optimized hot-loop that fuses **six** filtering and scoring phases into a single sequential scan. Each phase eliminates candidates before the expensive vector math:
-
-```
-Phase 1: Tombstone Check     (~1 cycle)    → Skip dead memories
-Phase 2: Synaptic Tag Gating (~1 cycle)    → Bloom filter eliminates 99% of irrelevant
-Phase 3: Valence Filter      (~2 cycles)   → Emotional range filtering
-Phase 4: Importance/Decay    (~5 cycles)   → Skip old + low-importance
-Phase 5: SIMD L2 Distance   (~200 cycles)  → Quantized INT8 Euclidean via Vector API
-Phase 6: Fused Score         (~7 cycles)   → α·similarity + β·importance·decay
-```
-
-**The math:**
-If an agent has 1,000,000 episodic memories but only 10,000 match the active synaptic tags:
-- Phases 1-4 eliminate 990,000 memories in ~990µs (cheap header reads)
-- Phase 5 computes SIMD distance on only ~10,000 candidates
-- **Total: ~0.13ms for 1M memories vs ~200ms without gating (1,500× improvement)**
-
----
-
-## Performance
-
-Benchmarked on Intel Core Ultra 9 285K, Java 25, AVX2 256-bit:
-
-| Benchmark | Result |
-|---|---|
-| **SIMD L2 Distance (768-dim)** | 2.2 µs/vector (1.4M vectors/sec) |
-| **SIMD L2 Distance (128-dim)** | 0.8 µs/vector (1.2M vectors/sec) |
-| **Reverse Index Lookup** | 180 ns/lookup (O(1) via ConcurrentHashMap) |
-| **CognitiveScorer (10K × 128-dim)** | 2.9 ms total |
-| **Batch Habituation (1K IDs)** | 101 µs total |
-| **Full Pipeline (1K ingest + 100 recall)** | < 50 ms/query |
-| **Real Embedding (qwen3-embedding 4096-dim)** | 31 ms/embed via Ollama |
-
-### Test Suite
-
-```
-spector-core:   276 tests ✅  (includes 15 SIMD kernel tests)
-spector-memory: 167 tests ✅  (includes 33 perf + index tests)
-                + 10 Ollama real embedding E2E tests (gated by OLLAMA_LIVE=true)
-Total: 443 tests, 0 failures
-```
-
----
-
-## Competitive Landscape
-
-| Feature | Spector Memory | Mem0 | Letta (MemGPT) | Zep |
-|---|---|---|---|---|
-| Language | **Java 25** | Python | Python | Go/Python |
-| Storage | **Off-heap Panama** | Postgres/pgvector | Postgres/Chroma | Postgres |
-| Latency | **0.13ms (1M memories)** | ~50-200ms | ~100-500ms | ~20-100ms |
-| GC Pressure | **Zero** | Python GC | Python GC | Go GC |
-| Temporal Decay | **Fused SIMD** | Post-filter | Post-filter | Post-filter |
-| Emotional Valence | **✅ Built-in** | ❌ | ❌ | ❌ |
-| Synaptic Tag Gating | **✅ 1-cycle Bloom** | ❌ | ❌ | ❌ |
-| Sleep Consolidation | **✅ K-Means** | ❌ | ❌ | ❌ |
-| Surprise Detection | **✅ Welford Z-score** | ❌ | ❌ | ❌ |
-| Habituation | **✅ Anti-filter bubble** | ❌ | ❌ | ❌ |
-| MCP Integration | **✅ Native** | ❌ | ❌ | ❌ |
-
----
-
-## Documentation
-
-📖 **Full documentation**: See the [Cognitive Memory Guide](../docs/docs/memory/index.md) for:
-
-- [System Architecture](../docs/docs/memory/architecture.md) — package hierarchy, data flow, design patterns
-- [6-Phase Scoring Pipeline](../docs/docs/memory/scoring-pipeline.md) — deep dive with math and cycle counts
-- [Biological Systems](../docs/docs/memory/cortex.md) — each brain region mapped to code
-- [Performance & SIMD](../docs/docs/memory/performance.md) — benchmarks, optimization techniques
-- [Off-Heap Panama Design](../docs/docs/memory/panama-design.md) — zero-GC architecture
-- [API Reference](../docs/docs/memory/api-reference.md) — full method signatures
-
----
-
-## License
-
-This module is licensed under the **Business Source License 1.1 (BSL 1.1)**.
-
-- Permits free use for non-production purposes.
-- Permits production use for all purposes **except** offering it as a managed service or embedding/integrating it in a competing AI cognitive memory product or service.
-- Automatically transitions to the **Apache License 2.0** on **May 27, 2030** (4 years from release).
-
-See the [LICENSE](LICENSE) file for the full terms and conditions.
-
-**Built with ⚡ by [Spectrayan](https://www.spectrayan.com/)**
diff --git a/spector-memory/pom.xml b/spector-memory/pom.xml
deleted file mode 100644
index a1899cb..0000000
--- a/spector-memory/pom.xml
+++ /dev/null
@@ -1,100 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0"
-         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
-    <modelVersion>4.0.0</modelVersion>
-
-    <parent>
-        <groupId>com.spectrayan</groupId>
-        <artifactId>spector</artifactId>
-        <version>0.1.0-SNAPSHOT</version>
-    </parent>
-
-    <artifactId>spector-memory</artifactId>
-    <name>Spector Memory</name>
-    <description>
-        Biologically-inspired cognitive memory for autonomous AI agents.
-        16 neuroscience mechanisms — from dopamine-driven surprise detection to
-        hippocampal sleep consolidation — running natively on Java Panama with
-        zero-GC, SIMD-accelerated off-heap storage.
-    </description>
-
-    <dependencies>
-        <!-- ── Internal modules ── -->
-        <dependency>
-            <groupId>com.spectrayan</groupId>
-            <artifactId>spector-core</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>com.spectrayan</groupId>
-            <artifactId>spector-storage</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>com.spectrayan</groupId>
-            <artifactId>spector-index</artifactId>
-        </dependency>
-
-        <dependency>
-            <groupId>com.spectrayan</groupId>
-            <artifactId>spector-embed-api</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>com.spectrayan</groupId>
-            <artifactId>spector-commons</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>com.spectrayan</groupId>
-            <artifactId>spector-ingestion</artifactId>
-        </dependency>
-
-        <!-- ── Logging ── -->
-        <dependency>
-            <groupId>org.slf4j</groupId>
-            <artifactId>slf4j-api</artifactId>
-        </dependency>
-
-        <!-- ── Test ── -->
-        <dependency>
-            <groupId>org.junit.jupiter</groupId>
-            <artifactId>junit-jupiter</artifactId>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>org.assertj</groupId>
-            <artifactId>assertj-core</artifactId>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>ch.qos.logback</groupId>
-            <artifactId>logback-classic</artifactId>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>com.spectrayan</groupId>
-            <artifactId>spector-embed-ollama</artifactId>
-            <scope>test</scope>
-        </dependency>
-    </dependencies>
-
-    <build>
-        <plugins>
-            <!-- Override: BSL 1.1 header for this module -->
-            <plugin>
-                <groupId>com.mycila</groupId>
-                <artifactId>license-maven-plugin</artifactId>
-                <configuration>
-                    <licenseSets>
-                        <licenseSet>
-                            <header>src/license/bsl-header.txt</header>
-                            <includes>
-                                <include>src/main/java/**/*.java</include>
-                                <include>src/test/java/**/*.java</include>
-                            </includes>
-                        </licenseSet>
-                    </licenseSets>
-                </configuration>
-            </plugin>
-        </plugins>
-    </build>
-
-</project>
diff --git a/spector-memory/src/license/bsl-header.txt b/spector-memory/src/license/bsl-header.txt
deleted file mode 100644
index c9f04c1..0000000
--- a/spector-memory/src/license/bsl-header.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-Copyright ${year} Spectrayan
-
-Licensed under the Business Source License 1.1 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
-
-Change Date: May 27, 2030
-Change License: Apache License, Version 2.0
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/CognitiveProfile.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/CognitiveProfile.java
deleted file mode 100644
index 5da0e76..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/CognitiveProfile.java
+++ /dev/null
@@ -1,315 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory;
-
-/**
- * Preset cognitive scoring profiles for thalamic modulation.
- *
- * <h3>Biological Analog: Thalamic Gating</h3>
- * <p>The thalamus modulates which sensory information reaches the cortex based on
- * the brain's current cognitive state. During focused debugging, the thalamus
- * amplifies error-related signals and suppresses unrelated memories. During
- * creative brainstorming, it broadens the gate to allow more associative
- * connections.</p>
- *
- * <h3>Usage</h3>
- * <p>Profiles preset the {@code alpha} (similarity weight), {@code beta}
- * (importance × decay weight), and valence range so the agent doesn't need
- * to manually tune these parameters:</p>
- * <pre>
- *   // Explicit profile
- *   memory.recall("database error", CognitiveProfile.DEBUGGING);
- *
- *   // Profile with overrides
- *   RecallOptions opts = RecallOptions.builder()
- *       .profile(CognitiveProfile.EXPLORING)
- *       .topK(20)   // override just topK, keep profile's alpha/beta
- *       .build();
- * </pre>
- *
- * <h3>Auto-Detection</h3>
- * <p>Use {@link #detect(String...)} to automatically select a profile based on
- * synaptic tags. Tags containing error-related keywords trigger {@code DEBUGGING},
- * positive keywords trigger {@code RECALLING}, etc.</p>
- */
-public enum CognitiveProfile {
-
-    /**
-     * Balanced scoring — equal weight to similarity and importance.
-     * Default profile for general-purpose recall.
-     */
-    BALANCED(0.6f, 0.4f, Byte.MIN_VALUE, Byte.MAX_VALUE),
-
-    /**
-     * Exploration mode — similarity-dominated scoring for creative, associative recall.
-     * Finds memories that are semantically close to the query, regardless of age or importance.
-     * Use when brainstorming, exploring new ideas, or looking for tangential connections.
-     */
-    EXPLORING(0.8f, 0.2f, Byte.MIN_VALUE, Byte.MAX_VALUE),
-
-    /**
-     * Debugging mode — importance-dominated scoring, biased toward negative valence.
-     * Surfaces recent errors, bugs, and failures. Deprioritizes old successes.
-     * Use when investigating bugs, crashes, or production issues.
-     */
-    DEBUGGING(0.3f, 0.7f, Byte.MIN_VALUE, (byte) -10),
-
-    /**
-     * Recalling mode — importance-dominated, biased toward positive valence.
-     * Surfaces proven solutions and past successes. Filters out negative outcomes.
-     * Use when looking for known-good patterns, templates, or prior art.
-     */
-    RECALLING(0.4f, 0.6f, (byte) 10, Byte.MAX_VALUE),
-
-    /**
-     * Critical mode — heavily importance-dominated, full valence range.
-     * Surfaces the most important memories regardless of similarity.
-     * Use for high-stakes decisions where correctness matters more than relevance.
-     */
-    CRITICAL(0.2f, 0.8f, Byte.MIN_VALUE, Byte.MAX_VALUE),
-
-    // ══ Neurodivergent Profiles ══
-
-    /**
-     * Hyperfocus mode — pure similarity scoring, zero time decay.
-     *
-     * <p>Biological analog: Monotropism. The neurodivergent brain focuses all
-     * attention on a narrow topic with absolute depth. Time ceases to exist
-     * for the focused topic — a 3-month-old memory scores as if fresh.</p>
-     *
-     * <p>Must be combined with a {@code hyperfocusMask} in RecallOptions to be
-     * effective. Without a mask, behaves like EXPLORING.</p>
-     *
-     * <p>Scoring: α=1.0 (pure similarity), β=0.0 (no importance×decay).
-     * Decay is clamped to 1.0 for focus-matched memories.
-     * Post-score hyperfocusBoost=1.5 applied after normalized base score.</p>
-     */
-    HYPERFOCUS(1.0f, 0.0f, Byte.MIN_VALUE, Byte.MAX_VALUE),
-
-    /**
-     * Systematizer mode — importance-dominated, lossless consolidation.
-     *
-     * <p>Biological analog: Bottom-up processing. The autistic brain absorbs massive
-     * amounts of raw, unfiltered details, meticulously holding them until a perfect
-     * systemic pattern emerges. Source episodes are pinned during consolidation
-     * instead of being eligible for pruning.</p>
-     *
-     * <p>Great for Senior AI Software Engineers, medical diagnosis, log analysis,
-     * and deep-research agents that need encyclopedic detail retention.</p>
-     */
-    SYSTEMATIZER(0.3f, 0.7f, Byte.MIN_VALUE, Byte.MAX_VALUE),
-
-    /**
-     * Divergent thinking mode — enables lateral/orthogonal retrieval.
-     *
-     * <p>Biological analog: Reduced Latent Inhibition. The ADHD brain processes
-     * peripheral data that neurotypical brains filter out, causing thoughts to
-     * jump between seemingly unrelated concepts based on shared structural tags.
-     * This is the engine of cross-disciplinary innovation.</p>
-     *
-     * <p>Enables {@code lateralMode} with default thresholds. Lateral candidates
-     * are tag-matched but semantically distant — blended with standard results.</p>
-     */
-    DIVERGENT(0.8f, 0.2f, Byte.MIN_VALUE, Byte.MAX_VALUE),
-
-    // ══ Enhanced Profiles (feature-flagged for licensing) ══
-
-    /**
-     * Paranoid Sentinel mode — SRE / Cyber Auditor.
-     *
-     * <p>Biological analog: Threat-detection circuitry in the amygdala.
-     * Only surfaces memories associated with negative outcomes (errors,
-     * failures, security incidents). Uses valence alignment to amplify
-     * mood-congruent threat recall.</p>
-     *
-     * <p>Scoring: α=0.2 (minimal similarity), β=0.8 (importance-dominated),
-     * valence range [-128, -1] (only negative memories).
-     * Valence alignment set to queryValence=-128 (maximum threat).</p>
-     *
-     * <p><b>Note:</b> This profile is functionally equivalent to the proposed
-     * "Anxious / Hyper-vigilant" cognitive profile from neuroscience literature.
-     * Threat-association weighting, negative valence bias, and amygdala modulation
-     * are all implemented via the valence range and alignment parameters.
-     * Users seeking "Anxious" or "Hyper-vigilant" behavior should use this profile.</p>
-     */
-    PARANOID_SENTINEL(0.2f, 0.8f, Byte.MIN_VALUE, (byte) -1),
-
-    /**
-     * The Executor mode — Devin-style agentic task runner.
-     *
-     * <p>Biological analog: Prefrontal cortex in "executive function" mode.
-     * Strict matching via Heaviside Cliff (only near-exact matches surface).
-     * Lateral retrieval is disabled to prevent tangential exploration.
-     * Combined with Zeigarnik Effect for task tracking.</p>
-     *
-     * <p>Scoring: α=0.3 (moderate similarity), β=0.7 (importance-dominated),
-     * strictnessCoefficient=10.0 (cliff function).</p>
-     */
-    THE_EXECUTOR(0.3f, 0.7f, Byte.MIN_VALUE, Byte.MAX_VALUE),
-
-    /**
-     * Highly Sensitive mode — Sensory Processing Sensitivity.
-     *
-     * <p>Biological analog: Enhanced sensory processing depth. The highly
-     * sensitive brain processes stimuli more deeply, captures finer details,
-     * and has a lower threshold for emotional activation. Memories are
-     * ingested at a lower flashbulb threshold and retained with stronger
-     * lateral inhibition to prevent interference.</p>
-     *
-     * <p>Scoring: α=0.7 (similarity-leaning), β=0.3 (importance secondary).
-     * Overrides: flashbulbThreshold=2.0 (lower than default 3.0),
-     * inhibitionFloor=0.3 (stronger than default).</p>
-     *
-     * <p>Users who previously tuned flashbulbThreshold and inhibition parameters
-     * manually can use this profile instead for a curated experience.</p>
-     */
-    HIGHLY_SENSITIVE(0.7f, 0.3f, Byte.MIN_VALUE, Byte.MAX_VALUE),
-
-    /**
-     * Default Mode Network — "Shower Thoughts" / mind-wandering.
-     *
-     * <p>Biological analog: The brain's default mode network activates during
-     * rest, surfacing deep, consolidated knowledge from long-term memory.
-     * Skips Working and Episodic tiers to focus on Semantic and Procedural
-     * memories.</p>
-     *
-     * <p>Scoring: α=0.2 (low similarity), β=0.8 (importance-dominated).
-     * memoryTypes restricted to SEMANTIC + PROCEDURAL.</p>
-     */
-    DEFAULT_MODE_NETWORK(0.2f, 0.8f, Byte.MIN_VALUE, Byte.MAX_VALUE);
-
-    private final float alpha;
-    private final float beta;
-    private final byte minValence;
-    private final byte maxValence;
-
-    CognitiveProfile(float alpha, float beta, byte minValence, byte maxValence) {
-        this.alpha = alpha;
-        this.beta = beta;
-        this.minValence = minValence;
-        this.maxValence = maxValence;
-    }
-
-    /** Similarity weight (higher = more similarity-driven). */
-    public float alpha() { return alpha; }
-
-    /** Importance × decay weight (higher = more importance-driven). */
-    public float beta() { return beta; }
-
-    /** Minimum valence filter. */
-    public byte minValence() { return minValence; }
-
-    /** Maximum valence filter. */
-    public byte maxValence() { return maxValence; }
-
-    /**
-     * Applies this profile's settings to a {@link RecallOptions.Builder}.
-     *
-     * <p>Sets alpha, beta, minValence, and maxValence. The caller can override
-     * individual fields after applying the profile:</p>
-     * <pre>
-     *   RecallOptions opts = RecallOptions.builder()
-     *       .profile(CognitiveProfile.DEBUGGING)
-     *       .topK(20)  // profile sets alpha/beta/valence; topK is independent
-     *       .build();
-     * </pre>
-     *
-     * @param builder the builder to configure
-     * @return the same builder for chaining
-     */
-    public RecallOptions.Builder applyTo(RecallOptions.Builder builder) {
-        builder.alpha(alpha)
-               .beta(beta)
-               .minValence(minValence)
-               .maxValence(maxValence);
-
-        // Neurodivergent profile-specific overrides
-        return switch (this) {
-            case HYPERFOCUS -> builder.hyperfocusBoost(1.5f);
-            case SYSTEMATIZER -> builder.strictnessCoefficient(10.0f);
-            case DIVERGENT  -> builder.lateralMode(true);
-            case PARANOID_SENTINEL -> builder.queryValence(Byte.MIN_VALUE)
-                                            .enableValenceAlignment(true);
-            case THE_EXECUTOR -> builder.lateralMode(false)
-                                        .strictnessCoefficient(10.0f);
-            case HIGHLY_SENSITIVE -> builder.minImportance(0.01f);
-            case DEFAULT_MODE_NETWORK -> builder.memoryTypes(
-                    MemoryType.SEMANTIC, MemoryType.PROCEDURAL);
-            default         -> builder;
-        };
-    }
-
-    /**
-     * Whether this profile pins source episodes during consolidation
-     * (lossless consolidation mode).
-     *
-     * @return true for SYSTEMATIZER, false for all others
-     */
-    public boolean pinSourceEpisodes() {
-        return this == SYSTEMATIZER;
-    }
-
-    // ══════════════════════════════════════════════════════════════
-    // AUTO-DETECTION — select profile from synaptic tags
-    // ══════════════════════════════════════════════════════════════
-
-    /** Keywords that trigger DEBUGGING profile. */
-    private static final String[] DEBUG_KEYWORDS = {
-            "error", "bug", "crash", "fail", "exception", "timeout", "broken", "fix"
-    };
-
-    /** Keywords that trigger RECALLING profile. */
-    private static final String[] RECALL_KEYWORDS = {
-            "solution", "success", "working", "resolved", "pattern", "template", "best-practice"
-    };
-
-    /** Keywords that trigger CRITICAL profile. */
-    private static final String[] CRITICAL_KEYWORDS = {
-            "critical", "urgent", "security", "production", "outage", "data-loss"
-    };
-
-    /**
-     * Auto-detects the most appropriate cognitive profile from synaptic tags.
-     *
-     * <p>Scans tags for keyword matches. If multiple profiles match, the most
-     * specific one wins (CRITICAL > DEBUGGING > RECALLING > BALANCED).</p>
-     *
-     * @param tags synaptic tag strings from the query
-     * @return the detected profile, or {@link #BALANCED} if no keywords match
-     */
-    public static CognitiveProfile detect(String... tags) {
-        if (tags == null || tags.length == 0) return BALANCED;
-
-        boolean hasCritical = false, hasDebug = false, hasRecall = false;
-
-        for (String tag : tags) {
-            if (tag == null) continue;
-            String lower = tag.toLowerCase();
-            for (String kw : CRITICAL_KEYWORDS) {
-                if (lower.contains(kw)) { hasCritical = true; break; }
-            }
-            for (String kw : DEBUG_KEYWORDS) {
-                if (lower.contains(kw)) { hasDebug = true; break; }
-            }
-            for (String kw : RECALL_KEYWORDS) {
-                if (lower.contains(kw)) { hasRecall = true; break; }
-            }
-        }
-
-        // Priority: CRITICAL > DEBUGGING > RECALLING > BALANCED
-        if (hasCritical) return CRITICAL;
-        if (hasDebug) return DEBUGGING;
-        if (hasRecall) return RECALLING;
-        return BALANCED;
-    }
-}
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/CognitiveProfileConfig.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/CognitiveProfileConfig.java
deleted file mode 100644
index 995f60e..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/CognitiveProfileConfig.java
+++ /dev/null
@@ -1,232 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory;
-
-import java.util.Collections;
-import java.util.EnumSet;
-import java.util.Set;
-
-/**
- * Runtime configuration for enabling/disabling cognitive profiles.
- *
- * <h3>Design Philosophy</h3>
- * <p>This is an <b>operational configuration</b>, not a licensing gate.
- * Spector is distributed under the Business Source License (BSL 1.1) —
- * commercial use restrictions are enforced by the license itself, not by
- * code-level feature gates that any user with the source can bypass.</p>
- *
- * <h3>Why Configuration, Not Licensing?</h3>
- * <ul>
- *   <li>BSL handles commercial restriction — code-level gates are security theater</li>
- *   <li>Users may want to disable profiles for safety, compliance, or resource reasons</li>
- *   <li>SaaS/cloud deployments can configure available profiles per-tenant</li>
- *   <li>Self-hosted users get full functionality — the BSL license governs their usage</li>
- * </ul>
- *
- * <h3>Usage</h3>
- * <pre>{@code
- *   // Default: all profiles enabled
- *   var config = CognitiveProfileConfig.allEnabled();
- *
- *   // Operational restriction: only allow specific profiles
- *   var config = CognitiveProfileConfig.only(
- *       CognitiveProfile.BALANCED,
- *       CognitiveProfile.DEBUGGING,
- *       CognitiveProfile.HYPERFOCUS);
- *
- *   // Validate before use
- *   CognitiveProfile profile = config.validate(CognitiveProfile.HYPERFOCUS); // → HYPERFOCUS
- *   CognitiveProfile blocked = config.validate(CognitiveProfile.THE_EXECUTOR); // → BALANCED
- *
- *   // Strict mode: throws instead of falling back
- *   config.requireEnabled(CognitiveProfile.THE_EXECUTOR); // throws IllegalArgumentException
- * }</pre>
- *
- * <h3>Presets</h3>
- * <table>
- *   <tr><th>Preset</th><th>Profiles</th><th>Use Case</th></tr>
- *   <tr><td>{@link #allEnabled()}</td><td>All 11</td><td>Default / self-hosted</td></tr>
- *   <tr><td>{@link #coreOnly()}</td><td>5 core</td><td>Minimal / embedded</td></tr>
- *   <tr><td>{@link #withNeurodivergent()}</td><td>Core + 3 neuro</td><td>Research / creative</td></tr>
- *   <tr><td>{@link #only(CognitiveProfile...)}</td><td>Custom</td><td>SaaS tenant config</td></tr>
- * </table>
- */
-public final class CognitiveProfileConfig {
-
-    /** Core profiles: always safe, low resource impact. */
-    private static final Set<CognitiveProfile> CORE_PROFILES = EnumSet.of(
-            CognitiveProfile.BALANCED,
-            CognitiveProfile.EXPLORING,
-            CognitiveProfile.DEBUGGING,
-            CognitiveProfile.RECALLING,
-            CognitiveProfile.CRITICAL
-    );
-
-    /** Core + neurodivergent profiles. */
-    private static final Set<CognitiveProfile> NEURODIVERGENT_PROFILES;
-    static {
-        NEURODIVERGENT_PROFILES = EnumSet.copyOf(CORE_PROFILES);
-        NEURODIVERGENT_PROFILES.add(CognitiveProfile.HYPERFOCUS);
-        NEURODIVERGENT_PROFILES.add(CognitiveProfile.SYSTEMATIZER);
-        NEURODIVERGENT_PROFILES.add(CognitiveProfile.DIVERGENT);
-    }
-
-    /** All profiles. */
-    private static final Set<CognitiveProfile> ALL_PROFILES =
-            EnumSet.allOf(CognitiveProfile.class);
-
-    private final Set<CognitiveProfile> enabledProfiles;
-
-    private CognitiveProfileConfig(Set<CognitiveProfile> enabledProfiles) {
-        this.enabledProfiles = Collections.unmodifiableSet(EnumSet.copyOf(enabledProfiles));
-    }
-
-    // ── Validation ──
-
-    /**
-     * Validates a requested profile against the configuration.
-     * Returns the profile if enabled, or BALANCED as a safe fallback.
-     *
-     * <p>This is a <b>soft</b> validation — the caller gets a usable
-     * profile regardless. Use {@link #requireEnabled} for strict validation.</p>
-     */
-    public CognitiveProfile validate(CognitiveProfile requested) {
-        if (requested == null) return CognitiveProfile.BALANCED;
-        return enabledProfiles.contains(requested) ? requested : CognitiveProfile.BALANCED;
-    }
-
-    /**
-     * Strict validation — throws if the profile is not enabled.
-     *
-     * @throws IllegalArgumentException if the profile is disabled
-     */
-    public CognitiveProfile requireEnabled(CognitiveProfile requested) {
-        if (requested == null) {
-            throw new IllegalArgumentException("CognitiveProfile must not be null");
-        }
-        if (!enabledProfiles.contains(requested)) {
-            throw new IllegalArgumentException(
-                    "CognitiveProfile." + requested.name() + " is not enabled in this configuration. "
-                    + "Enabled profiles: " + enabledProfiles);
-        }
-        return requested;
-    }
-
-    /**
-     * Checks if a profile is enabled.
-     */
-    public boolean isEnabled(CognitiveProfile profile) {
-        return enabledProfiles.contains(profile);
-    }
-
-    /**
-     * Returns the set of all enabled profiles (unmodifiable).
-     */
-    public Set<CognitiveProfile> enabledProfiles() {
-        return enabledProfiles;
-    }
-
-    // ── Presets ──
-
-    /**
-     * All profiles enabled — the default for self-hosted deployments.
-     * BSL license governs commercial use, not this configuration.
-     */
-    public static CognitiveProfileConfig allEnabled() {
-        return new CognitiveProfileConfig(ALL_PROFILES);
-    }
-
-    /**
-     * Core profiles only — minimal resource footprint.
-     * Suitable for embedded or resource-constrained deployments.
-     */
-    public static CognitiveProfileConfig coreOnly() {
-        return new CognitiveProfileConfig(CORE_PROFILES);
-    }
-
-    /**
-     * Core + neurodivergent profiles.
-     * Suitable for research, creative, or development environments.
-     */
-    public static CognitiveProfileConfig withNeurodivergent() {
-        return new CognitiveProfileConfig(NEURODIVERGENT_PROFILES);
-    }
-
-    /**
-     * Custom configuration with specific profiles enabled.
-     * BALANCED is always included as the safe fallback.
-     *
-     * <p>Use for SaaS tenant configuration or operational restrictions:</p>
-     * <pre>{@code
-     *   var config = CognitiveProfileConfig.only(
-     *       CognitiveProfile.DEBUGGING,
-     *       CognitiveProfile.HYPERFOCUS);
-     * }</pre>
-     */
-    public static CognitiveProfileConfig only(CognitiveProfile... profiles) {
-        EnumSet<CognitiveProfile> set = EnumSet.of(CognitiveProfile.BALANCED);
-        for (CognitiveProfile p : profiles) {
-            if (p != null) set.add(p);
-        }
-        return new CognitiveProfileConfig(set);
-    }
-
-    /**
-     * Parses a configuration value from {@code spector-defaults.yml} (or overrides).
-     *
-     * <p>Supported values:</p>
-     * <ul>
-     *   <li>{@code "ALL"} — all profiles enabled (default)</li>
-     *   <li>{@code "CORE_ONLY"} — core 5 profiles</li>
-     *   <li>{@code "WITH_NEURODIVERGENT"} — core + neurodivergent profiles</li>
-     *   <li>Comma-separated list: {@code "BALANCED,DEBUGGING,HYPERFOCUS"}</li>
-     * </ul>
-     *
-     * <p>This is the bridge between the YAML config layer ({@code spector.memory.cognitive-profiles})
-     * and the runtime config object. Called during {@code DefaultSpectorMemory} initialization.</p>
-     *
-     * @param value the raw config string (null or blank defaults to ALL)
-     * @return the parsed config
-     */
-    public static CognitiveProfileConfig fromConfigValue(String value) {
-        if (value == null || value.isBlank()) return allEnabled();
-
-        return switch (value.strip().toUpperCase()) {
-            case "ALL" -> allEnabled();
-            case "CORE_ONLY" -> coreOnly();
-            case "WITH_NEURODIVERGENT" -> withNeurodivergent();
-            default -> parseProfileList(value);
-        };
-    }
-
-    private static CognitiveProfileConfig parseProfileList(String csv) {
-        EnumSet<CognitiveProfile> set = EnumSet.of(CognitiveProfile.BALANCED);
-        for (String token : csv.split(",")) {
-            String name = token.strip().toUpperCase();
-            if (name.isEmpty()) continue;
-            try {
-                set.add(CognitiveProfile.valueOf(name));
-            } catch (IllegalArgumentException e) {
-                throw new IllegalArgumentException(
-                        "Unknown cognitive profile in config: '" + token.strip()
-                        + "'. Valid profiles: " + java.util.Arrays.toString(CognitiveProfile.values()));
-            }
-        }
-        return new CognitiveProfileConfig(set);
-    }
-
-    @Override
-    public String toString() {
-        return "CognitiveProfileConfig{enabled=" + enabledProfiles + "}";
-    }
-}
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/CognitiveResult.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/CognitiveResult.java
deleted file mode 100644
index 54bd365..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/CognitiveResult.java
+++ /dev/null
@@ -1,123 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory;
-
-import com.spectrayan.spector.memory.cortex.MemorySource;
-
-/**
- * Immutable result record returned by {@link SpectorMemory#recall}.
- *
- * <p>Contains the memory text, cognitive scoring metadata, provenance information,
- * and biological state (recall count, valence, decay factor). Designed to give
- * the LLM maximum contextual grounding for reasoning about memory reliability.</p>
- *
- * @param id              unique memory identifier
- * @param text            the memory content text
- * @param score           final fused cognitive score (similarity × decay × importance)
- * @param importance      base importance weight (auto-set by Prediction Error engine)
- * @param ageDays         age of the memory in days
- * @param recallCount     number of times this memory has been recalled (LTP/reconsolidation)
- * @param valence         emotional valence (-128 to +127)
- * @param memoryType      cognitive memory tier (Working, Episodic, Semantic, Procedural)
- * @param source          provenance source (Observed, UserStated, Reflected, etc.)
- * @param synapticTags    decoded synaptic tag labels
- * @param decayFactor     raw decay multiplier (before reconsolidation adjustment)
- * @param ltpAdjustedDecay decay multiplier after reconsolidation adjustment
- * @param retrievalMode   how this result was retrieved (Standard, Lateral, Hyperfocus)
- */
-public record CognitiveResult(
-        String id,
-        String text,
-        float score,
-        float importance,
-        float ageDays,
-        int recallCount,
-        byte valence,
-        MemoryType memoryType,
-        MemorySource source,
-        String[] synapticTags,
-        float decayFactor,
-        float ltpAdjustedDecay,
-        RetrievalMode retrievalMode
-) {
-
-    /**
-     * How a memory was retrieved — enables the LLM to reason about result provenance.
-     *
-     * <h3>Neurodivergent Cognitive Profiles</h3>
-     * <ul>
-     *   <li>{@code STANDARD} — normal similarity-based retrieval</li>
-     *   <li>{@code LATERAL} — cross-domain retrieval via orthogonal tag matching
-     *       (divergent thinking / ADHD profile)</li>
-     *   <li>{@code HYPERFOCUS} — zero-decay retrieval for focus-matched memories
-     *       (monotropism / autistic profile)</li>
-     * </ul>
-     */
-    public enum RetrievalMode {
-        /** Standard similarity-based retrieval. */
-        STANDARD,
-        /** Lateral/orthogonal retrieval — tag-matched but semantically distant. */
-        LATERAL,
-        /** Hyperfocus retrieval — zero time decay, strict tag matching. */
-        HYPERFOCUS
-    }
-
-    /**
-     * Compact constructor — defaults retrievalMode to STANDARD when not specified.
-     */
-    public CognitiveResult(String id, String text, float score, float importance,
-                            float ageDays, int recallCount, byte valence,
-                            MemoryType memoryType, MemorySource source,
-                            String[] synapticTags, float decayFactor,
-                            float ltpAdjustedDecay) {
-        this(id, text, score, importance, ageDays, recallCount, valence,
-                memoryType, source, synapticTags, decayFactor, ltpAdjustedDecay,
-                RetrievalMode.STANDARD);
-    }
-
-    /**
-     * Returns the confidence weight based on source monitoring.
-     */
-    public float confidenceWeight() {
-        return source != null ? source.confidenceWeight() : 0.5f;
-    }
-
-    /**
-     * Returns true if this memory has been positively reinforced (valence > 10).
-     */
-    public boolean isPositivelyReinforced() {
-        return valence > 10;
-    }
-
-    /**
-     * Returns true if this memory is associated with a negative outcome (valence < -10).
-     */
-    public boolean isNegativeOutcome() {
-        return valence < -10;
-    }
-
-    /**
-     * Returns true if this result was retrieved via lateral/divergent retrieval.
-     */
-    public boolean isLateral() {
-        return retrievalMode == RetrievalMode.LATERAL;
-    }
-
-    /**
-     * Returns true if this result was retrieved via hyperfocus/zero-decay mode.
-     */
-    public boolean isHyperfocused() {
-        return retrievalMode == RetrievalMode.HYPERFOCUS;
-    }
-}
-
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/DefaultSpectorMemory.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/DefaultSpectorMemory.java
deleted file mode 100644
index a0050ed..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/DefaultSpectorMemory.java
+++ /dev/null
@@ -1,808 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory;
-
-import com.spectrayan.spector.commons.concurrent.ConcurrentTasks;
-import com.spectrayan.spector.commons.concurrent.ConcurrentExecutionException;
-import com.spectrayan.spector.core.quantization.ScalarQuantizer;
-import com.spectrayan.spector.embed.EmbeddingProvider;
-import com.spectrayan.spector.embed.TextGenerationProvider;
-import com.spectrayan.spector.memory.amygdala.ValenceTracker;
-import com.spectrayan.spector.memory.cortex.CentroidRouter;
-import com.spectrayan.spector.memory.cortex.EpisodicMemoryStore;
-import com.spectrayan.spector.memory.cortex.MemorySource;
-import com.spectrayan.spector.memory.cortex.ProceduralMemoryStore;
-import com.spectrayan.spector.memory.cortex.SemanticMemoryStore;
-import com.spectrayan.spector.memory.cortex.SemanticRecallStrategy;
-import com.spectrayan.spector.memory.cortex.TierRouter;
-import com.spectrayan.spector.memory.cortex.WorkingMemoryStore;
-import com.spectrayan.spector.memory.dopamine.FlashbulbPolicy;
-import com.spectrayan.spector.memory.dopamine.SurpriseDetector;
-import com.spectrayan.spector.memory.graph.EntityExtractionMode;
-import com.spectrayan.spector.memory.graph.EntityExtractor;
-import com.spectrayan.spector.memory.graph.EntityGraph;
-import com.spectrayan.spector.memory.graph.LlmEntityExtractor;
-import com.spectrayan.spector.memory.graph.NoOpEntityExtractor;
-import com.spectrayan.spector.memory.habituation.HabituationPenalty;
-import com.spectrayan.spector.memory.hebbian.CoActivationTracker;
-import com.spectrayan.spector.memory.hebbian.HebbianGraph;
-import com.spectrayan.spector.memory.hippocampus.CircadianPolicy;
-import com.spectrayan.spector.memory.hippocampus.ReflectDaemon;
-import com.spectrayan.spector.memory.index.MemoryIndex;
-import com.spectrayan.spector.memory.index.MemoryIndex.MemoryLocation;
-import com.spectrayan.spector.memory.inhibition.SuppressionSet;
-import com.spectrayan.spector.memory.interference.SemanticDeduplicator;
-import com.spectrayan.spector.memory.metamemory.MemoryInsight;
-import com.spectrayan.spector.memory.metamemory.MemoryIntrospector;
-import com.spectrayan.spector.memory.neurodivergent.IcnuWeights;
-import com.spectrayan.spector.memory.neurodivergent.LateralEvaluator;
-import com.spectrayan.spector.memory.pipeline.HebbianCoActivationListener;
-import com.spectrayan.spector.memory.pipeline.CognitiveIngestionTarget;
-import com.spectrayan.spector.memory.pipeline.LtpReconsolidationListener;
-import com.spectrayan.spector.memory.pipeline.RecallPipeline;
-import com.spectrayan.spector.memory.prospective.ProspectiveScheduler;
-import com.spectrayan.spector.memory.prospective.Reminder;
-import com.spectrayan.spector.memory.sync.MemoryWal;
-import com.spectrayan.spector.memory.sync.WalEvent;
-import com.spectrayan.spector.memory.synapse.CognitiveRecordLayout;
-import com.spectrayan.spector.memory.synapse.SynapticHeaderConstants;
-import com.spectrayan.spector.memory.temporal.TemporalChain;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.lang.foreign.MemorySegment;
-import java.nio.file.Path;
-import java.time.Duration;
-import java.time.Instant;
-import java.util.List;
-import java.util.Objects;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-import java.util.concurrent.atomic.AtomicInteger;
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-import com.spectrayan.spector.commons.error.SpectorServerException;
-import com.spectrayan.spector.commons.error.ErrorCode;
-
-import com.spectrayan.spector.memory.error.SpectorGraphDecayException;
-
-/**
- * Default implementation of {@link SpectorMemory} — the Zero-GC Cognitive Backbone for Autonomous Agents.
- *
- * <h3>Design Pattern: Façade</h3>
- * <p>{@code DefaultSpectorMemory} is a thin façade that composes 5 subsystems:</p>
- * <ul>
- *   <li>{@link com.spectrayan.spector.ingestion.IngestionPipeline} — 10-step ingest (embed → quantize → route → WAL)</li>
- *   <li>{@link RecallPipeline} — 8-step recall (embed → score → filter → sort)</li>
- *   <li>{@link TierRouter} — tier store registry (Working, Episodic, Semantic, Procedural)</li>
- *   <li>{@link MemoryIndex} — ID → metadata index (locations, text, tags, sources)</li>
- *   <li>{@link ReflectDaemon} — sleep consolidation (REM cycle, tombstone compaction)</li>
- * </ul>
- *
- * <h3>Example</h3>
- * <pre>{@code
- *   var memory = DefaultSpectorMemory.builder()
- *       .dimensions(768)
- *       .embeddingProvider(ollamaProvider)
- *       .persistence(Path.of("/data/agent-memory"))
- *       .build();
- *
- *   memory.remember("user-pref", "User prefers dark mode.",
- *       MemoryType.SEMANTIC, MemorySource.USER_STATED, "ui", "preferences").join();
- *
- *   List<CognitiveResult> results = memory.recall("what theme?",
- *       RecallOptions.builder().topK(5).synapticFilter("preferences").build());
- * }</pre>
- */
-public final class DefaultSpectorMemory implements SpectorMemory {
-
-    private static final Logger log = LoggerFactory.getLogger(DefaultSpectorMemory.class);
-
-    // ── Core Subsystems (Façade composition) ──
-    private final CognitiveIngestionTarget cognitiveTarget;
-    private final EmbeddingProvider embeddingProvider;
-    private final RecallPipeline recallPipeline;
-    private final TierRouter tierRouter;
-    private final MemoryIndex index;
-    private final ScalarQuantizer quantizer;
-
-    // ── Biological Subsystems ──
-    private final ValenceTracker valenceTracker;
-    private final ReflectDaemon reflectDaemon;
-    private final CoActivationTracker coActivationTracker;
-    private final SuppressionSet suppressionSet;
-    private final HabituationPenalty habituationPenalty;
-    private final ProspectiveScheduler prospectiveScheduler;
-    private final MemoryIntrospector introspector;
-    private final MemoryWal wal;
-    private final LateralEvaluator lateralEvaluator;
-
-    // ── 3-Layer Cognitive Graph ──
-    private final HebbianGraph hebbianGraph;
-    private final TemporalChain temporalChain;
-    private final EntityGraph entityGraph;
-
-    // ── Configuration ──
-    private final int dimensions;
-    private final MemoryPersistenceMode persistenceMode;
-    private final Path persistencePath;
-    private final CircadianPolicy circadianPolicy;
-    private final CognitiveProfileConfig profileConfig;
-    private final ExecutorService virtualExecutor;
-    private final AtomicInteger episodicIngestCount = new AtomicInteger(0);
-
-    private DefaultSpectorMemory(Builder builder) {
-        this.dimensions = builder.dimensions;
-        this.persistenceMode = builder.persistenceMode;
-        this.persistencePath = builder.persistencePath;
-        if (builder.embeddingProvider == null) { throw new SpectorValidationException(ErrorCode.ARGUMENT_NULL, "embeddingProvider is required"); } EmbeddingProvider embeddingProvider = builder.embeddingProvider;
-        this.circadianPolicy = builder.circadianPolicy;
-        this.profileConfig = builder.profileConfig;
-        this.virtualExecutor = Executors.newVirtualThreadPerTaskExecutor();
-
-        boolean isDisk = persistenceMode == MemoryPersistenceMode.DISK;
-
-        // Resolve persistence path for DISK mode
-        Path basePath;
-        if (isDisk && builder.persistencePath != null) {
-            basePath = builder.persistencePath;
-        } else if (isDisk) {
-            basePath = Path.of(System.getProperty("java.io.tmpdir"),
-                    "spector-memory-" + ProcessHandle.current().pid());
-            log.warn("DISK persistence mode with no explicit path — using temp directory: {}", basePath);
-        } else {
-            basePath = null;
-        }
-
-        // ── Quantization calibration ──
-        if (builder.quantizer != null) {
-            this.quantizer = builder.quantizer;
-        } else {
-            float[] defaultMins = new float[dimensions];
-            float[] defaultMaxs = new float[dimensions];
-            java.util.Arrays.fill(defaultMins, -1.0f);
-            java.util.Arrays.fill(defaultMaxs, 1.0f);
-            this.quantizer = ScalarQuantizer.fromBounds(dimensions, defaultMins, defaultMaxs);
-        }
-
-        // ── Tier Stores → TierRouter ──
-        int quantizedVecBytes = dimensions;
-
-        // Working memory: configurable persistence (default: volatile)
-        WorkingMemoryStore workingStore;
-        if (isDisk && builder.persistWorkingMemory && basePath != null) {
-            workingStore = new WorkingMemoryStore(quantizedVecBytes, builder.workingCapacity,
-                    basePath.resolve("working.mem"));
-        } else {
-            workingStore = new WorkingMemoryStore(quantizedVecBytes, builder.workingCapacity);
-        }
-
-        // Episodic: always uses its own directory (already file-backed)
-        Path episodicPath;
-        if (basePath != null) {
-            episodicPath = basePath.resolve("episodic");
-        } else {
-            episodicPath = Path.of(System.getProperty("java.io.tmpdir"),
-                    "spector-memory-" + ProcessHandle.current().pid() + "-" + System.nanoTime(),
-                    "episodic");
-        }
-        EpisodicMemoryStore episodicStore = new EpisodicMemoryStore(
-                episodicPath, quantizedVecBytes, builder.episodicPartitionCapacity);
-
-        // Semantic: file-backed in DISK mode
-        SemanticMemoryStore semanticStore;
-        if (isDisk && basePath != null) {
-            semanticStore = new SemanticMemoryStore(quantizedVecBytes, builder.semanticCapacity,
-                    basePath.resolve("semantic.mem"));
-        } else {
-            semanticStore = new SemanticMemoryStore(quantizedVecBytes, builder.semanticCapacity);
-        }
-
-        // Procedural: file-backed in DISK mode
-        ProceduralMemoryStore proceduralStore;
-        if (isDisk && basePath != null) {
-            proceduralStore = new ProceduralMemoryStore(quantizedVecBytes, builder.proceduralCapacity,
-                    basePath.resolve("procedural.mem"));
-        } else {
-            proceduralStore = new ProceduralMemoryStore(quantizedVecBytes, builder.proceduralCapacity);
-        }
-
-        this.tierRouter = new TierRouter(workingStore, episodicStore, semanticStore, proceduralStore);
-
-        // ── Memory Index (load from disk if DISK mode and file exists) ──
-        if (isDisk && basePath != null) {
-            this.index = MemoryIndex.load(basePath.resolve("memory-index.mem"));
-        } else {
-            this.index = new MemoryIndex();
-        }
-
-        // ── WAL (file-backed in DISK mode) ──
-        if (isDisk && basePath != null) {
-            this.wal = new MemoryWal(basePath.resolve("wal"));
-        } else {
-            this.wal = new MemoryWal();
-        }
-
-        // ── Biological Subsystems ──
-        SurpriseDetector surpriseDetector = new SurpriseDetector(builder.surpriseWarmup);
-        FlashbulbPolicy flashbulbPolicy = new FlashbulbPolicy(builder.flashbulbThreshold);
-        this.valenceTracker = new ValenceTracker(builder.valenceLearningRate);
-        // CoActivationTracker: load from disk if available, else create fresh
-        if (isDisk && basePath != null) {
-            this.coActivationTracker = CoActivationTracker.load(
-                    basePath.resolve("coactivation.tracker"), 10_000, 20_000);
-        } else {
-            this.coActivationTracker = new CoActivationTracker();
-        }
-        this.suppressionSet = new SuppressionSet();
-        this.habituationPenalty = new HabituationPenalty(0.2f, builder.inhibitionTtlMs, builder.inhibitionFloor);
-        this.prospectiveScheduler = new ProspectiveScheduler();
-        this.introspector = new MemoryIntrospector(coActivationTracker);
-        this.lateralEvaluator = new LateralEvaluator();
-        this.reflectDaemon = new ReflectDaemon(
-                circadianPolicy,
-                builder.dimensions > 0 ? new CentroidRouter(builder.dimensions) : null,
-                builder.textGenerationProvider,
-                embeddingProvider,
-                5, // minClusterSize
-                builder.pinSourceEpisodes,
-                builder.pinnedQuota);
-
-        // ── 3-Layer Cognitive Graph ──
-        int graphCapacity = builder.hebbianGraphCapacity > 0
-                ? builder.hebbianGraphCapacity : builder.episodicPartitionCapacity;
-
-        // HebbianGraph: load from disk if available, else create fresh
-        if (isDisk && basePath != null) {
-            this.hebbianGraph = HebbianGraph.load(
-                    basePath.resolve("hebbian.graph"), graphCapacity);
-        } else {
-            this.hebbianGraph = new HebbianGraph(graphCapacity);
-        }
-
-        // TemporalChain: load from disk if available, else create fresh
-        int temporalCapacity = builder.temporalChainCapacity > 0
-                ? builder.temporalChainCapacity : graphCapacity;
-        if (isDisk && basePath != null) {
-            this.temporalChain = TemporalChain.load(
-                    basePath.resolve("temporal.chain"), temporalCapacity);
-        } else {
-            this.temporalChain = new TemporalChain(temporalCapacity);
-        }
-
-        // EntityGraph + EntityExtractor: based on mode
-        EntityExtractor entityExtractor;
-        if (builder.entityExtractionMode == EntityExtractionMode.LLM
-                && builder.textGenerationProvider != null) {
-            entityExtractor = new LlmEntityExtractor(
-                    builder.textGenerationProvider,
-                    builder.maxEntitiesPerMemory, builder.maxRelationsPerMemory);
-        } else if (builder.entityExtractionMode == EntityExtractionMode.CUSTOM
-                && builder.entityExtractor != null) {
-            entityExtractor = builder.entityExtractor;
-        } else {
-            entityExtractor = NoOpEntityExtractor.INSTANCE;
-        }
-
-        boolean entityEnabled = builder.entityExtractionMode != EntityExtractionMode.NONE;
-        if (entityEnabled) {
-            int entityCap = builder.entityGraphCapacity;
-            int edgeCap = entityCap * EntityGraph.MAX_DEGREE;
-            if (isDisk && basePath != null) {
-                this.entityGraph = EntityGraph.load(
-                        basePath.resolve("entity.graph"), entityCap, edgeCap);
-            } else {
-                this.entityGraph = new EntityGraph(entityCap, edgeCap);
-            }
-        } else {
-            this.entityGraph = null;
-        }
-
-        // ── Pipelines ──
-        this.embeddingProvider = embeddingProvider;
-        this.cognitiveTarget = new CognitiveIngestionTarget(
-                quantizer, surpriseDetector, flashbulbPolicy,
-                tierRouter, index, wal, workingStore, builder.icnuWeights,
-                builder.semanticIndex, builder.vectorStore, builder.tagExtractor, true,
-                hebbianGraph, temporalChain, entityExtractor, entityGraph);
-
-        // Build optional fused semantic recall strategy
-        SemanticRecallStrategy semanticStrategy = builder.semanticIndex != null
-                ? new SemanticRecallStrategy(builder.semanticIndex, semanticStore, index)
-                : null;
-
-        this.recallPipeline = new RecallPipeline(
-                embeddingProvider, tierRouter, index,
-                suppressionSet, habituationPenalty, prospectiveScheduler, wal,
-                quantizer.mins(), quantizer.scales(), semanticStrategy,
-                null, hebbianGraph, temporalChain, entityGraph, entityExtractor);
-
-        // Register post-recall observers (Phase 6: Observer pattern)
-        recallPipeline.addListener(new LtpReconsolidationListener(index, tierRouter, wal));
-        recallPipeline.addListener(new HebbianCoActivationListener(coActivationTracker));
-
-        log.info("SpectorMemory initialized: dimensions={}, model={}, persistence={}, mode={}, quantizer={}",
-                dimensions, embeddingProvider.modelName(),
-                basePath != null ? basePath : "in-memory",
-                persistenceMode,
-                builder.quantizer != null ? "user-provided" : "identity-default");
-    }
-
-    // ══════════════════════════════════════════════════════════════
-    // INGESTION TARGET — for unified IngestionPipeline
-    // ══════════════════════════════════════════════════════════════
-
-    @Override
-    public CognitiveIngestionTarget target() {
-        return cognitiveTarget;
-    }
-
-    // ══════════════════════════════════════════════════════════════
-    // CORE API — remember / recall / forget / reflect
-    // ══════════════════════════════════════════════════════════════
-
-    @Override
-    public CompletableFuture<Void> remember(String id, String text, MemoryType type,
-                                              MemorySource source, String... tags) {
-        return CompletableFuture.runAsync(() -> {
-            try {
-                // Embed text, then pass to cognitive target
-                float[] vector = embeddingProvider.embed(text).vector();
-                cognitiveTarget.ingestCognitive(id, text, vector, type, tags, source, null);
-
-                // Circadian trigger: auto-reflect after volume threshold
-                if (type == MemoryType.EPISODIC) {
-                    int count = episodicIngestCount.incrementAndGet();
-                    if (count >= circadianPolicy.volumeTrigger()) {
-                        episodicIngestCount.set(0);
-                        CompletableFuture.runAsync(() -> {
-                            log.info("Circadian volume trigger: {} episodic memories → auto-reflect", count);
-                            reflect();
-                        }, virtualExecutor);
-                    }
-                }
-            } catch (Exception e) {
-                log.error("Failed to remember '{}': {}", id, e.getMessage(), e);
-                throw new SpectorServerException(ErrorCode.INTERNAL_ERROR, e, "Memory ingestion failed for id=" + id);
-            }
-        }, virtualExecutor);
-    }
-
-    @Override
-    public CompletableFuture<Void> remember(String id, String text, MemoryType type,
-                                              String... tags) {
-        return remember(id, text, type, MemorySource.OBSERVED, tags);
-    }
-
-    @Override
-    public List<CognitiveResult> recall(String queryText, RecallOptions options) {
-        return recallPipeline.recall(queryText, options);
-    }
-
-    @Override
-    public List<CognitiveResult> recall(String queryText, CognitiveProfile profile) {
-        CognitiveProfile effective = profileConfig.validate(profile);
-        return recall(queryText, RecallOptions.builder().profile(effective).build());
-    }
-
-    @Override
-    public List<CognitiveResult> recall(String queryText) {
-        return recall(queryText, RecallOptions.DEFAULT);
-    }
-
-    @Override
-    public void forget(String id) {
-        if (id == null) { throw new SpectorValidationException(ErrorCode.ARGUMENT_NULL, "id"); }
-        MemoryLocation loc = index.locate(id);
-        if (loc == null) {
-            log.warn("Forget: memory '{}' not found in index", id);
-            return;
-        }
-
-        MemorySegment segment = tierRouter.segmentFor(loc.type());
-        if (segment != null) {
-            CognitiveRecordLayout layout = tierRouter.layoutFor(loc.type());
-            layout.tombstone(segment, loc.offset());
-        }
-
-        wal.appendForget(id);
-        index.remove(id);
-        log.debug("Forget: '{}' tombstoned", id);
-    }
-
-    @Override
-    public ReflectReport reflect() {
-        log.info("Manual reflection triggered");
-        ReflectReport report = reflectDaemon.runCycle(
-                tierRouter.episodic(), tierRouter.semantic(),
-                offset -> index.findTextByOffset(MemoryType.EPISODIC, offset));
-
-        // ── Graph Decay (Sleep Consolidation) ──
-        // Hebbian edges decay by 10% per reflection cycle (biological synaptic homeostasis)
-        try {
-            int hebbianDecayed = hebbianGraph.decayEdges(0.9f);
-            if (hebbianDecayed > 0) {
-                log.info("Reflect: Hebbian graph decayed {} weak edges", hebbianDecayed);
-            }
-        } catch (RuntimeException e) {
-            SpectorGraphDecayException ex = new SpectorGraphDecayException("Hebbian edge decay", e);
-            log.warn(ex.getMessage());
-        }
-
-        // Temporal chain: decay old links (prune chains older than 7 days)
-        // TemporalChain nodes don't have a decay mechanism yet — future work
-
-        wal.append(WalEvent.EventType.REFLECT, "system", null);
-        return report;
-    }
-
-    // ══════════════════════════════════════════════════════════════
-    // EXTENDED API — reinforce / suppress / introspect / Hebbian
-    // ══════════════════════════════════════════════════════════════
-
-    @Override
-    public void reinforce(String memoryId, byte valence) {
-        if (memoryId == null) { throw new SpectorValidationException(ErrorCode.ARGUMENT_NULL, "memoryId"); }
-        MemoryLocation loc = index.locate(memoryId);
-        if (loc == null) {
-            log.warn("Reinforce: memory '{}' not found", memoryId);
-            return;
-        }
-
-        MemorySegment segment = tierRouter.segmentFor(loc.type());
-        if (segment != null) {
-            CognitiveRecordLayout layout = tierRouter.layoutFor(loc.type());
-            valenceTracker.reinforce(segment, loc.offset(), layout, valence);
-            layout.incrementRecallCount(segment, loc.offset()); // LTP on explicit use
-        }
-
-        // Neurodivergent: Feed lateral evaluator based on whether this was a lateral result
-        if (recallPipeline.wasLateral(memoryId)) {
-            if (valence > 0) {
-                lateralEvaluator.recordLateralReinforcement();
-                log.debug("Lateral reinforcement: '{}' (positive valence={})", memoryId, valence);
-            } else if (valence < 0) {
-                lateralEvaluator.recordLateralSuppression();
-                log.debug("Lateral suppression via reinforce: '{}' (negative valence={})", memoryId, valence);
-            }
-        }
-
-        wal.appendReinforce(memoryId, valence);
-        log.debug("Reinforce: '{}' with valence={}", memoryId, valence);
-    }
-
-    @Override
-    public void suppress(String memoryId, String reason) {
-        suppressionSet.suppress(memoryId, reason);
-        // Also register offset for hot-loop filtering
-        MemoryLocation loc = index.locate(memoryId);
-        if (loc != null) {
-            suppressionSet.registerOffset(loc.type().ordinal(), loc.offset());
-        }
-
-        // Neurodivergent: Feed lateral evaluator
-        if (recallPipeline.wasLateral(memoryId)) {
-            lateralEvaluator.recordLateralSuppression();
-            log.debug("Lateral suppression: '{}' (reason={})", memoryId, reason);
-        }
-    }
-
-    @Override
-    public void suppress(String memoryId) { suppress(memoryId, null); }
-
-    @Override
-    public void unsuppress(String memoryId) { suppressionSet.unsuppress(memoryId); }
-
-    @Override
-    public void markResolved(String memoryId) {
-        var loc = index.locate(memoryId);
-        if (loc == null) return;
-        tierRouter.layoutFor(loc.type()).markResolved(tierRouter.segmentFor(loc.type()), loc.offset());
-        log.debug("Zeigarnik: marked '{}' as RESOLVED", memoryId);
-    }
-
-    @Override
-    public void markUnresolved(String memoryId) {
-        var loc = index.locate(memoryId);
-        if (loc == null) return;
-        tierRouter.layoutFor(loc.type()).markUnresolved(tierRouter.segmentFor(loc.type()), loc.offset());
-        log.debug("Zeigarnik: marked '{}' as UNRESOLVED", memoryId);
-    }
-
-    @Override
-    public MemoryInsight introspect(String topic) {
-        List<CognitiveResult> results = recall(topic, RecallOptions.builder().topK(20).build());
-        return introspector.analyze(topic, results);
-    }
-
-    // ══════════════════════════════════════════════════════════════
-    // PROSPECTIVE / SCRATCHPAD / STATS
-    // ══════════════════════════════════════════════════════════════
-
-    @Override
-    public Reminder scheduleReminder(String text, Instant triggerAt, String... tags) {
-        return prospectiveScheduler.schedule(text, triggerAt, tags);
-    }
-
-    @Override
-    public Reminder scheduleReminder(String text, Duration delay, String... tags) {
-        return prospectiveScheduler.scheduleAfter(text, delay, tags);
-    }
-
-    @Override
-    public CompletableFuture<Void> scratchpad(String text) {
-        return remember("scratchpad-" + System.nanoTime(), text, MemoryType.WORKING);
-    }
-
-    @Override
-    public int totalMemories() { return tierRouter.totalCount(); }
-
-    @Override
-    public int memoryCount(MemoryType type) { return tierRouter.countFor(type); }
-
-    @Override
-    public int decay(Duration olderThan, float factor) {
-        if (olderThan == null) { throw new SpectorValidationException(ErrorCode.ARGUMENT_NULL, "olderThan"); }
-        if (factor < 0f || factor > 1f) throw new SpectorValidationException(ErrorCode.ARGUMENT_OUT_OF_RANGE, "factor", 0, 1, 0);
-
-        long nowMs = System.currentTimeMillis();
-        long thresholdMs = nowMs - olderThan.toMillis();
-
-        var partitions = tierRouter.episodic().partitions();
-        if (partitions.isEmpty()) return 0;
-
-        // Parallel decay: each partition on its own Virtual Thread
-        try {
-            java.util.List<java.util.concurrent.Callable<Integer>> tasks = new java.util.ArrayList<>(partitions.size());
-            for (var partition : partitions) {
-                tasks.add(() -> {
-                    int count = 0;
-                    CognitiveRecordLayout layout = partition.layout();
-                    MemorySegment segment = partition.segment();
-                    for (int i = 0; i < partition.count(); i++) {
-                        long offset = partition.recordOffset(i);
-                        byte flags = layout.readFlags(segment, offset);
-                        if (SynapticHeaderConstants.isTombstoned(flags)) continue;
-
-                        long ts = layout.readTimestamp(segment, offset);
-                        if (ts < thresholdMs) {
-                            float oldImp = layout.readImportance(segment, offset);
-                            layout.writeImportance(segment, offset, oldImp * factor);
-                            count++;
-                        }
-                    }
-                    return count;
-                });
-            }
-            java.util.List<Integer> results = ConcurrentTasks.forkJoinAll(tasks);
-            int affected = 0;
-            for (int c : results) affected += c;
-            log.info("Decay: {} memories older than {} multiplied by {}", affected, olderThan, factor);
-            return affected;
-        } catch (ConcurrentExecutionException | InterruptedException e) {
-            Thread.currentThread().interrupt();
-            log.warn("Parallel decay failed, falling back to sequential: {}", e.getMessage());
-            // Sequential fallback
-            int affected = 0;
-            for (var partition : partitions) {
-                CognitiveRecordLayout layout = partition.layout();
-                MemorySegment segment = partition.segment();
-                for (int i = 0; i < partition.count(); i++) {
-                    long offset = partition.recordOffset(i);
-                    byte flags = layout.readFlags(segment, offset);
-                    if (SynapticHeaderConstants.isTombstoned(flags)) continue;
-                    long ts = layout.readTimestamp(segment, offset);
-                    if (ts < thresholdMs) {
-                        float oldImp = layout.readImportance(segment, offset);
-                        layout.writeImportance(segment, offset, oldImp * factor);
-                        affected++;
-                    }
-                }
-            }
-            log.info("Decay: {} memories older than {} multiplied by {}", affected, olderThan, factor);
-            return affected;
-        }
-    }
-
-    // ══════════════════════════════════════════════════════════════
-    // SUBSYSTEM ACCESSORS
-    // ══════════════════════════════════════════════════════════════
-
-    @Override public CoActivationTracker coActivation() { return coActivationTracker; }
-    @Override public MemoryWal wal() { return wal; }
-    @Override public ProspectiveScheduler prospective() { return prospectiveScheduler; }
-    @Override public SuppressionSet suppression() { return suppressionSet; }
-    @Override public HabituationPenalty habituation() { return habituationPenalty; }
-    @Override public ScalarQuantizer quantizer() { return quantizer; }
-    @Override public CognitiveIngestionTarget cognitiveTarget() { return cognitiveTarget; }
-    @Override public RecallPipeline recallPipeline() { return recallPipeline; }
-    @Override public TierRouter tierRouter() { return tierRouter; }
-    @Override public MemoryIndex index() { return index; }
-    @Override public LateralEvaluator lateralEvaluator() { return lateralEvaluator; }
-    @Override public HebbianGraph hebbianGraph() { return hebbianGraph; }
-    @Override public TemporalChain temporalChain() { return temporalChain; }
-    @Override public EntityGraph entityGraph() { return entityGraph; }
-
-    @Override
-    public void close() {
-        log.info("SpectorMemory closing ({} total memories, mode={})", totalMemories(), persistenceMode);
-
-        // Save MemoryIndex to disk if DISK mode
-        if (persistenceMode == MemoryPersistenceMode.DISK && persistencePath != null) {
-            try {
-                index.save(persistencePath.resolve("memory-index.mem"));
-            } catch (Exception e) {
-                log.error("Failed to save MemoryIndex on close: {}", e.getMessage(), e);
-            }
-
-            // Save 3-Layer Cognitive Graph
-            try {
-                hebbianGraph.save(persistencePath.resolve("hebbian.graph"));
-            } catch (Exception e) {
-                log.error("Failed to save HebbianGraph on close: {}", e.getMessage(), e);
-            }
-            try {
-                temporalChain.save(persistencePath.resolve("temporal.chain"));
-            } catch (Exception e) {
-                log.error("Failed to save TemporalChain on close: {}", e.getMessage(), e);
-            }
-            if (entityGraph != null) {
-                try {
-                    entityGraph.save(persistencePath.resolve("entity.graph"));
-                } catch (Exception e) {
-                    log.error("Failed to save EntityGraph on close: {}", e.getMessage(), e);
-                }
-            }
-            try {
-                coActivationTracker.save(persistencePath.resolve("coactivation.tracker"));
-            } catch (Exception e) {
-                log.error("Failed to save CoActivationTracker on close: {}", e.getMessage(), e);
-            }
-        }
-
-        virtualExecutor.close();
-        tierRouter.close();
-        wal.close();
-        hebbianGraph.close();
-        temporalChain.close();
-        coActivationTracker.close();
-        if (entityGraph != null) entityGraph.close();
-    }
-
-    // ══════════════════════════════════════════════════════════════
-    // BUILDER
-    // ══════════════════════════════════════════════════════════════
-
-    public static Builder builder() { return new Builder(); }
-
-    public static final class Builder {
-        private int dimensions;
-        private EmbeddingProvider embeddingProvider;
-        private Path persistencePath;
-        private MemoryPersistenceMode persistenceMode = MemoryPersistenceMode.DISK;
-        private boolean persistWorkingMemory = false;
-        private CircadianPolicy circadianPolicy = CircadianPolicy.DEFAULT;
-        private int workingCapacity = 100;
-        private int episodicPartitionCapacity = 10_000;
-        private int semanticCapacity = 100_000;
-        private int proceduralCapacity = 1_000;
-        private int surpriseWarmup = 20;
-        private double flashbulbThreshold = 3.0;
-        private float valenceLearningRate = 0.3f;
-        private float deduplicationRadius = 0.05f;
-        private TextGenerationProvider textGenerationProvider;
-        private ScalarQuantizer quantizer;
-        private com.spectrayan.spector.index.VectorIndex semanticIndex;
-        private long inhibitionTtlMs = 300_000L;
-        private float inhibitionFloor = 0.1f;
-        private IcnuWeights icnuWeights;
-        private boolean pinSourceEpisodes = false;
-        private int pinnedQuota = 10_000;
-        private com.spectrayan.spector.memory.pipeline.TagExtractor tagExtractor;
-        private com.spectrayan.spector.storage.VectorStore vectorStore;
-        private CognitiveProfileConfig profileConfig = CognitiveProfileConfig.allEnabled();
-
-        // 3-Layer Cognitive Graph configuration
-        private int hebbianGraphCapacity = 0; // 0 = use episodicPartitionCapacity
-        private int temporalChainCapacity = 0; // 0 = use hebbianGraphCapacity
-        private EntityExtractionMode entityExtractionMode = EntityExtractionMode.NONE;
-        private EntityExtractor entityExtractor;
-        private int entityGraphCapacity = 50_000;
-        private int maxEntitiesPerMemory = 10;
-        private int maxRelationsPerMemory = 20;
-
-        public Builder dimensions(int dimensions) { this.dimensions = dimensions; return this; }
-        public Builder embeddingProvider(EmbeddingProvider p) { this.embeddingProvider = p; return this; }
-        public Builder persistence(Path p) { this.persistencePath = p; return this; }
-        /** Sets the persistence mode (default: {@link MemoryPersistenceMode#DISK}). */
-        public Builder persistenceMode(MemoryPersistenceMode mode) { this.persistenceMode = mode; return this; }
-        /** If true, Working memory is also persisted to disk in DISK mode (default: false). */
-        public Builder persistWorkingMemory(boolean persist) { this.persistWorkingMemory = persist; return this; }
-        public Builder reflectPolicy(CircadianPolicy p) { this.circadianPolicy = p; return this; }
-        public Builder workingCapacity(int c) { this.workingCapacity = c; return this; }
-        public Builder episodicPartitionCapacity(int c) { this.episodicPartitionCapacity = c; return this; }
-        public Builder semanticCapacity(int c) { this.semanticCapacity = c; return this; }
-        public Builder proceduralCapacity(int c) { this.proceduralCapacity = c; return this; }
-        public Builder surpriseWarmup(int w) { this.surpriseWarmup = w; return this; }
-        public Builder flashbulbThreshold(double t) { this.flashbulbThreshold = t; return this; }
-        public Builder valenceLearningRate(float r) { this.valenceLearningRate = r; return this; }
-        public Builder deduplicationRadius(float r) { this.deduplicationRadius = r; return this; }
-        public Builder textGenerationProvider(TextGenerationProvider p) { this.textGenerationProvider = p; return this; }
-        public Builder quantizer(ScalarQuantizer quantizer) { this.quantizer = quantizer; return this; }
-
-        /** Optional HNSW/IVF index for fused semantic recall (default: null = header-only fallback). */
-        public Builder semanticIndex(com.spectrayan.spector.index.VectorIndex idx) { this.semanticIndex = idx; return this; }
-
-        /** Engine's VectorStore for store-backed HNSW population (default: null). */
-        public Builder vectorStore(com.spectrayan.spector.storage.VectorStore vs) { this.vectorStore = vs; return this; }
-
-        /** Inhibition of Return TTL in millis (default: 300_000 = 5 minutes). */
-        public Builder inhibitionTtlMs(long ms) { this.inhibitionTtlMs = ms; return this; }
-
-        /** Inhibition of Return floor multiplier (default: 0.1). */
-        public Builder inhibitionFloor(float floor) { this.inhibitionFloor = floor; return this; }
-
-        /** ICNU fusion weights for neurodivergent importance computation (default: IcnuWeights.DEFAULT). */
-        public Builder icnuWeights(IcnuWeights w) { this.icnuWeights = w; return this; }
-
-        /** Enable lossless consolidation — pin source episodes during REM sleep (default: false). */
-        public Builder pinSourceEpisodes(boolean pin) { this.pinSourceEpisodes = pin; return this; }
-
-        /** Maximum number of pinned records (default: 10,000). */
-        public Builder pinnedQuota(int quota) { this.pinnedQuota = quota; return this; }
-
-        /** Pluggable tag extraction strategy for cognitive ingestion (default: ContentTagExtractor). */
-        public Builder tagExtractor(com.spectrayan.spector.memory.pipeline.TagExtractor te) { this.tagExtractor = te; return this; }
-
-        /** Cognitive profile configuration (default: all profiles enabled). */
-        public Builder profileConfig(CognitiveProfileConfig config) { this.profileConfig = config; return this; }
-
-        // ── 3-Layer Cognitive Graph configuration ──
-
-        /** Hebbian graph capacity (default: same as episodicPartitionCapacity). */
-        public Builder hebbianGraphCapacity(int c) { this.hebbianGraphCapacity = c; return this; }
-
-        /** Temporal chain capacity (default: same as hebbianGraphCapacity). */
-        public Builder temporalChainCapacity(int c) { this.temporalChainCapacity = c; return this; }
-
-        /** Entity extraction mode (default: NONE). */
-        public Builder entityExtractionMode(EntityExtractionMode mode) { this.entityExtractionMode = mode; return this; }
-
-        /** Custom entity extractor (used when mode = CUSTOM). */
-        public Builder entityExtractor(EntityExtractor extractor) { this.entityExtractor = extractor; return this; }
-
-        /** Entity graph capacity — max entities (default: 50,000). */
-        public Builder entityGraphCapacity(int c) { this.entityGraphCapacity = c; return this; }
-
-        /** Max entities to extract per memory (default: 10). */
-        public Builder maxEntitiesPerMemory(int c) { this.maxEntitiesPerMemory = c; return this; }
-
-        /** Max relations to extract per memory (default: 20). */
-        public Builder maxRelationsPerMemory(int c) { this.maxRelationsPerMemory = c; return this; }
-
-        /**
-         * Parses a cognitive profile config from a YAML string value.
-         * Supports: "ALL", "CORE_ONLY", "WITH_NEURODIVERGENT", or comma-separated profile names.
-         * @see CognitiveProfileConfig#fromConfigValue(String)
-         */
-        public Builder cognitiveProfiles(String configValue) { this.profileConfig = CognitiveProfileConfig.fromConfigValue(configValue); return this; }
-
-        public SpectorMemory build() {
-            if (dimensions <= 0 && embeddingProvider != null) {
-                dimensions = embeddingProvider.dimensions();
-            }
-            return new DefaultSpectorMemory(this);
-        }
-    }
-}
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/MemoryPersistenceMode.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/MemoryPersistenceMode.java
deleted file mode 100644
index 6921407..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/MemoryPersistenceMode.java
+++ /dev/null
@@ -1,48 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory;
-
-/**
- * Persistence mode for cognitive memory tier stores.
- *
- * <h3>Design</h3>
- * <p>Mirrors {@code com.spectrayan.spector.storage.PersistenceMode} from the
- * storage module, but is specific to the memory module's tier stores
- * (Working, Episodic, Semantic, Procedural).</p>
- *
- * <h3>Behavior by Mode</h3>
- * <ul>
- *   <li>{@link #IN_MEMORY} — All tier stores use {@code Arena.ofShared()} for
- *       volatile off-heap RAM. Data is lost on JVM shutdown. Suitable for
- *       ephemeral agents and unit tests.</li>
- *   <li>{@link #DISK} — All tier stores (except optionally Working) use
- *       {@code FileChannel.map()} for persistent mmap files. Data survives
- *       JVM restarts. This is the <b>default</b> mode.</li>
- * </ul>
- *
- * @see com.spectrayan.spector.memory.SpectorMemory.Builder#persistenceMode(MemoryPersistenceMode)
- */
-public enum MemoryPersistenceMode {
-
-    /**
-     * All tier stores use volatile off-heap RAM ({@code Arena.ofShared()}).
-     * Data is lost on JVM shutdown.
-     */
-    IN_MEMORY,
-
-    /**
-     * Tier stores use memory-mapped files ({@code FileChannel.map()}).
-     * Data survives JVM restarts. This is the default.
-     */
-    DISK
-}
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/MemoryType.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/MemoryType.java
deleted file mode 100644
index b16b128..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/MemoryType.java
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory;
-
-/**
- * Cognitive memory type — determines physical routing and storage backend.
- *
- * <h3>Biological Analogs</h3>
- * <ul>
- *   <li>{@link #WORKING} — Prefrontal Cortex (short-term buffer, volatile RAM)</li>
- *   <li>{@link #EPISODIC} — Hippocampus (event sequences, time-partitioned mmap)</li>
- *   <li>{@link #SEMANTIC} — Neocortex (permanent facts, HNSW/SVASQ indexed)</li>
- *   <li>{@link #PROCEDURAL} — Basal Ganglia (motor/habit memory, small indexed store)</li>
- * </ul>
- *
- * <p>The ordinal values (0–3) are encoded as 2 bits in the flags byte of the
- * {@link com.spectrayan.spector.memory.synapse.SynapticHeaderConstants synaptic header}.</p>
- */
-public enum MemoryType {
-
-    /**
-     * Short-lived scratchpad for in-progress reasoning.
-     * Backed by volatile {@code MemorySegment} Arena (RAM only, no mmap).
-     * Auto-evicts via FIFO when capacity is reached.
-     */
-    WORKING,
-
-    /**
-     * High-volume, append-only event log.
-     * Backed by time-partitioned mmap files.
-     * Flat SIMD scan per partition (no HNSW — append-only is faster).
-     */
-    EPISODIC,
-
-    /**
-     * Permanent, deduplicated factual knowledge.
-     * Backed by persistent mmap with HNSW/SVASQ index.
-     * Reuses existing {@code SpectorIndex} infrastructure.
-     */
-    SEMANTIC,
-
-    /**
-     * Prompt templates and tool-usage rules.
-     * Small persistent store for microsecond lookups.
-     * High importance, low TTL, indexed flat scan.
-     */
-    PROCEDURAL
-}
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/RecallOptions.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/RecallOptions.java
deleted file mode 100644
index e8662a5..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/RecallOptions.java
+++ /dev/null
@@ -1,331 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory;
-
-import com.spectrayan.spector.memory.synapse.SynapticTagEncoder;
-
-/**
- * Builder for recall query configuration.
- *
- * <p>Controls how {@link SpectorMemory#recall} filters, scores, and returns
- * cognitive memories. Supports synaptic tag filtering, importance thresholds,
- * memory type selection, valence range filtering, and neurodivergent
- * cognitive profile mechanics (hyperfocus, lateral retrieval).</p>
- *
- * <h3>Example</h3>
- * <pre>{@code
- *   List<CognitiveResult> results = memory.recall("database lock timeout",
- *       RecallOptions.builder()
- *           .topK(5)
- *           .synapticFilter("debugging", "database")
- *           .minImportance(0.3f)
- *           .memoryTypes(MemoryType.SEMANTIC, MemoryType.EPISODIC)
- *           .maxValence((byte) -10)  // only negative-outcome memories
- *           .build());
- * }</pre>
- *
- * <h3>Neurodivergent Profiles</h3>
- * <pre>{@code
- *   // Hyperfocus: zero-decay, strict tag gate, pure similarity scoring
- *   RecallOptions opts = RecallOptions.builder()
- *       .profile(CognitiveProfile.HYPERFOCUS)
- *       .hyperfocusMask("database", "deadlock")
- *       .build();
- *
- *   // Lateral retrieval: cross-domain divergent thinking
- *   RecallOptions opts = RecallOptions.builder()
- *       .profile(CognitiveProfile.DIVERGENT)
- *       .lateralMode(true)
- *       .build();
- * }</pre>
- */
-public record RecallOptions(
-        int topK,
-        long synapticTagMask,
-        float minImportance,
-        MemoryType[] memoryTypes,
-        byte minValence,
-        byte maxValence,
-        float alpha,
-        float beta,
-        float tagRelevanceBoost,
-        int semanticCandidateMultiplier,
-        // ── Neurodivergent: Hyperfocus ──
-        long hyperfocusMask,
-        float hyperfocusBoost,
-        // ── Neurodivergent: Lateral Retrieval ──
-        boolean lateralMode,
-        float lateralDistanceThreshold,
-        int lateralMaxResults,
-        float lateralMinTagOverlap,
-        // ── Enhanced Scoring ──
-        float strictnessCoefficient,
-        // ── Valence Alignment (State-Dependent Recall) ──
-        byte queryValence,
-        boolean enableValenceAlignment
-) {
-
-    /** Default options: top 10, no filters, balanced scoring. */
-    public static final RecallOptions DEFAULT = builder().build();
-
-    /**
-     * Creates a new builder.
-     */
-    public static Builder builder() {
-        return new Builder();
-    }
-
-    /**
-     * Builder for {@link RecallOptions}.
-     */
-    public static final class Builder {
-
-        private int topK = 10;
-        private long synapticTagMask = 0L;
-        private float minImportance = 0.0f;
-        private MemoryType[] memoryTypes = null; // null = all types
-        private byte minValence = Byte.MIN_VALUE;
-        private byte maxValence = Byte.MAX_VALUE;
-        private float alpha = 0.6f;  // similarity weight
-        private float beta = 0.4f;   // importance × decay weight
-        private float tagRelevanceBoost = 0.3f;  // weighted tag overlap boost
-        private int semanticCandidateMultiplier = 3; // HNSW over-fetch for semantic
-
-        // ── Neurodivergent: Hyperfocus ──
-        private long hyperfocusMask = 0L;       // 0 = disabled
-        private float hyperfocusBoost = 1.0f;   // post-score multiplier
-
-        // ── Neurodivergent: Lateral Retrieval ──
-        private boolean lateralMode = false;
-        private float lateralDistanceThreshold = 1.2f;
-        private int lateralMaxResults = -1;      // -1 = topK/3
-        private float lateralMinTagOverlap = 0.5f;
-
-        // ── Enhanced Scoring ──
-        private float strictnessCoefficient = 1.0f; // 1.0 = standard, 10.0 = Heaviside cliff
-
-        // ── Valence Alignment (State-Dependent Recall) ──
-        private byte queryValence = 0;              // 0 = neutral
-        private boolean enableValenceAlignment = false;
-
-        /**
-         * Applies a {@link CognitiveProfile} preset to this builder.
-         *
-         * <p>Sets alpha, beta, minValence, and maxValence from the profile.
-         * Individual fields can be overridden after applying the profile.</p>
-         *
-         * @param profile the cognitive scoring profile to apply
-         */
-        public Builder profile(CognitiveProfile profile) {
-            return profile.applyTo(this);
-        }
-
-        /**
-         * Maximum number of results to return.
-         */
-        public Builder topK(int topK) {
-            this.topK = topK;
-            return this;
-        }
-
-        /**
-         * Synaptic tag filter using Bloom filter matching.
-         * Only memories whose tags match ALL specified tags will be considered.
-         */
-        public Builder synapticFilter(String... tags) {
-            this.synapticTagMask = SynapticTagEncoder.encode(tags);
-            return this;
-        }
-
-        /**
-         * Minimum importance threshold — memories below this are skipped.
-         */
-        public Builder minImportance(float minImportance) {
-            this.minImportance = minImportance;
-            return this;
-        }
-
-        /**
-         * Restrict recall to specific memory types.
-         * Pass null or omit to search all types.
-         */
-        public Builder memoryTypes(MemoryType... memoryTypes) {
-            this.memoryTypes = memoryTypes;
-            return this;
-        }
-
-        /**
-         * Minimum valence (inclusive). Use for filtering to positive outcomes.
-         */
-        public Builder minValence(byte minValence) {
-            this.minValence = minValence;
-            return this;
-        }
-
-        /**
-         * Maximum valence (inclusive). Use for filtering to negative outcomes (debugging).
-         */
-        public Builder maxValence(byte maxValence) {
-            this.maxValence = maxValence;
-            return this;
-        }
-
-        /**
-         * Scoring weight for vector similarity (default: 0.6).
-         */
-        public Builder alpha(float alpha) {
-            this.alpha = alpha;
-            return this;
-        }
-
-        /**
-         * Scoring weight for importance × decay (default: 0.4).
-         */
-        public Builder beta(float beta) {
-            this.beta = beta;
-            return this;
-        }
-
-        /**
-         * Boost factor for weighted tag relevance (default: 0.3).
-         * Partial tag matches are scored as: score *= (1.0 + overlapRatio * tagRelevanceBoost).
-         * Set to 0.0 to disable tag relevance boosting.
-         */
-        public Builder tagRelevanceBoost(float tagRelevanceBoost) {
-            this.tagRelevanceBoost = tagRelevanceBoost;
-            return this;
-        }
-
-        /**
-         * Over-fetch multiplier for semantic HNSW search (default: 3).
-         * Fetches topK * multiplier candidates from HNSW before cognitive re-ranking.
-         */
-        public Builder semanticCandidateMultiplier(int multiplier) {
-            this.semanticCandidateMultiplier = multiplier;
-            return this;
-        }
-
-        // ── Neurodivergent: Hyperfocus ──
-
-        /**
-         * Sets the hyperfocus Bloom filter mask from raw long value.
-         * Memories that don't match ALL bits in this mask are excluded (strict equality gate).
-         * Set to 0L to disable hyperfocus (default).
-         */
-        public Builder hyperfocusMask(long mask) {
-            this.hyperfocusMask = mask;
-            return this;
-        }
-
-        /**
-         * Sets the hyperfocus mask from synaptic tag strings.
-         * Encodes tags into a Bloom filter mask for strict equality gating.
-         */
-        public Builder hyperfocusMask(String... tags) {
-            this.hyperfocusMask = SynapticTagEncoder.encode(tags);
-            return this;
-        }
-
-        /**
-         * Post-score multiplier for hyperfocus-matched memories (default: 1.0).
-         * Applied after the normalized base score is computed.
-         */
-        public Builder hyperfocusBoost(float boost) {
-            this.hyperfocusBoost = boost;
-            return this;
-        }
-
-        // ── Neurodivergent: Lateral Retrieval ──
-
-        /**
-         * Enables lateral/orthogonal retrieval — finds tag-matched but semantically
-         * distant memories for cross-domain insight (default: false).
-         */
-        public Builder lateralMode(boolean enabled) {
-            this.lateralMode = enabled;
-            return this;
-        }
-
-        /**
-         * Minimum L2 distance for a memory to qualify as a lateral candidate (default: 1.2).
-         * Higher values → only very distant memories are considered lateral.
-         */
-        public Builder lateralDistanceThreshold(float threshold) {
-            this.lateralDistanceThreshold = threshold;
-            return this;
-        }
-
-        /**
-         * Maximum number of lateral candidates in the final results (default: topK/3).
-         * Set to -1 for auto (topK/3).
-         */
-        public Builder lateralMaxResults(int max) {
-            this.lateralMaxResults = max;
-            return this;
-        }
-
-        /**
-         * Minimum tag overlap ratio for lateral candidates (default: 0.5).
-         * Prevents Bloom filter false positives from producing spurious lateral results.
-         */
-        public Builder lateralMinTagOverlap(float minOverlap) {
-            this.lateralMinTagOverlap = minOverlap;
-            return this;
-        }
-
-        // ── Enhanced Scoring ──
-
-        /**
-         * Strictness coefficient for the similarity function (default: 1.0).
-         * Higher values create a steeper "cliff" — near-matches score well,
-         * slightly vague matches plummet. Use 10.0 for SYSTEMATIZER / THE_EXECUTOR.
-         */
-        public Builder strictnessCoefficient(float k) {
-            this.strictnessCoefficient = k;
-            return this;
-        }
-
-        // ── Valence Alignment (State-Dependent Recall) ──
-
-        /**
-         * Sets the query's emotional valence for state-dependent recall.
-         * Memories with similar valence score higher. Enables valence alignment automatically.
-         */
-        public Builder queryValence(byte valence) {
-            this.queryValence = valence;
-            this.enableValenceAlignment = true;
-            return this;
-        }
-
-        /**
-         * Explicitly enables/disables valence alignment scoring.
-         */
-        public Builder enableValenceAlignment(boolean enabled) {
-            this.enableValenceAlignment = enabled;
-            return this;
-        }
-
-        public RecallOptions build() {
-            int effectiveLateralMax = lateralMaxResults >= 0
-                    ? lateralMaxResults
-                    : Math.max(1, topK / 3);
-            return new RecallOptions(topK, synapticTagMask, minImportance,
-                    memoryTypes, minValence, maxValence, alpha, beta,
-                    tagRelevanceBoost, semanticCandidateMultiplier,
-                    hyperfocusMask, hyperfocusBoost,
-                    lateralMode, lateralDistanceThreshold,
-                    effectiveLateralMax, lateralMinTagOverlap,
-                    strictnessCoefficient, queryValence, enableValenceAlignment);
-        }
-    }
-}
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/ReflectReport.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/ReflectReport.java
deleted file mode 100644
index 6914687..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/ReflectReport.java
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory;
-
-import java.time.Duration;
-
-/**
- * Report generated by the reflection (sleep consolidation) process.
- *
- * @param consolidatedCount number of episodic clusters promoted to Semantic tier
- * @param tombstonedCount   number of memories tombstoned during Deep Sleep pruning
- * @param compactedPartitions number of partitions that were rebuilt after tombstone threshold
- * @param duration          total time taken for the reflection cycle
- */
-public record ReflectReport(
-        int consolidatedCount,
-        int tombstonedCount,
-        int compactedPartitions,
-        Duration duration
-) {
-
-    /**
-     * Returns true if any work was done during this reflection cycle.
-     */
-    public boolean hadActivity() {
-        return consolidatedCount > 0 || tombstonedCount > 0 || compactedPartitions > 0;
-    }
-
-    /**
-     * Empty report — no work done.
-     */
-    public static final ReflectReport EMPTY = new ReflectReport(0, 0, 0, Duration.ZERO);
-}
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/SpectorMemory.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/SpectorMemory.java
deleted file mode 100644
index f25bf96..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/SpectorMemory.java
+++ /dev/null
@@ -1,206 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory;
-
-import com.spectrayan.spector.core.quantization.ScalarQuantizer;
-import com.spectrayan.spector.memory.cortex.MemorySource;
-import com.spectrayan.spector.memory.cortex.TierRouter;
-import com.spectrayan.spector.memory.graph.EntityGraph;
-import com.spectrayan.spector.memory.habituation.HabituationPenalty;
-import com.spectrayan.spector.memory.hebbian.CoActivationTracker;
-import com.spectrayan.spector.memory.hebbian.HebbianGraph;
-import com.spectrayan.spector.memory.index.MemoryIndex;
-import com.spectrayan.spector.memory.inhibition.SuppressionSet;
-import com.spectrayan.spector.memory.metamemory.MemoryInsight;
-import com.spectrayan.spector.memory.neurodivergent.LateralEvaluator;
-import com.spectrayan.spector.memory.pipeline.CognitiveIngestionTarget;
-import com.spectrayan.spector.memory.pipeline.RecallPipeline;
-import com.spectrayan.spector.memory.prospective.ProspectiveScheduler;
-import com.spectrayan.spector.memory.prospective.Reminder;
-import com.spectrayan.spector.memory.sync.MemoryWal;
-import com.spectrayan.spector.memory.temporal.TemporalChain;
-
-import java.time.Duration;
-import java.time.Instant;
-import java.util.List;
-import java.util.concurrent.CompletableFuture;
-
-/**
- * Primary interface for the Spector Cognitive Memory system.
- *
- * <p>Provides the full API surface for a Zero-GC cognitive backbone:
- * remember, recall, forget, reinforce, reflect, suppress, introspect,
- * prospective scheduling, working memory scratchpad, and subsystem access.</p>
- *
- * <p>Implementations include {@link DefaultSpectorMemory} (the standard
- * implementation) and metered decorators for observability.</p>
- *
- * <h3>Core API</h3>
- * <ul>
- *   <li>{@link #remember} — Ingest a memory (async, Virtual Thread)</li>
- *   <li>{@link #recall} — Fused cognitive scoring across tiers</li>
- *   <li>{@link #forget} — Tombstone a memory</li>
- *   <li>{@link #reflect} — Trigger sleep consolidation</li>
- *   <li>{@link #reinforce} — Outcome-driven valence update</li>
- *   <li>{@link #suppress} — Session-level recall suppression</li>
- *   <li>{@link #introspect} — Metamemory self-analysis</li>
- *   <li>{@link #scheduleReminder} — Prospective memory</li>
- *   <li>{@link #scratchpad} — Working memory shorthand</li>
- * </ul>
- *
- * @see DefaultSpectorMemory
- */
-public interface SpectorMemory extends AutoCloseable {
-
-    // ══════════════════════════════════════════════════════════════
-    // INGESTION TARGET
-    // ══════════════════════════════════════════════════════════════
-
-    /** Returns the cognitive ingestion target for use with the unified IngestionPipeline. */
-    CognitiveIngestionTarget target();
-
-    // ══════════════════════════════════════════════════════════════
-    // CORE API — remember / recall / forget / reflect
-    // ══════════════════════════════════════════════════════════════
-
-    /** Ingests a new memory asynchronously on a Virtual Thread. */
-    CompletableFuture<Void> remember(String id, String text, MemoryType type,
-                                      MemorySource source, String... tags);
-
-    /** Convenience overload with default source. */
-    CompletableFuture<Void> remember(String id, String text, MemoryType type,
-                                      String... tags);
-
-    /** Performs fused cognitive scoring across all relevant memory tiers. */
-    List<CognitiveResult> recall(String queryText, RecallOptions options);
-
-    /** Convenience recall using a CognitiveProfile preset. */
-    List<CognitiveResult> recall(String queryText, CognitiveProfile profile);
-
-    /** Convenience overload with default options. */
-    List<CognitiveResult> recall(String queryText);
-
-    /** Tombstones a memory by ID (logical deletion). */
-    void forget(String id);
-
-    /** Triggers a synchronous reflection (sleep consolidation) cycle. */
-    ReflectReport reflect();
-
-    // ══════════════════════════════════════════════════════════════
-    // EXTENDED API — reinforce / suppress / introspect
-    // ══════════════════════════════════════════════════════════════
-
-    /** Reports an outcome (positive/negative) for a previously recalled memory. */
-    void reinforce(String memoryId, byte valence);
-
-    /** Suppresses a memory from future recall with a reason. */
-    void suppress(String memoryId, String reason);
-
-    /** Suppresses a memory from future recall. */
-    void suppress(String memoryId);
-
-    /** Removes a suppression, allowing recall again. */
-    void unsuppress(String memoryId);
-
-    /**
-     * Marks a memory as resolved (Zeigarnik Effect).
-     * Resolved memories return to normal time-decay and gradually fade.
-     */
-    void markResolved(String memoryId);
-
-    /**
-     * Marks a memory as unresolved (Zeigarnik Effect).
-     * Unresolved memories resist time-decay and float to the top of recall.
-     */
-    void markUnresolved(String memoryId);
-
-    /** Introspects the agent's knowledge about a topic (metamemory). */
-    MemoryInsight introspect(String topic);
-
-    // ══════════════════════════════════════════════════════════════
-    // PROSPECTIVE / SCRATCHPAD / STATS
-    // ══════════════════════════════════════════════════════════════
-
-    /** Schedules a reminder at a specific instant. */
-    Reminder scheduleReminder(String text, Instant triggerAt, String... tags);
-
-    /** Schedules a reminder after a delay. */
-    Reminder scheduleReminder(String text, Duration delay, String... tags);
-
-    /** Stores ephemeral text in working memory. */
-    CompletableFuture<Void> scratchpad(String text);
-
-    /** Returns the total number of memories across all tiers. */
-    int totalMemories();
-
-    /** Returns the number of memories in a specific tier. */
-    int memoryCount(MemoryType type);
-
-    /** Explicitly decays importance of old episodic memories. */
-    int decay(Duration olderThan, float factor);
-
-    // ══════════════════════════════════════════════════════════════
-    // SUBSYSTEM ACCESSORS
-    // ══════════════════════════════════════════════════════════════
-
-    /** Returns the Hebbian co-activation tracker. */
-    CoActivationTracker coActivation();
-
-    /** Returns the Write-Ahead Log. */
-    MemoryWal wal();
-
-    /** Returns the prospective memory scheduler. */
-    ProspectiveScheduler prospective();
-
-    /** Returns the suppression set. */
-    SuppressionSet suppression();
-
-    /** Returns the habituation penalty tracker. */
-    HabituationPenalty habituation();
-
-    /** Returns the scalar quantizer used for vector compression. */
-    ScalarQuantizer quantizer();
-
-    /** Returns the cognitive ingestion target. */
-    CognitiveIngestionTarget cognitiveTarget();
-
-    /** Returns the recall pipeline. */
-    RecallPipeline recallPipeline();
-
-    /** Returns the tier router (Working, Episodic, Semantic, Procedural). */
-    TierRouter tierRouter();
-
-    /** Returns the memory index. */
-    MemoryIndex index();
-
-    /** Returns the lateral (neurodivergent) evaluator. */
-    LateralEvaluator lateralEvaluator();
-
-    // ══════════════════════════════════════════════════════════════
-    // GRAPH SUBSYSTEM ACCESSORS (3-Layer Cognitive Graph)
-    // ══════════════════════════════════════════════════════════════
-
-    /** Returns the Hebbian memory-to-memory association graph (nullable if disabled). */
-    HebbianGraph hebbianGraph();
-
-    /** Returns the temporal causal chain (nullable if disabled). */
-    TemporalChain temporalChain();
-
-    /** Returns the entity-relationship graph (nullable if disabled). */
-    EntityGraph entityGraph();
-
-    /** Closes the memory system and persists data. */
-    @Override
-    void close();
-}
-
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/amygdala/Valence.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/amygdala/Valence.java
deleted file mode 100644
index 0b789c5..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/amygdala/Valence.java
+++ /dev/null
@@ -1,79 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.amygdala;
-
-/**
- * Valence constants and utility methods.
- *
- * <h3>Biological Analog: Amygdala</h3>
- * <p>The amygdala processes emotions and tags memories with emotional significance.
- * Positive valence (joy, reward) and negative valence (fear, punishment) influence
- * which memories are recalled and how they are weighted.</p>
- *
- * <p>Valence is stored as a signed byte (-128 to +127) in the synaptic header
- * at offset 30. It is learned from <em>outcomes</em>, not guessed at encoding time.</p>
- */
-public final class Valence {
-
-    private Valence() {}
-
-    /** Strong positive outcome (e.g., agent's response solved the problem). */
-    public static final byte STRONGLY_POSITIVE = 100;
-
-    /** Mild positive outcome. */
-    public static final byte POSITIVE = 50;
-
-    /** Neutral / unknown outcome (default for new memories). */
-    public static final byte NEUTRAL = 0;
-
-    /** Mild negative outcome (e.g., response was unhelpful). */
-    public static final byte NEGATIVE = -50;
-
-    /** Strong negative outcome (e.g., response caused an error / data loss). */
-    public static final byte STRONGLY_NEGATIVE = -100;
-
-    /**
-     * Clamps a valence value to the valid range (-128 to +127).
-     */
-    public static byte clamp(int value) {
-        return (byte) Math.max(Byte.MIN_VALUE, Math.min(Byte.MAX_VALUE, value));
-    }
-
-    /**
-     * Returns true if the valence indicates a positive outcome.
-     */
-    public static boolean isPositive(byte valence) {
-        return valence > 10;
-    }
-
-    /**
-     * Returns true if the valence indicates a negative outcome.
-     */
-    public static boolean isNegative(byte valence) {
-        return valence < -10;
-    }
-
-    /**
-     * Blends two valence values with exponential moving average.
-     * New observations have more weight than old ones.
-     *
-     * @param existing current valence
-     * @param newValue  new outcome valence
-     * @param alpha    learning rate (0.0–1.0, default: 0.3)
-     * @return blended valence
-     */
-    public static byte blend(byte existing, byte newValue, float alpha) {
-        float blended = existing * (1.0f - alpha) + newValue * alpha;
-        return clamp(Math.round(blended));
-    }
-}
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/amygdala/ValenceTracker.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/amygdala/ValenceTracker.java
deleted file mode 100644
index 0feab2c..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/amygdala/ValenceTracker.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.amygdala;
-
-import com.spectrayan.spector.memory.synapse.CognitiveRecordLayout;
-import com.spectrayan.spector.memory.synapse.SynapticHeaderConstants;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.lang.foreign.MemorySegment;
-
-/**
- * Outcome-driven emotional reinforcement tracker.
- *
- * <h3>Biological Analog: Amygdala Valence Tagging</h3>
- * <p>The amygdala doesn't predict emotions at encoding time — it learns them
- * from outcomes. If a memory led to a good result, dopamine reinforces it
- * with positive valence. If it led to a bad result, cortisol tags it with
- * negative valence. This is why you instinctively avoid things that hurt you.</p>
- *
- * <h3>Design: Outcome-Driven, Not LLM-Guessed</h3>
- * <p>Valence is NOT assigned at ingestion time. It's updated via
- * {@link #reinforce(MemorySegment, long, CognitiveRecordLayout, byte)} after
- * the agent observes whether using a memory led to success or failure.
- * This gives ground-truth reinforcement, not hallucinated importance.</p>
- *
- * <h3>Learning Rate</h3>
- * <p>Uses exponential moving average with α=0.3 by default. New outcomes
- * weigh more than old ones, allowing the agent to "change its mind" about
- * a memory's value over time.</p>
- */
-public final class ValenceTracker {
-
-    private static final Logger log = LoggerFactory.getLogger(ValenceTracker.class);
-
-    private final float learningRate;
-
-    /**
-     * Creates a valence tracker.
-     *
-     * @param learningRate exponential moving average alpha (0.0–1.0, default: 0.3)
-     */
-    public ValenceTracker(float learningRate) {
-        this.learningRate = learningRate;
-    }
-
-    /**
-     * Creates a valence tracker with default learning rate (0.3).
-     */
-    public ValenceTracker() {
-        this(0.3f);
-    }
-
-    /**
-     * Reinforces a memory with an outcome valence.
-     *
-     * <p>Blends the new valence into the existing value using exponential moving average.
-     * This allows gradual learning — a memory used 10 times with positive outcomes
-     * will have strongly positive valence even if one use was negative.</p>
-     *
-     * @param segment   off-heap segment containing the record
-     * @param offset    record offset within the segment
-     * @param layout    cognitive record layout
-     * @param outcome   outcome valence (use {@link Valence} constants)
-     */
-    public void reinforce(MemorySegment segment, long offset,
-                           CognitiveRecordLayout layout, byte outcome) {
-        byte currentValence = layout.readValence(segment, offset);
-        byte blended = Valence.blend(currentValence, outcome, learningRate);
-
-        segment.set(SynapticHeaderConstants.LAYOUT_VALENCE,
-                offset + SynapticHeaderConstants.OFFSET_VALENCE, blended);
-
-        log.debug("Valence reinforced at offset {}: {} → {} (outcome={})",
-                offset, currentValence, blended, outcome);
-    }
-
-    /**
-     * Returns the learning rate.
-     */
-    public float learningRate() {
-        return learningRate;
-    }
-}
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/cortex/AbstractTierStore.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/cortex/AbstractTierStore.java
deleted file mode 100644
index 13f0582..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/cortex/AbstractTierStore.java
+++ /dev/null
@@ -1,302 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.cortex;
-
-import com.spectrayan.spector.memory.synapse.CognitiveRecordLayout;
-import com.spectrayan.spector.memory.synapse.SynapticHeaderConstants;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.io.IOException;
-import java.io.UncheckedIOException;
-import java.lang.foreign.Arena;
-import java.lang.foreign.MemorySegment;
-import java.lang.foreign.ValueLayout;
-import java.nio.ByteBuffer;
-import java.nio.channels.FileChannel;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.nio.file.StandardOpenOption;
-
-/**
- * Abstract base class for single-segment tier stores.
- *
- * <h3>Template Method Pattern</h3>
- * <p>Provides common infrastructure shared by {@link WorkingMemoryStore},
- * {@link SemanticMemoryStore}, and {@link ProceduralMemoryStore}:</p>
- * <ul>
- *   <li>Arena lifecycle (shared Arena for thread-safe access)</li>
- *   <li>Layout creation from vector byte count</li>
- *   <li>Capacity tracking and size reporting</li>
- *   <li>Segment allocation with 32-byte alignment</li>
- *   <li>Close/cleanup lifecycle</li>
- * </ul>
- *
- * <h3>Dual Mode: Volatile vs. File-Backed</h3>
- * <ul>
- *   <li><b>Volatile</b> (in-memory): {@code Arena.ofShared()} allocates off-heap RAM.
- *       Data is lost on JVM shutdown.</li>
- *   <li><b>File-backed</b> (persistent): {@code FileChannel.map()} creates a persistent
- *       mmap'd file with a 64-byte metadata header. Data survives JVM restarts.</li>
- * </ul>
- *
- * <h3>Metadata Header Layout (64 bytes)</h3>
- * <pre>
- *   [4B magic]     Offset 0  — 0x54494552 ("TIER")
- *   [4B version]   Offset 4  — format version (1)
- *   [4B count]     Offset 8  — number of live records
- *   [4B capacity]  Offset 12 — max records
- *   [4B stride]    Offset 16 — record stride in bytes
- *   [4B tierOrd]   Offset 20 — MemoryType ordinal
- *   [4B extra1]    Offset 24 — subclass-specific (e.g., writeIndex for Working)
- *   [4B extra2]    Offset 28 — reserved for subclass use
- *   [32B reserved] Offset 32 — future use
- * </pre>
- *
- * <p>{@link EpisodicMemoryStore} implements {@link TierStore} directly because
- * it uses mmap-backed partitions rather than a single Arena-allocated segment.</p>
- *
- * @see TierStore for the common interface
- */
-public abstract class AbstractTierStore implements TierStore {
-
-    private static final Logger log = LoggerFactory.getLogger(AbstractTierStore.class);
-
-    /** Metadata header magic: "TIER" in ASCII. */
-    static final int TIER_MAGIC = 0x54494552;
-
-    /** Metadata header format version. */
-    static final int TIER_VERSION = 1;
-
-    /** Size of the metadata header in bytes. */
-    public static final int METADATA_HEADER_BYTES = 64;
-
-    // Metadata field offsets
-    static final int META_MAGIC    = 0;
-    static final int META_VERSION  = 4;
-    static final int META_COUNT    = 8;
-    static final int META_CAPACITY = 12;
-    static final int META_STRIDE   = 16;
-    static final int META_TIER_ORD = 20;
-    static final int META_EXTRA1   = 24;
-    static final int META_EXTRA2   = 28;
-
-    protected final CognitiveRecordLayout layout;
-    protected final int capacity;
-    protected final Arena arena;
-    protected final MemorySegment segment;
-    protected int count = 0;
-
-    /** True if this store is backed by a file (persistent). */
-    protected final boolean persistent;
-
-    /** File channel for persistent stores (null for volatile). */
-    private FileChannel fileChannel;
-
-    /** File path for persistent stores (null for volatile). */
-    private final Path filePath;
-
-    /**
-     * Volatile constructor — allocates a single contiguous off-heap segment (no file).
-     *
-     * @param quantizedVecBytes bytes per quantized vector
-     * @param capacity          maximum number of records
-     * @param segmentBytes      total bytes to allocate (caller decides header-only vs full)
-     */
-    protected AbstractTierStore(int quantizedVecBytes, int capacity, long segmentBytes) {
-        this.layout = new CognitiveRecordLayout(quantizedVecBytes);
-        this.capacity = capacity;
-        this.arena = Arena.ofShared();
-        this.segment = arena.allocate(segmentBytes, SynapticHeaderConstants.HEADER_BYTES);
-        this.persistent = false;
-        this.filePath = null;
-    }
-
-    /**
-     * File-backed constructor — creates or opens a persistent mmap'd file.
-     *
-     * <p>If the file already exists and contains a valid metadata header, the
-     * store's state ({@code count}) is restored from it. Otherwise, a new
-     * file is created with a fresh metadata header.</p>
-     *
-     * @param quantizedVecBytes bytes per quantized vector
-     * @param capacity          maximum number of records
-     * @param segmentBytes      total data bytes (excluding metadata header)
-     * @param filePath          path to the backing file
-     */
-    protected AbstractTierStore(int quantizedVecBytes, int capacity, long segmentBytes, Path filePath) {
-        this.layout = new CognitiveRecordLayout(quantizedVecBytes);
-        this.capacity = capacity;
-        this.persistent = true;
-        this.filePath = filePath;
-        this.arena = Arena.ofShared();
-
-        try {
-            // Ensure parent directories exist
-            Path parent = filePath.getParent();
-            if (parent != null) {
-                Files.createDirectories(parent);
-            }
-
-            long totalBytes = METADATA_HEADER_BYTES + segmentBytes;
-            boolean isNew = !Files.exists(filePath) || Files.size(filePath) < METADATA_HEADER_BYTES;
-
-            fileChannel = FileChannel.open(filePath,
-                    StandardOpenOption.CREATE,
-                    StandardOpenOption.READ,
-                    StandardOpenOption.WRITE);
-
-            if (isNew) {
-                // Extend file to full size
-                fileChannel.position(totalBytes - 1);
-                fileChannel.write(ByteBuffer.wrap(new byte[]{0}));
-            }
-
-            // Map the entire file
-            long mapSize = Math.max(totalBytes, fileChannel.size());
-            this.segment = fileChannel.map(FileChannel.MapMode.READ_WRITE, 0, mapSize, arena);
-
-            if (isNew) {
-                // Write fresh metadata header
-                this.count = 0;
-                writeMetadata();
-                log.info("{} created new persistent file: {} ({}KB)",
-                        getClass().getSimpleName(), filePath, totalBytes / 1024);
-            } else {
-                // Restore state from existing file
-                readMetadata();
-                log.info("{} loaded from persistent file: {} ({} records)",
-                        getClass().getSimpleName(), filePath, count);
-            }
-        } catch (IOException e) {
-            throw new UncheckedIOException("Cannot create/open persistent tier store: " + filePath, e);
-        }
-    }
-
-    /**
-     * Writes the metadata header to the mapped segment.
-     * Called on creation and after count changes.
-     */
-    protected void writeMetadata() {
-        if (!persistent) return;
-        segment.set(ValueLayout.JAVA_INT, META_MAGIC, TIER_MAGIC);
-        segment.set(ValueLayout.JAVA_INT, META_VERSION, TIER_VERSION);
-        segment.set(ValueLayout.JAVA_INT, META_COUNT, count);
-        segment.set(ValueLayout.JAVA_INT, META_CAPACITY, capacity);
-        segment.set(ValueLayout.JAVA_INT, META_STRIDE, layout.stride());
-        segment.set(ValueLayout.JAVA_INT, META_TIER_ORD, type().ordinal());
-    }
-
-    /**
-     * Reads the metadata header from the mapped segment.
-     * Called when loading from an existing file.
-     */
-    protected void readMetadata() {
-        int magic = segment.get(ValueLayout.JAVA_INT, META_MAGIC);
-        if (magic != TIER_MAGIC) {
-            log.warn("Invalid tier magic in {}: 0x{} (expected 0x{})",
-                    filePath, Integer.toHexString(magic), Integer.toHexString(TIER_MAGIC));
-            this.count = 0;
-            return;
-        }
-        this.count = segment.get(ValueLayout.JAVA_INT, META_COUNT);
-    }
-
-    /**
-     * Persists the current count to the metadata header.
-     * Subclasses should call this after modifying {@code count}.
-     */
-    protected void persistCount() {
-        if (persistent) {
-            segment.set(ValueLayout.JAVA_INT, META_COUNT, count);
-        }
-    }
-
-    /**
-     * Returns the byte offset where data records begin.
-     * For persistent stores, records start after the metadata header.
-     * For volatile stores, records start at offset 0.
-     */
-    protected long dataOffset() {
-        return persistent ? METADATA_HEADER_BYTES : 0;
-    }
-
-    @Override
-    public int size() {
-        return count;
-    }
-
-    @Override
-    public CognitiveRecordLayout layout() {
-        return layout;
-    }
-
-    @Override
-    public MemorySegment primarySegment() {
-        return segment;
-    }
-
-    /**
-     * Returns the maximum capacity of this store.
-     */
-    public int capacity() {
-        return capacity;
-    }
-
-    /**
-     * Returns the backing memory segment for direct scorer access.
-     */
-    public MemorySegment segment() {
-        return segment;
-    }
-
-    /**
-     * Returns whether this store is file-backed (persistent).
-     */
-    public boolean isPersistent() {
-        return persistent;
-    }
-
-    /**
-     * Forces the mapped segment to be written to the underlying file (persistent only).
-     */
-    public void force() {
-        if (persistent && segment != null) {
-            segment.force();
-        }
-    }
-
-    @Override
-    public void close() {
-        log.info("{} closing ({} records, persistent={})", getClass().getSimpleName(), count, persistent);
-        if (persistent) {
-            try {
-                if (segment != null) {
-                    segment.force();
-                }
-            } catch (Exception e) {
-                log.debug("Error forcing segment: {}", e.getMessage());
-            }
-        }
-        arena.close();
-        if (fileChannel != null) {
-            try {
-                fileChannel.close();
-            } catch (IOException e) {
-                log.debug("Error closing file channel: {}", e.getMessage());
-            }
-        }
-    }
-}
-
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/cortex/CentroidRouter.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/cortex/CentroidRouter.java
deleted file mode 100644
index eb990ef..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/cortex/CentroidRouter.java
+++ /dev/null
@@ -1,236 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.cortex;
-
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-import com.spectrayan.spector.commons.error.ErrorCode;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-/**
- * Routes memories to IVF centroid partitions for spatial pre-filtering.
- *
- * <h3>Biological Analog: Cortical Columns</h3>
- * <p>Physical grouping of neurons by function. The brain clusters related concepts
- * into cortical columns for efficient activation — Spector clusters memories by
- * vector proximity for cache-efficient scanning.</p>
- *
- * <h3>Dual-Path Routing</h3>
- * <p>This provides <b>Path A: Spatial Routing</b> ("Where").
- * The synaptic tag Bloom filter provides <b>Path B: Semantic Filtering</b> ("What").
- * Together, they enable two-stage pre-filtering before expensive SIMD distance
- * computation.</p>
- *
- * <h3>Centroid Drift (Neurogenesis)</h3>
- * <p>Over time, new topics emerge. The {@link #recalibrate(float[][], int)}
- * method recalculates centroid positions from actual vector distributions,
- * splitting partitions that exceed a variance threshold — analogous to
- * hippocampal neurogenesis.</p>
- *
- * @see com.spectrayan.spector.memory.synapse.SynapticHeaderConstants#OFFSET_CENTROID_ID
- */
-public final class CentroidRouter {
-
-    private static final Logger log = LoggerFactory.getLogger(CentroidRouter.class);
-
-    /** Maximum number of centroids (IVF partitions). */
-    private static final int MAX_CENTROIDS = 256;
-
-    /** Default number of initial centroids. */
-    private static final int DEFAULT_K = 16;
-
-    /** Variance threshold for partition splitting during recalibration. */
-    private static final float SPLIT_VARIANCE_THRESHOLD = 2.0f;
-
-    private final int dimensions;
-    private float[][] centroids;
-    private int activeCentroids;
-
-    /**
-     * Creates a router with default centroid count.
-     *
-     * @param dimensions vector dimensions
-     */
-    public CentroidRouter(int dimensions) {
-        this(dimensions, DEFAULT_K);
-    }
-
-    /**
-     * Creates a router with a specified number of initial centroids.
-     *
-     * @param dimensions      vector dimensions
-     * @param initialCentroids number of initial centroid slots
-     */
-    public CentroidRouter(int dimensions, int initialCentroids) {
-        this.dimensions = dimensions;
-        this.activeCentroids = Math.min(initialCentroids, MAX_CENTROIDS);
-        this.centroids = new float[MAX_CENTROIDS][dimensions];
-        log.info("CentroidRouter initialized: dimensions={}, initialCentroids={}",
-                dimensions, activeCentroids);
-    }
-
-    /**
-     * Assigns the nearest centroid ID for a given vector.
-     *
-     * <p>Computes L2 distance to all active centroids and returns the ID of
-     * the nearest. This value is written to the {@code centroid_id} field
-     * at offset 24 in the cognitive header.</p>
-     *
-     * @param vector the memory vector
-     * @return centroid ID (0 to activeCentroids-1), or 0 if no centroids are initialized
-     */
-    public int assignCentroid(float[] vector) {
-        if (activeCentroids == 0) return 0;
-
-        int bestId = 0;
-        float bestDist = Float.MAX_VALUE;
-
-        for (int c = 0; c < activeCentroids; c++) {
-            float dist = l2Distance(vector, centroids[c]);
-            if (dist < bestDist) {
-                bestDist = dist;
-                bestId = c;
-            }
-        }
-
-        return bestId;
-    }
-
-    /**
-     * Updates centroid positions from a sample of vectors.
-     *
-     * <p>This is analogous to <b>neurogenesis</b> — the brain creates new neurons
-     * to accommodate new categories of experience. Called periodically by the
-     * ReflectDaemon during sleep consolidation.</p>
-     *
-     * <p>Algorithm:</p>
-     * <ol>
-     *   <li>Assign each sample vector to its nearest centroid</li>
-     *   <li>Recompute centroid positions as cluster means</li>
-     *   <li>If any partition's internal variance exceeds the threshold, split it</li>
-     * </ol>
-     *
-     * @param sampleVectors representative sample of recent memory vectors
-     * @param iterations    number of Lloyd's iterations (default: 5)
-     * @return number of active centroids after recalibration
-     */
-    public int recalibrate(float[][] sampleVectors, int iterations) {
-        if (sampleVectors == null || sampleVectors.length == 0) return activeCentroids;
-        if (activeCentroids == 0) {
-            // Bootstrap: initialize first centroids from sample
-            activeCentroids = Math.min(DEFAULT_K, sampleVectors.length);
-            for (int c = 0; c < activeCentroids; c++) {
-                System.arraycopy(sampleVectors[c], 0, centroids[c], 0, dimensions);
-            }
-        }
-
-        // Run mini k-means (Lloyd's algorithm)
-        for (int iter = 0; iter < iterations; iter++) {
-            // Accumulate per-centroid sums and counts
-            float[][] sums = new float[activeCentroids][dimensions];
-            int[] counts = new int[activeCentroids];
-            float[] variances = new float[activeCentroids];
-
-            for (float[] vec : sampleVectors) {
-                int nearest = assignCentroid(vec);
-                counts[nearest]++;
-                for (int d = 0; d < dimensions; d++) {
-                    sums[nearest][d] += vec[d];
-                }
-            }
-
-            // Update centroid positions
-            for (int c = 0; c < activeCentroids; c++) {
-                if (counts[c] > 0) {
-                    for (int d = 0; d < dimensions; d++) {
-                        centroids[c][d] = sums[c][d] / counts[c];
-                    }
-                }
-            }
-
-            // Compute variance for splitting check (last iteration only)
-            if (iter == iterations - 1) {
-                for (float[] vec : sampleVectors) {
-                    int nearest = assignCentroid(vec);
-                    variances[nearest] += l2Distance(vec, centroids[nearest]);
-                }
-                for (int c = 0; c < activeCentroids; c++) {
-                    if (counts[c] > 0) {
-                        variances[c] /= counts[c];
-                    }
-                }
-
-                // Split high-variance partitions
-                for (int c = 0; c < activeCentroids && activeCentroids < MAX_CENTROIDS; c++) {
-                    if (variances[c] > SPLIT_VARIANCE_THRESHOLD && counts[c] > 10) {
-                        splitCentroid(c);
-                        log.info("Centroid {} split (variance={:.3f}). Active centroids: {}",
-                                c, variances[c], activeCentroids);
-                    }
-                }
-            }
-        }
-
-        log.debug("Recalibration complete: {} active centroids", activeCentroids);
-        return activeCentroids;
-    }
-
-    /**
-     * Returns whether a centroid is geometrically close enough to a query vector
-     * to warrant scanning its partition.
-     *
-     * @param centroidId    the centroid to check
-     * @param queryVector   the query vector
-     * @param maxDistance    maximum L2 distance threshold for partition inclusion
-     * @return true if the partition should be scanned
-     */
-    public boolean shouldScanPartition(int centroidId, float[] queryVector, float maxDistance) {
-        if (centroidId < 0 || centroidId >= activeCentroids) return true; // safety: scan if unknown
-        return l2Distance(queryVector, centroids[centroidId]) <= maxDistance;
-    }
-
-    /**
-     * Returns the number of active centroids.
-     */
-    public int activeCentroids() {
-        return activeCentroids;
-    }
-
-    /**
-     * Returns the centroid vector for a given ID.
-     */
-    public float[] centroid(int id) {
-        if (id < 0 || id >= activeCentroids) throw new SpectorValidationException(ErrorCode.ARGUMENT_OUT_OF_RANGE, "centroidId", 0, activeCentroids - 1, id);
-        return centroids[id].clone();
-    }
-
-    // ── Internal ──
-
-    private void splitCentroid(int centroidId) {
-        // Create a new centroid by perturbing the existing one
-        int newId = activeCentroids++;
-        for (int d = 0; d < dimensions; d++) {
-            centroids[newId][d] = centroids[centroidId][d] + 0.01f * (d % 2 == 0 ? 1 : -1);
-        }
-    }
-
-    private float l2Distance(float[] a, float[] b) {
-        float sum = 0f;
-        for (int i = 0; i < a.length; i++) {
-            float diff = a[i] - b[i];
-            sum += diff * diff;
-        }
-        return (float) Math.sqrt(sum);
-    }
-}
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/cortex/EpisodicMemoryStore.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/cortex/EpisodicMemoryStore.java
deleted file mode 100644
index 0363b5a..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/cortex/EpisodicMemoryStore.java
+++ /dev/null
@@ -1,616 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.cortex;
-
-import com.spectrayan.spector.memory.MemoryType;
-import com.spectrayan.spector.memory.synapse.CognitiveRecordLayout;
-import com.spectrayan.spector.memory.synapse.CognitiveRecordLayout.CognitiveHeader;
-import com.spectrayan.spector.memory.synapse.SynapticHeaderConstants;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.io.IOException;
-import java.io.UncheckedIOException;
-import java.lang.foreign.Arena;
-import java.lang.foreign.MemorySegment;
-import java.nio.ByteBuffer;
-import java.nio.ByteOrder;
-import java.nio.channels.FileChannel;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.nio.file.StandardOpenOption;
-import java.time.Instant;
-import java.time.LocalDate;
-import java.time.ZoneId;
-import java.time.format.DateTimeFormatter;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ConcurrentMap;
-import com.spectrayan.spector.commons.error.SpectorServerException;
-import com.spectrayan.spector.memory.error.SpectorMemoryTierFullException;
-import com.spectrayan.spector.commons.error.ErrorCode;
-
-/**
- * Time-partitioned mmap store for Episodic memory.
- *
- * <h3>Biological Analog: Hippocampus</h3>
- * <p>The hippocampus encodes events as time-ordered episodic traces. New events are
- * appended rapidly (one-trial learning), and during sleep the hippocampus replays
- * sequences for consolidation into cortical (semantic) memory.</p>
- *
- * <h3>V3 Design: Persistent mmap via FileChannel.map()</h3>
- * <ul>
- *   <li>One partition per time window (default: 1 day)</li>
- *   <li>Append-only within each partition — O(1) inserts, no graph rewiring</li>
- *   <li>Uses {@link CognitiveRecordLayout} for each record</li>
- *   <li>Flat SIMD scan per partition via the scorer</li>
- *   <li>Persistent across JVM restarts via {@code FileChannel.map()}</li>
- *   <li>64-byte metadata header per partition file tracks count, state, capacity</li>
- *   <li>Lazy mmap for old partitions (only mapped when scanned)</li>
- * </ul>
- *
- * <h3>Partition Lifecycle</h3>
- * <pre>
- *   active → sealed → reflectable → tombstoned → compacted
- * </pre>
- */
-public final class EpisodicMemoryStore implements TierStore {
-
-    private static final Logger log = LoggerFactory.getLogger(EpisodicMemoryStore.class);
-    private static final DateTimeFormatter PARTITION_FORMAT = DateTimeFormatter.ofPattern("yyyyMMdd");
-
-    private final Path basePath;
-    private final CognitiveRecordLayout layout;
-    private final int partitionCapacity;
-
-    // Active partition state
-    private final ConcurrentMap<String, EpisodicPartition> partitions = new ConcurrentHashMap<>();
-
-    /**
-     * Creates a new Episodic Memory store.
-     *
-     * <p>On construction, scans {@code basePath} for existing partition files and
-     * loads them as sealed partitions (lazy mmap). New partitions are created
-     * on demand when {@link #append} is called.</p>
-     *
-     * @param basePath           directory for partition files
-     * @param quantizedVecBytes  bytes per quantized vector
-     * @param partitionCapacity  max records per partition (default: 10_000)
-     */
-    public EpisodicMemoryStore(Path basePath, int quantizedVecBytes, int partitionCapacity) {
-        this.basePath = basePath;
-        this.layout = new CognitiveRecordLayout(quantizedVecBytes);
-        this.partitionCapacity = partitionCapacity;
-
-        try {
-            Files.createDirectories(basePath);
-        } catch (IOException e) {
-            throw new UncheckedIOException("Cannot create episodic store directory: " + basePath, e);
-        }
-
-        // Load existing partition files from disk
-        loadExistingPartitions();
-
-        log.info("EpisodicMemoryStore initialized: path={}, stride={}B, partitionCapacity={}, loaded={}",
-                basePath, layout.stride(), partitionCapacity, partitions.size());
-    }
-
-    /**
-     * Appends a new memory to the current day's partition.
-     *
-     * @param header       cognitive header
-     * @param quantizedVec quantized vector bytes
-     */
-    public void append(CognitiveHeader header, byte[] quantizedVec) {
-        String partitionKey = currentPartitionKey();
-        EpisodicPartition partition = partitions.computeIfAbsent(partitionKey,
-                k -> createPartition(k));
-        partition.append(header, quantizedVec);
-    }
-
-    /**
-     * Returns all partitions for scanning during recall.
-     */
-    public List<EpisodicPartition> partitions() {
-        return new ArrayList<>(partitions.values());
-    }
-
-    /**
-     * Returns the partition count.
-     */
-    public int partitionCount() {
-        return partitions.size();
-    }
-
-    /**
-     * Returns the total record count across all partitions.
-     */
-    public int totalRecords() {
-        return partitions.values().stream().mapToInt(EpisodicPartition::count).sum();
-    }
-
-    /**
-     * Returns the layout for this store.
-     */
-    public CognitiveRecordLayout layout() {
-        return layout;
-    }
-
-    @Override
-    public MemoryType type() {
-        return MemoryType.EPISODIC;
-    }
-
-    @Override
-    public int size() {
-        return totalRecords();
-    }
-
-    @Override
-    public java.lang.foreign.MemorySegment primarySegment() {
-        var parts = partitions();
-        return parts.isEmpty() ? null : parts.getLast().segment();
-    }
-
-    @Override
-    public long write(CognitiveHeader header, byte[] quantizedVec) {
-        append(header, quantizedVec);
-        var parts = partitions();
-        if (!parts.isEmpty()) {
-            var lastPartition = parts.getLast();
-            // Offset must include METADATA_HEADER_BYTES to match what CognitiveScorer
-            // returns during recall scanning (baseOffset = METADATA_HEADER_BYTES)
-            return lastPartition.recordOffset(lastPartition.count() - 1);
-        }
-        return 0L;
-    }
-
-    /**
-     * Atomically replaces a partition in the map.
-     *
-     * <p>Used by {@code TombstoneCompactor} after rebuilding a compacted partition.
-     * The old partition is closed after replacement.</p>
-     *
-     * @param key          the partition key
-     * @param oldPartition the partition being replaced
-     * @param newPartition the compacted replacement
-     * @return true if the swap was successful
-     */
-    public boolean replacePartition(String key, EpisodicPartition oldPartition,
-                                     EpisodicPartition newPartition) {
-        boolean replaced = partitions.replace(key, oldPartition, newPartition);
-        if (replaced) {
-            oldPartition.close();
-            log.info("Partition '{}' replaced: {} → {} records",
-                    key, oldPartition.count(), newPartition.count());
-        }
-        return replaced;
-    }
-
-    /**
-     * Returns the partition key for a given partition, or null if not found.
-     */
-    public String keyForPartition(EpisodicPartition partition) {
-        for (var entry : partitions.entrySet()) {
-            if (entry.getValue() == partition) {
-                return entry.getKey();
-            }
-        }
-        return null;
-    }
-
-    private String currentPartitionKey() {
-        return LocalDate.now().format(PARTITION_FORMAT);
-    }
-
-    private EpisodicPartition createPartition(String key) {
-        Path partitionPath = basePath.resolve("episodic-" + key + ".mem");
-        log.info("Creating new episodic partition: {}", partitionPath);
-        return new EpisodicPartition(partitionPath, layout, partitionCapacity, true);
-    }
-
-    /**
-     * Scans the base directory for existing partition files and loads them.
-     * Existing partitions are loaded in SEALED state (read-only until today's
-     * partition is accessed).
-     */
-    private void loadExistingPartitions() {
-        try {
-            if (!Files.isDirectory(basePath)) return;
-
-            try (var stream = Files.list(basePath)) {
-                stream.filter(p -> {
-                            String name = p.getFileName().toString();
-                            return name.startsWith("episodic-") && name.endsWith(".mem");
-                        })
-                        .forEach(p -> {
-                            String name = p.getFileName().toString();
-                            // Extract key: "episodic-{key}.mem" or "episodic-{key}-compacted.mem"
-                            String key = name.replace("episodic-", "")
-                                    .replace("-compacted.mem", "")
-                                    .replace(".mem", "");
-                            try {
-                                EpisodicPartition partition = new EpisodicPartition(p, layout, partitionCapacity, false);
-                                partitions.putIfAbsent(key, partition);
-                                log.debug("Loaded existing partition: {} ({} records, state={})",
-                                        key, partition.count(), partition.state());
-                            } catch (Exception e) {
-                                log.warn("Failed to load partition {}: {}", p, e.getMessage());
-                            }
-                        });
-            }
-        } catch (IOException e) {
-            log.warn("Error scanning for existing partitions: {}", e.getMessage());
-        }
-    }
-
-    @Override
-    public void close() {
-        log.info("EpisodicMemoryStore closing ({} partitions, {} records)",
-                partitions.size(), totalRecords());
-        partitions.values().forEach(EpisodicPartition::close);
-        partitions.clear();
-    }
-
-    // ── Inner class: single partition ──
-
-    /**
-     * Partition lifecycle states.
-     */
-    public enum PartitionState {
-        /** Currently accepting writes. */
-        ACTIVE,
-        /** No more writes; available for scanning. */
-        SEALED,
-        /** Eligible for sleep consolidation (ReflectDaemon). */
-        REFLECTABLE,
-        /** Tombstone ratio exceeds threshold; queued for compaction. */
-        TOMBSTONED,
-        /** Has been rebuilt by TombstoneCompactor. */
-        COMPACTED
-    }
-
-    /**
-     * A single time-partitioned episodic memory file.
-     *
-     * <h3>V3: Persistent mmap via FileChannel.map()</h3>
-     * <p>Each partition is backed by an mmap'd file. The first {@value #METADATA_HEADER_BYTES}
-     * bytes contain a metadata header tracking record count, tombstone count, capacity,
-     * and partition state. Records begin at offset {@value #METADATA_HEADER_BYTES}.</p>
-     *
-     * <h3>Metadata Header Layout (64 bytes)</h3>
-     * <pre>
-     *   [4B magic]          Offset 0  — 0x45504943 ("EPIC")
-     *   [4B version]        Offset 4  — format version (1)
-     *   [4B count]          Offset 8  — number of live records
-     *   [4B tombstoneCount] Offset 12 — number of tombstoned records
-     *   [4B capacity]       Offset 16 — max records in this partition
-     *   [4B state]          Offset 20 — PartitionState ordinal
-     *   [4B stride]         Offset 24 — record stride in bytes
-     *   [36B reserved]      Offset 28 — reserved for future use
-     * </pre>
-     */
-    public static final class EpisodicPartition {
-
-        /** Partition file magic: "EPIC" in ASCII. */
-        static final int PARTITION_MAGIC = 0x45504943;
-
-        /** Partition format version. */
-        static final int PARTITION_VERSION = 1;
-
-        /** Size of the metadata header in bytes. */
-        public static final int METADATA_HEADER_BYTES = 64;
-
-        // Metadata field offsets
-        private static final int META_MAGIC           = 0;
-        private static final int META_VERSION         = 4;
-        private static final int META_COUNT           = 8;
-        private static final int META_TOMBSTONE_COUNT = 12;
-        private static final int META_CAPACITY        = 16;
-        private static final int META_STATE           = 20;
-        private static final int META_STRIDE          = 24;
-
-        private final Path path;
-        private final CognitiveRecordLayout layout;
-        private final Arena arena;
-        private MemorySegment segment;
-        private final int capacity;
-        private int count;
-        private int tombstoneCount;
-        private PartitionState state;
-
-        private FileChannel fileChannel;
-
-        /**
-         * Creates or opens an episodic partition.
-         *
-         * @param path     path to the partition file
-         * @param layout   the cognitive record layout
-         * @param capacity max records for this partition
-         * @param isNew    true to create a new partition, false to load existing
-         */
-        public EpisodicPartition(Path path, CognitiveRecordLayout layout, int capacity, boolean isNew) {
-            this.path = path;
-            this.layout = layout;
-            this.capacity = capacity;
-            this.arena = Arena.ofShared();
-
-            if (isNew) {
-                createNewPartition();
-            } else {
-                loadExistingPartition();
-            }
-        }
-
-        /**
-         * Creates a new partition file with metadata header and mmap'd segment.
-         */
-        private void createNewPartition() {
-            try {
-                long totalBytes = METADATA_HEADER_BYTES + (long) layout.stride() * capacity;
-
-                fileChannel = FileChannel.open(path,
-                        StandardOpenOption.CREATE,
-                        StandardOpenOption.READ,
-                        StandardOpenOption.WRITE);
-
-                // Extend the file to full size
-                fileChannel.position(totalBytes - 1);
-                fileChannel.write(ByteBuffer.wrap(new byte[]{0}));
-
-                // Map the entire file
-                segment = fileChannel.map(FileChannel.MapMode.READ_WRITE, 0, totalBytes, arena);
-
-                // Write metadata header
-                this.count = 0;
-                this.tombstoneCount = 0;
-                this.state = PartitionState.ACTIVE;
-                writeMetadata();
-
-            } catch (IOException e) {
-                throw new UncheckedIOException("Cannot create partition: " + path, e);
-            }
-        }
-
-        /**
-         * Loads an existing partition file — reads metadata header, then mmaps.
-         */
-        private void loadExistingPartition() {
-            try {
-                if (!Files.exists(path)) {
-                    // Fallback: create as new if file doesn't exist
-                    createNewPartition();
-                    return;
-                }
-
-                fileChannel = FileChannel.open(path,
-                        StandardOpenOption.READ,
-                        StandardOpenOption.WRITE);
-
-                long fileSize = fileChannel.size();
-                if (fileSize < METADATA_HEADER_BYTES) {
-                    log.warn("Partition file too small ({}B), creating fresh: {}", fileSize, path);
-                    fileChannel.close();
-                    createNewPartition();
-                    return;
-                }
-
-                // Map the entire file
-                segment = fileChannel.map(FileChannel.MapMode.READ_WRITE, 0, fileSize, arena);
-
-                // Read metadata header
-                readMetadata();
-
-                // If loaded partition is today's date, keep it ACTIVE
-                String fileName = path.getFileName().toString();
-                String today = LocalDate.now().format(PARTITION_FORMAT);
-                if (fileName.contains(today) && state == PartitionState.ACTIVE) {
-                    // Keep ACTIVE — it's today's partition
-                } else if (state == PartitionState.ACTIVE) {
-                    // Older partitions default to SEALED on load
-                    this.state = PartitionState.SEALED;
-                    writeMetadata();
-                }
-
-            } catch (IOException e) {
-                throw new UncheckedIOException("Cannot load partition: " + path, e);
-            }
-        }
-
-        /**
-         * Writes the metadata header to the mapped segment.
-         */
-        private void writeMetadata() {
-            segment.set(java.lang.foreign.ValueLayout.JAVA_INT, META_MAGIC, PARTITION_MAGIC);
-            segment.set(java.lang.foreign.ValueLayout.JAVA_INT, META_VERSION, PARTITION_VERSION);
-            segment.set(java.lang.foreign.ValueLayout.JAVA_INT, META_COUNT, count);
-            segment.set(java.lang.foreign.ValueLayout.JAVA_INT, META_TOMBSTONE_COUNT, tombstoneCount);
-            segment.set(java.lang.foreign.ValueLayout.JAVA_INT, META_CAPACITY, capacity);
-            segment.set(java.lang.foreign.ValueLayout.JAVA_INT, META_STATE, state.ordinal());
-            segment.set(java.lang.foreign.ValueLayout.JAVA_INT, META_STRIDE, layout.stride());
-        }
-
-        /**
-         * Reads the metadata header from the mapped segment.
-         */
-        private void readMetadata() {
-            int magic = segment.get(java.lang.foreign.ValueLayout.JAVA_INT, META_MAGIC);
-            if (magic != PARTITION_MAGIC) {
-                log.warn("Invalid partition magic in {}: 0x{} (expected 0x{})",
-                        path, Integer.toHexString(magic), Integer.toHexString(PARTITION_MAGIC));
-                // Treat as empty
-                this.count = 0;
-                this.tombstoneCount = 0;
-                this.state = PartitionState.ACTIVE;
-                return;
-            }
-
-            this.count = segment.get(java.lang.foreign.ValueLayout.JAVA_INT, META_COUNT);
-            this.tombstoneCount = segment.get(java.lang.foreign.ValueLayout.JAVA_INT, META_TOMBSTONE_COUNT);
-
-            int stateOrd = segment.get(java.lang.foreign.ValueLayout.JAVA_INT, META_STATE);
-            if (stateOrd >= 0 && stateOrd < PartitionState.values().length) {
-                this.state = PartitionState.values()[stateOrd];
-            } else {
-                this.state = PartitionState.ACTIVE;
-            }
-        }
-
-        /**
-         * Appends a record to this partition.
-         *
-         * <p>Records are stored after the metadata header. The offset for record
-         * {@code i} is {@code METADATA_HEADER_BYTES + i * stride}.</p>
-         */
-        public synchronized void append(CognitiveHeader header, byte[] quantizedVec) {
-            if (count >= capacity) {
-                throw new SpectorMemoryTierFullException("EPISODIC", capacity);
-            }
-
-            long offset = recordOffset(count);
-            layout.writeHeader(segment, offset, header);
-            MemorySegment.copy(
-                    MemorySegment.ofArray(quantizedVec), 0,
-                    segment, layout.vectorOffset(offset),
-                    quantizedVec.length
-            );
-            count++;
-
-            // Update count in metadata header
-            segment.set(java.lang.foreign.ValueLayout.JAVA_INT, META_COUNT, count);
-        }
-
-        /**
-         * Computes the byte offset for record at logical index {@code i}.
-         *
-         * <p>Offset includes the metadata header:
-         * {@code METADATA_HEADER_BYTES + i * stride}</p>
-         *
-         * @param recordIndex logical record index (0-based)
-         * @return byte offset in the mapped segment
-         */
-        public long recordOffset(int recordIndex) {
-            return METADATA_HEADER_BYTES + (long) recordIndex * layout.stride();
-        }
-
-        /**
-         * Returns the number of records in this partition.
-         */
-        public int count() {
-            return count;
-        }
-
-        /**
-         * Returns the tombstone count.
-         */
-        public int tombstoneCount() {
-            return tombstoneCount;
-        }
-
-        /**
-         * Returns the tombstone ratio (0.0 to 1.0).
-         */
-        public float tombstoneRatio() {
-            return count == 0 ? 0f : (float) tombstoneCount / count;
-        }
-
-        /**
-         * Increments the tombstone counter and persists to metadata.
-         */
-        public void incrementTombstoneCount() {
-            tombstoneCount++;
-            segment.set(java.lang.foreign.ValueLayout.JAVA_INT, META_TOMBSTONE_COUNT, tombstoneCount);
-        }
-
-        /**
-         * Returns the backing segment for scanning.
-         */
-        public MemorySegment segment() {
-            return segment;
-        }
-
-        /**
-         * Returns the partition file path.
-         */
-        public Path path() {
-            return path;
-        }
-
-        /**
-         * Returns the layout.
-         */
-        public CognitiveRecordLayout layout() {
-            return layout;
-        }
-
-        /**
-         * Returns the capacity.
-         */
-        public int capacity() {
-            return capacity;
-        }
-
-        /**
-         * Returns the current partition state.
-         */
-        public PartitionState state() {
-            return state;
-        }
-
-        /**
-         * Seals this partition — prevents further writes.
-         */
-        public synchronized void seal() {
-            this.state = PartitionState.SEALED;
-            writeMetadata();
-            log.debug("Partition sealed: {} ({} records)", path, count);
-        }
-
-        /**
-         * Sets the partition state.
-         */
-        public synchronized void setState(PartitionState newState) {
-            this.state = newState;
-            writeMetadata();
-        }
-
-        /**
-         * Forces the mapped segment to be written to the underlying file.
-         */
-        public void force() {
-            if (segment != null) {
-                segment.force();
-            }
-        }
-
-        public void close() {
-            try {
-                if (segment != null) {
-                    segment.force();
-                }
-            } catch (Exception e) {
-                log.debug("Error forcing segment: {}", e.getMessage());
-            }
-            arena.close();
-            try {
-                if (fileChannel != null) {
-                    fileChannel.close();
-                }
-            } catch (IOException e) {
-                log.debug("Error closing file channel: {}", e.getMessage());
-            }
-        }
-    }
-}
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/cortex/MemorySource.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/cortex/MemorySource.java
deleted file mode 100644
index 0cbe15c..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/cortex/MemorySource.java
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.cortex;
-
-/**
- * Provenance tracking for memory source monitoring.
- *
- * <h3>Biological Analog: Source Monitoring / Reality Monitoring</h3>
- * <p>Knowing <em>where</em> a memory came from — did I see it, hear it, read it, or
- * imagine it? Failure of source monitoring causes confabulation ("false memories") —
- * you genuinely remember something that never happened.</p>
- *
- * <p>Each source carries a confidence weight that influences how much the LLM
- * should trust the memory during recall.</p>
- */
-public enum MemorySource {
-
-    /**
-     * Agent directly processed this content (observed during a task).
-     */
-    OBSERVED(0.9f),
-
-    /**
-     * Explicitly stated by the user (highest trust — ground truth).
-     */
-    USER_STATED(1.0f),
-
-    /**
-     * Synthesized by the ReflectDaemon from an episodic cluster.
-     * Lower confidence because it's a computed summary, not raw observation.
-     */
-    REFLECTED(0.7f),
-
-    /**
-     * Agent's own reasoning or conclusion (inference, not observation).
-     */
-    INFERRED(0.5f),
-
-    /**
-     * System prompt, tool template, or procedural rule.
-     * High trust because it's system-defined.
-     */
-    PROCEDURAL(1.0f),
-
-    /**
-     * Replayed from another agent's WAL (cross-agent memory sharing).
-     * Lower confidence because it's secondhand information.
-     */
-    TRANSFERRED(0.6f);
-
-    private final float confidenceWeight;
-
-    MemorySource(float confidenceWeight) {
-        this.confidenceWeight = confidenceWeight;
-    }
-
-    /**
-     * Returns the default confidence weight for this source type.
-     *
-     * @return confidence weight (0.0–1.0)
-     */
-    public float confidenceWeight() {
-        return confidenceWeight;
-    }
-}
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/cortex/ProceduralMemoryStore.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/cortex/ProceduralMemoryStore.java
deleted file mode 100644
index c018adf..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/cortex/ProceduralMemoryStore.java
+++ /dev/null
@@ -1,124 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.cortex;
-
-import com.spectrayan.spector.memory.MemoryType;
-import com.spectrayan.spector.memory.synapse.CognitiveRecordLayout.CognitiveHeader;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.lang.foreign.MemorySegment;
-import java.nio.file.Path;
-import com.spectrayan.spector.commons.error.SpectorServerException;
-import com.spectrayan.spector.memory.error.SpectorMemoryTierFullException;
-import com.spectrayan.spector.commons.error.ErrorCode;
-
-/**
- * Small persistent store for procedural memory — prompt templates and tool-usage rules.
- *
- * <h3>Biological Analog: Basal Ganglia</h3>
- * <p>The basal ganglia stores procedural / motor memory — "how to do things" rather
- * than "what happened." These are habits, skills, and automatic routines that
- * don't require conscious recall.</p>
- *
- * <h3>Persistence</h3>
- * <p>When file-backed ({@code filePath} constructor), records are stored in a
- * persistent mmap file. On restart, the {@code count} is restored and all
- * records are immediately accessible for microsecond lookups.</p>
- *
- * <h3>Design</h3>
- * <ul>
- *   <li>Extends {@link AbstractTierStore} for common Arena/layout/segment lifecycle</li>
- *   <li>Small store (typically &lt;1000 records)</li>
- *   <li>High importance, low TTL — designed for microsecond lookups</li>
- *   <li>Linear append (no eviction — throws when full)</li>
- *   <li>Flat scan with {@code CognitiveScorer}</li>
- * </ul>
- */
-public final class ProceduralMemoryStore extends AbstractTierStore {
-
-    private static final Logger log = LoggerFactory.getLogger(ProceduralMemoryStore.class);
-
-    /**
-     * Creates a volatile Procedural Memory store (in-memory only).
-     *
-     * @param quantizedVecBytes bytes per quantized vector
-     * @param capacity          maximum number of procedural memories (default: 1000)
-     */
-    public ProceduralMemoryStore(int quantizedVecBytes, int capacity) {
-        super(quantizedVecBytes, capacity,
-                (long) new com.spectrayan.spector.memory.synapse.CognitiveRecordLayout(quantizedVecBytes).stride() * capacity);
-
-        log.info("ProceduralMemoryStore initialized: capacity={}, stride={}B, persistent=false",
-                capacity, layout.stride());
-    }
-
-    /**
-     * Creates a persistent Procedural Memory store backed by an mmap file.
-     *
-     * @param quantizedVecBytes bytes per quantized vector
-     * @param capacity          maximum number of procedural memories
-     * @param filePath          path to the backing mmap file
-     */
-    public ProceduralMemoryStore(int quantizedVecBytes, int capacity, Path filePath) {
-        super(quantizedVecBytes, capacity,
-                (long) new com.spectrayan.spector.memory.synapse.CognitiveRecordLayout(quantizedVecBytes).stride() * capacity,
-                filePath);
-
-        log.info("ProceduralMemoryStore initialized: capacity={}, stride={}B, persistent=true, count={}",
-                capacity, layout.stride(), count);
-    }
-
-    /**
-     * Creates a volatile Procedural Memory store with default capacity (1000).
-     */
-    public ProceduralMemoryStore(int quantizedVecBytes) {
-        this(quantizedVecBytes, 1000);
-    }
-
-    @Override
-    public MemoryType type() {
-        return MemoryType.PROCEDURAL;
-    }
-
-    @Override
-    public long write(CognitiveHeader header, byte[] quantizedVec) {
-        long offset = dataOffset() + (long) count * layout.stride();
-        append(header, quantizedVec);
-        return offset;
-    }
-
-    /**
-     * Appends a procedural memory.
-     *
-     * @param header       cognitive header
-     * @param quantizedVec quantized vector bytes
-     */
-    public synchronized void append(CognitiveHeader header, byte[] quantizedVec) {
-        if (count >= capacity) {
-            throw new SpectorMemoryTierFullException("PROCEDURAL", capacity);
-        }
-
-        long offset = dataOffset() + (long) count * layout.stride();
-        layout.writeHeader(segment, offset, header);
-        MemorySegment.copy(
-                MemorySegment.ofArray(quantizedVec), 0,
-                segment, layout.vectorOffset(offset),
-                quantizedVec.length
-        );
-        count++;
-        persistCount();
-    }
-}
-
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/cortex/SemanticMemoryStore.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/cortex/SemanticMemoryStore.java
deleted file mode 100644
index 57cb102..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/cortex/SemanticMemoryStore.java
+++ /dev/null
@@ -1,147 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.cortex;
-
-import com.spectrayan.spector.memory.MemoryType;
-import com.spectrayan.spector.memory.synapse.CognitiveRecordLayout.CognitiveHeader;
-import com.spectrayan.spector.memory.synapse.HeaderLayout;
-import com.spectrayan.spector.memory.synapse.SynapticHeaderConstants;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.lang.foreign.MemorySegment;
-import java.nio.file.Path;
-import com.spectrayan.spector.commons.error.SpectorServerException;
-import com.spectrayan.spector.memory.error.SpectorMemoryTierFullException;
-import com.spectrayan.spector.commons.error.ErrorCode;
-
-/**
- * Permanent factual knowledge store delegating to existing HNSW/SVASQ index infrastructure.
- *
- * <h3>Biological Analog: Neocortex</h3>
- * <p>The neocortex stores permanent, deduplicated facts — consolidated from episodic
- * memories during sleep. It's the "long-term" memory that survives across sessions.</p>
- *
- * <h3>Persistence</h3>
- * <p>When file-backed ({@code filePath} constructor), the header-only slab is
- * stored in a persistent mmap file. On restart, the {@code count} is restored
- * from the metadata header and all existing headers are immediately accessible.</p>
- *
- * <h3>Design</h3>
- * <ul>
- *   <li>Extends {@link AbstractTierStore} for common Arena/layout/segment lifecycle</li>
- *   <li>Header-only store — vectors go through SpectorIndex's HNSW/SVASQ pipeline</li>
- *   <li>Maintains a parallel off-heap slab for synaptic headers (size depends on layout version)</li>
- *   <li>On search: reads header for scoring, delegates vector distance to SVASQ kernel</li>
- *   <li>Deduplication check before insert (via {@code SemanticDeduplicator})</li>
- * </ul>
- */
-public final class SemanticMemoryStore extends AbstractTierStore {
-
-    private static final Logger log = LoggerFactory.getLogger(SemanticMemoryStore.class);
-
-    /**
-     * Creates a volatile Semantic Memory store (in-memory only).
-     *
-     * <p>Allocates a header-only slab (no vector payload) since vectors are stored
-     * in SpectorIndex.</p>
-     *
-     * @param quantizedVecBytes bytes per quantized vector (for layout calculation)
-     * @param capacity          maximum number of semantic memories (default: 100_000)
-     */
-    public SemanticMemoryStore(int quantizedVecBytes, int capacity) {
-        super(quantizedVecBytes, capacity,
-                (long) layout(quantizedVecBytes).headerLayout().headerBytes() * capacity);
-
-        log.info("SemanticMemoryStore initialized: capacity={}, headerSlab={}KB, persistent=false, headerVersion=V{}",
-                capacity,
-                (long) layout.headerLayout().headerBytes() * capacity / 1024,
-                layout.headerLayout().version());
-    }
-
-    /**
-     * Creates a persistent Semantic Memory store backed by an mmap file.
-     *
-     * @param quantizedVecBytes bytes per quantized vector (for layout calculation)
-     * @param capacity          maximum number of semantic memories
-     * @param filePath          path to the backing mmap file
-     */
-    public SemanticMemoryStore(int quantizedVecBytes, int capacity, Path filePath) {
-        super(quantizedVecBytes, capacity,
-                (long) layout(quantizedVecBytes).headerLayout().headerBytes() * capacity,
-                filePath);
-
-        log.info("SemanticMemoryStore initialized: capacity={}, headerSlab={}KB, persistent=true, count={}, headerVersion=V{}",
-                capacity,
-                (long) layout.headerLayout().headerBytes() * capacity / 1024,
-                count,
-                layout.headerLayout().version());
-    }
-
-    @Override
-    public MemoryType type() {
-        return MemoryType.SEMANTIC;
-    }
-
-    @Override
-    public long write(CognitiveHeader header, byte[] quantizedVec) {
-        // Semantic store is header-only — quantizedVec is ignored
-        int index = store(header);
-        return dataOffset() + (long) index * layout.headerLayout().headerBytes();
-    }
-
-    /**
-     * Stores a new semantic memory header.
-     *
-     * <p>The actual vector is stored via SpectorIndex's existing HNSW/SVASQ pipeline.
-     * This method only writes the cognitive header to the parallel slab.</p>
-     *
-     * @param header cognitive header
-     * @return the record index (used to correlate with SpectorIndex vector)
-     */
-    public synchronized int store(CognitiveHeader header) {
-        if (count >= capacity) {
-            throw new SpectorMemoryTierFullException("SEMANTIC", capacity);
-        }
-
-        long offset = dataOffset() + (long) count * layout.headerLayout().headerBytes();
-        layout.writeHeader(segment, offset, header);
-        int index = count++;
-        persistCount();
-        return index;
-    }
-
-    /**
-     * Reads the cognitive header at the given index.
-     */
-    public CognitiveHeader readHeader(int index) {
-        long offset = dataOffset() + (long) index * layout.headerLayout().headerBytes();
-        return layout.readHeader(segment, offset);
-    }
-
-    /**
-     * Returns the header slab segment for direct scorer access.
-     * This is the same as {@link #primarySegment()} for semantic stores.
-     */
-    public MemorySegment headerSlab() {
-        return segment;
-    }
-
-    /**
-     * Helper to create a layout for slab size calculation in super() calls.
-     */
-    private static com.spectrayan.spector.memory.synapse.CognitiveRecordLayout layout(int quantizedVecBytes) {
-        return new com.spectrayan.spector.memory.synapse.CognitiveRecordLayout(quantizedVecBytes);
-    }
-}
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/cortex/SemanticRecallStrategy.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/cortex/SemanticRecallStrategy.java
deleted file mode 100644
index cbd9046..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/cortex/SemanticRecallStrategy.java
+++ /dev/null
@@ -1,197 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.cortex;
-
-import com.spectrayan.spector.index.ScoredResult;
-import com.spectrayan.spector.index.VectorIndex;
-import com.spectrayan.spector.memory.CognitiveResult;
-import com.spectrayan.spector.memory.MemoryType;
-import com.spectrayan.spector.memory.RecallOptions;
-import com.spectrayan.spector.memory.index.MemoryIndex;
-import com.spectrayan.spector.memory.synapse.CognitiveRecordLayout;
-import com.spectrayan.spector.memory.synapse.CognitiveRecordLayout.CognitiveHeader;
-import com.spectrayan.spector.memory.synapse.DecayStrategy;
-import com.spectrayan.spector.memory.synapse.SynapticHeaderConstants;
-import com.spectrayan.spector.memory.synapse.SynapticTagEncoder;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.util.ArrayList;
-import java.util.Comparator;
-import java.util.List;
-
-/**
- * Fused semantic recall strategy — HNSW vector search + cognitive header scoring.
- *
- * <h3>Problem (The Truncation Trap — Semantic Variant)</h3>
- * <p>The {@code SemanticMemoryStore} stores only 32-byte cognitive headers (no vectors).
- * This means flat-scanning the header slab cannot compute vector similarity — the
- * {@code alpha * similarity} term is entirely missing. Semantic recall was scoring
- * only {@code beta * importance * decay}, which is fundamentally broken for
- * similarity-based retrieval.</p>
- *
- * <h3>Solution: Fused Pipeline</h3>
- * <ol>
- *   <li>Query the {@link VectorIndex} (HNSW) for top-N candidates with similarity scores</li>
- *   <li>For each candidate, look up the cognitive header from the header slab</li>
- *   <li>Apply the full 6-phase cognitive scoring: tag gating, valence filtering,
- *       temporal decay, reconsolidation, and weighted tag relevance</li>
- *   <li>Re-rank by fused score and return</li>
- * </ol>
- *
- * <h3>Performance</h3>
- * <p>HNSW search is O(log N) vs O(N) flat scan. For 100K+ semantic memories,
- * this is orders of magnitude faster. The over-fetch multiplier (default: 3×)
- * ensures cognitive re-ranking has enough candidates to find truly relevant results.</p>
- *
- * <h3>Graceful Degradation</h3>
- * <p>If no {@code VectorIndex} is configured, the caller falls back to
- * the header-only scoring path (with the newly-added tag/valence filters).</p>
- */
-public final class SemanticRecallStrategy {
-
-    private static final Logger log = LoggerFactory.getLogger(SemanticRecallStrategy.class);
-
-    private final VectorIndex vectorIndex;
-    private final SemanticMemoryStore semanticStore;
-    private final MemoryIndex memoryIndex;
-
-    /**
-     * Creates a fused semantic recall strategy.
-     *
-     * @param vectorIndex   the HNSW/IVF index backing semantic memory
-     * @param semanticStore the header-only semantic slab
-     * @param memoryIndex   the ID → metadata index for reverse lookups
-     */
-    public SemanticRecallStrategy(VectorIndex vectorIndex,
-                                   SemanticMemoryStore semanticStore,
-                                   MemoryIndex memoryIndex) {
-        this.vectorIndex = vectorIndex;
-        this.semanticStore = semanticStore;
-        this.memoryIndex = memoryIndex;
-    }
-
-    /**
-     * Executes a fused semantic recall: HNSW search → cognitive re-ranking.
-     *
-     * <p>Steps:</p>
-     * <ol>
-     *   <li>Search HNSW for {@code topK * multiplier} candidates</li>
-     *   <li>For each candidate, read the cognitive header from the slab</li>
-     *   <li>Apply tag gating, valence filtering, importance threshold</li>
-     *   <li>Compute fused score: {@code alpha * similarity + beta * importance * decay}</li>
-     *   <li>Apply weighted tag relevance boost</li>
-     *   <li>Sort and return top-K</li>
-     * </ol>
-     *
-     * @param queryVector the embedded query vector
-     * @param options     recall configuration
-     * @param nowMs       current timestamp for decay computation
-     * @return ranked list of cognitive results
-     */
-    public List<CognitiveResult> recall(float[] queryVector, RecallOptions options, long nowMs) {
-        int candidateCount = options.topK() * options.semanticCandidateMultiplier();
-        ScoredResult[] hnswResults = vectorIndex.search(queryVector, candidateCount);
-
-        if (hnswResults == null || hnswResults.length == 0) {
-            log.debug("Semantic HNSW search returned 0 results");
-            return List.of();
-        }
-
-        // Extract filter parameters
-        long queryTagMask = options.synapticTagMask();
-        byte minValence = options.minValence();
-        byte maxValence = options.maxValence();
-        float minImportance = options.minImportance();
-        float alpha = options.alpha();
-        float beta = options.beta();
-        float tagRelevanceBoost = options.tagRelevanceBoost();
-
-        CognitiveRecordLayout layout = semanticStore.layout();
-        java.lang.foreign.MemorySegment headerSlab = semanticStore.primarySegment();
-
-        List<CognitiveResult> results = new ArrayList<>();
-
-        for (ScoredResult sr : hnswResults) {
-            // HNSW returns an internal store index — compute header offset
-            long headerOffset = (long) sr.index() * layout.headerLayout().headerBytes();
-
-            // Bounds check: ensure we're within the slab
-            if (headerSlab == null || headerOffset + layout.headerLayout().headerBytes() > headerSlab.byteSize()) {
-                continue;
-            }
-
-            CognitiveHeader header = layout.readHeader(headerSlab, headerOffset);
-
-            // Phase 1: Tombstone check
-            if (SynapticHeaderConstants.isTombstoned(header.flags())) continue;
-
-            // Phase 2: Synaptic tag gating (skip on zero overlap)
-            long recordTags = header.synapticTags();
-            if (queryTagMask != 0 && (recordTags & queryTagMask) == 0) continue;
-
-            // Phase 3: Valence filter
-            byte valence = header.valence();
-            if (valence < minValence || valence > maxValence) continue;
-
-            // Phase 4: Importance threshold
-            float importance = header.importance();
-            if (importance < minImportance) continue;
-
-            // Phase 5: Use HNSW similarity score directly
-            float similarity = sr.score();
-
-            // Phase 6: Temporal decay + reconsolidation
-            long timestamp = header.timestampMs();
-            int recallCount = header.recallCount();
-            int rawBucket = DecayStrategy.ageToBucket(timestamp, nowMs);
-            int adjusted = DecayStrategy.adjustForReconsolidation(rawBucket, recallCount);
-            float decay = DecayStrategy.decay(adjusted);
-
-            // Fused cognitive score with weighted tag relevance
-            float baseScore = alpha * similarity + beta * importance * decay;
-            float tagOverlap = SynapticTagEncoder.overlapRatio(recordTags, queryTagMask);
-            float finalScore = baseScore * (1.0f + tagOverlap * tagRelevanceBoost);
-
-            // Build result
-            String id = memoryIndex.findIdByOffset(MemoryType.SEMANTIC, headerOffset);
-            String text = id != null ? memoryIndex.text(id) : "";
-            MemorySource source = id != null ? memoryIndex.source(id) : MemorySource.OBSERVED;
-            String[] tags = id != null ? memoryIndex.tags(id) : new String[0];
-            float ageDays = (nowMs - timestamp) / (1000f * 60f * 60f * 24f);
-            float rawDecay = DecayStrategy.decay(rawBucket);
-
-            results.add(new CognitiveResult(
-                    id != null ? id : "semantic-" + sr.index(),
-                    text, finalScore, importance, ageDays,
-                    recallCount, valence, MemoryType.SEMANTIC, source,
-                    tags, rawDecay, decay));
-        }
-
-        // Sort by fused score descending
-        results.sort(Comparator.comparing(CognitiveResult::score).reversed());
-
-        log.debug("Semantic fused recall: {} HNSW candidates → {} after filtering",
-                hnswResults.length, results.size());
-
-        return results;
-    }
-
-    /**
-     * Returns whether this strategy has a configured vector index.
-     */
-    public boolean isAvailable() {
-        return vectorIndex != null;
-    }
-}
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/cortex/TierRouter.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/cortex/TierRouter.java
deleted file mode 100644
index 12c7dc6..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/cortex/TierRouter.java
+++ /dev/null
@@ -1,176 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.cortex;
-
-import com.spectrayan.spector.memory.MemoryType;
-import com.spectrayan.spector.memory.synapse.CognitiveRecordLayout;
-import com.spectrayan.spector.memory.synapse.CognitiveRecordLayout.CognitiveHeader;
-
-import java.lang.foreign.MemorySegment;
-import java.util.EnumMap;
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-import com.spectrayan.spector.commons.error.ErrorCode;
-
-/**
- * Tier store registry and polymorphic routing — zero switch statements.
- *
- * <h3>Design Pattern: Strategy + Registry</h3>
- * <p>Holds a {@code EnumMap<MemoryType, TierStore>} and dispatches all operations
- * polymorphically via the {@link TierStore} interface. Adding a new memory tier
- * (e.g., FLASH) requires: (1) implement {@link TierStore}, (2) register here.
- * Zero changes to SpectorMemory, RecallPipeline, or IngestionPipeline.</p>
- *
- * <h3>SOLID Compliance</h3>
- * <ul>
- *   <li><b>OCP</b>: Open for extension (new tiers), closed for modification</li>
- *   <li><b>DIP</b>: Depends on {@link TierStore} abstraction, not concrete stores</li>
- *   <li><b>LSP</b>: All stores are substitutable via the common interface</li>
- * </ul>
- */
-public final class TierRouter implements AutoCloseable {
-
-    private final EnumMap<MemoryType, TierStore> stores = new EnumMap<>(MemoryType.class);
-
-    // ── Typed accessors for tier-specific operations ──
-    private final WorkingMemoryStore workingStore;
-    private final EpisodicMemoryStore episodicStore;
-    private final SemanticMemoryStore semanticStore;
-    private final ProceduralMemoryStore proceduralStore;
-
-    /**
-     * Creates a TierRouter with all four cognitive tier stores.
-     *
-     * <p>Each store is registered in the internal {@code EnumMap} for polymorphic
-     * dispatch, while typed fields are retained for tier-specific operations
-     * (e.g., episodic partition iteration, semantic header reads).</p>
-     */
-    public TierRouter(WorkingMemoryStore workingStore,
-                       EpisodicMemoryStore episodicStore,
-                       SemanticMemoryStore semanticStore,
-                       ProceduralMemoryStore proceduralStore) {
-        this.workingStore = workingStore;
-        this.episodicStore = episodicStore;
-        this.semanticStore = semanticStore;
-        this.proceduralStore = proceduralStore;
-
-        // Register in EnumMap for polymorphic dispatch
-        stores.put(MemoryType.WORKING, workingStore);
-        stores.put(MemoryType.EPISODIC, episodicStore);
-        stores.put(MemoryType.SEMANTIC, semanticStore);
-        stores.put(MemoryType.PROCEDURAL, proceduralStore);
-    }
-
-    // ══════════════════════════════════════════════════════════════
-    // POLYMORPHIC DISPATCH (zero switch statements)
-    // ══════════════════════════════════════════════════════════════
-
-    /**
-     * Returns the {@link TierStore} for a given memory type.
-     *
-     * @throws SpectorValidationException if no store is registered for the type
-     */
-    public TierStore get(MemoryType type) {
-        TierStore store = stores.get(type);
-        if (store == null) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_INVALID, "storeType", type);
-        }
-        return store;
-    }
-
-    /**
-     * Routes a memory write to the appropriate tier store.
-     * Polymorphic — delegates to {@link TierStore#write}.
-     *
-     * @param type       target memory tier
-     * @param header     cognitive header
-     * @param quantized  quantized vector bytes
-     * @return byte offset where the record was written
-     */
-    public long write(MemoryType type, CognitiveHeader header, byte[] quantized) {
-        return get(type).write(header, quantized);
-    }
-
-    /**
-     * Returns the primary memory segment for a given tier.
-     * Polymorphic — delegates to {@link TierStore#primarySegment}.
-     */
-    public MemorySegment segmentFor(MemoryType type) {
-        return get(type).primarySegment();
-    }
-
-    /**
-     * Returns the layout for a given tier.
-     * Polymorphic — delegates to {@link TierStore#layout}.
-     */
-    public CognitiveRecordLayout layoutFor(MemoryType type) {
-        return get(type).layout();
-    }
-
-    /**
-     * Returns the record count for a given tier.
-     * Polymorphic — delegates to {@link TierStore#size}.
-     */
-    public int countFor(MemoryType type) {
-        return get(type).size();
-    }
-
-    /**
-     * Returns the total memory count across all registered tiers.
-     */
-    public int totalCount() {
-        return workingStore.size() + episodicStore.size()
-                + semanticStore.size() + proceduralStore.size();
-    }
-
-    /**
-     * Checks if a given memory type should be scanned based on the target type filter.
-     *
-     * @param type        the tier to check
-     * @param targetTypes target type filter (null or empty = scan all)
-     * @return true if this type should be scanned
-     */
-    public static boolean shouldScan(MemoryType type, MemoryType[] targetTypes) {
-        if (targetTypes == null || targetTypes.length == 0) return true;
-        for (MemoryType t : targetTypes) {
-            if (t == type) return true;
-        }
-        return false;
-    }
-
-    // ══════════════════════════════════════════════════════════════
-    // TYPED ACCESSORS (for tier-specific operations)
-    // ══════════════════════════════════════════════════════════════
-
-    /** Returns the Working Memory store (for circular buffer scan). */
-    public WorkingMemoryStore working() { return workingStore; }
-
-    /** Returns the Episodic Memory store (for partition iteration). */
-    public EpisodicMemoryStore episodic() { return episodicStore; }
-
-    /** Returns the Semantic Memory store (for header slab access). */
-    public SemanticMemoryStore semantic() { return semanticStore; }
-
-    /** Returns the Procedural Memory store (for flat scan). */
-    public ProceduralMemoryStore procedural() { return proceduralStore; }
-
-    @Override
-    public void close() {
-        stores.values().forEach(store -> {
-            try {
-                store.close();
-            } catch (Exception e) {
-                // Log and continue closing remaining stores
-            }
-        });
-    }
-}
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/cortex/TierStore.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/cortex/TierStore.java
deleted file mode 100644
index 6a3b9af..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/cortex/TierStore.java
+++ /dev/null
@@ -1,79 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.cortex;
-
-import com.spectrayan.spector.memory.MemoryType;
-import com.spectrayan.spector.memory.synapse.CognitiveRecordLayout;
-import com.spectrayan.spector.memory.synapse.CognitiveRecordLayout.CognitiveHeader;
-
-import java.lang.foreign.MemorySegment;
-
-/**
- * Common interface for all cognitive tier stores.
- *
- * <h3>Design Pattern: Strategy (Interface Segregation)</h3>
- * <p>Defines the contract that every memory tier store must implement.
- * The {@link TierRouter} holds a {@code Map<MemoryType, TierStore>}
- * and dispatches operations polymorphically — zero switch statements.</p>
- *
- * <h3>Implementations</h3>
- * <ul>
- *   <li>{@link WorkingMemoryStore} — volatile circular buffer (Prefrontal Cortex)</li>
- *   <li>{@link EpisodicMemoryStore} — time-partitioned mmap (Hippocampus)</li>
- *   <li>{@link SemanticMemoryStore} — permanent header slab (Neocortex)</li>
- *   <li>{@link ProceduralMemoryStore} — small append-only store (Basal Ganglia)</li>
- * </ul>
- *
- * @see AbstractTierStore for common implementation
- * @see TierRouter for polymorphic dispatch
- */
-public interface TierStore extends AutoCloseable {
-
-    /**
-     * Returns the cognitive memory tier this store belongs to.
-     */
-    MemoryType type();
-
-    /**
-     * Returns the number of live records in this store.
-     */
-    int size();
-
-    /**
-     * Returns the record layout for this store.
-     */
-    CognitiveRecordLayout layout();
-
-    /**
-     * Returns the primary memory segment for this store.
-     *
-     * <p>For single-segment stores (Working, Procedural), this is the backing segment.
-     * For Semantic, this is the header slab.
-     * For Episodic, this returns the latest partition's segment (or null if empty).</p>
-     */
-    MemorySegment primarySegment();
-
-    /**
-     * Writes a memory record to this store and returns the byte offset
-     * where the record was written.
-     *
-     * <p>Each implementation handles its own write semantics:
-     * Working uses circular buffer FIFO, Episodic uses partitioned append,
-     * Semantic writes header-only, Procedural uses linear append.</p>
-     *
-     * @param header      cognitive header
-     * @param quantizedVec quantized vector bytes (may be ignored by header-only stores)
-     * @return byte offset where the record was written
-     */
-    long write(CognitiveHeader header, byte[] quantizedVec);
-}
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/cortex/WorkingMemoryStore.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/cortex/WorkingMemoryStore.java
deleted file mode 100644
index e75b796..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/cortex/WorkingMemoryStore.java
+++ /dev/null
@@ -1,237 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.cortex;
-
-import com.spectrayan.spector.core.similarity.SimilarityFunction;
-import com.spectrayan.spector.memory.MemoryType;
-import com.spectrayan.spector.memory.synapse.CognitiveRecordLayout.CognitiveHeader;
-import com.spectrayan.spector.memory.synapse.SynapticHeaderConstants;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.lang.foreign.MemorySegment;
-import java.lang.foreign.ValueLayout;
-import java.nio.file.Path;
-
-/**
- * Volatile or persistent scratchpad for short-term Working Memory.
- *
- * <h3>Biological Analog: Prefrontal Cortex</h3>
- * <p>The prefrontal cortex holds a small number of items in active consciousness
- * (~7 ± 2 according to Miller's Law). Working memory is volatile — it exists
- * only while the session is active and is discarded when the session ends.</p>
- *
- * <h3>Persistence</h3>
- * <p>When file-backed ({@code filePath} constructor), the circular buffer and
- * its {@code writeIndex} are persisted via mmap. The {@code writeIndex} is
- * stored in the metadata header's {@code extra1} field (offset 24). On restart,
- * the agent resumes with its previous "train of thought."</p>
- *
- * <h3>Design</h3>
- * <ul>
- *   <li>Extends {@link AbstractTierStore} for common Arena/layout/segment lifecycle</li>
- *   <li>Fixed capacity (default: 100 records)</li>
- *   <li>FIFO eviction when full — oldest items are overwritten (circular buffer)</li>
- *   <li>Flat Panama scan — no index needed (working set is small)</li>
- * </ul>
- *
- * <h3>Thread Safety</h3>
- * <p>Uses a shared Arena. Write access is synchronized; reads are lock-free
- * (scan over immutable segments).</p>
- */
-public final class WorkingMemoryStore extends AbstractTierStore {
-
-    private static final Logger log = LoggerFactory.getLogger(WorkingMemoryStore.class);
-
-    private int writeIndex = 0;  // circular buffer index
-
-    /**
-     * Creates a volatile Working Memory store (in-memory only).
-     *
-     * @param quantizedVecBytes bytes per quantized vector
-     * @param capacity          maximum number of records (default: 100)
-     */
-    public WorkingMemoryStore(int quantizedVecBytes, int capacity) {
-        super(quantizedVecBytes, capacity,
-                (long) new com.spectrayan.spector.memory.synapse.CognitiveRecordLayout(quantizedVecBytes).stride() * capacity);
-
-        log.info("WorkingMemoryStore initialized: capacity={}, stride={}B, total={}KB, persistent=false",
-                capacity, layout.stride(), (long) layout.stride() * capacity / 1024);
-    }
-
-    /**
-     * Creates a persistent Working Memory store backed by an mmap file.
-     *
-     * <p>On restart, {@code count} and {@code writeIndex} are restored from
-     * the metadata header, allowing the circular buffer to resume exactly
-     * where it left off.</p>
-     *
-     * @param quantizedVecBytes bytes per quantized vector
-     * @param capacity          maximum number of records
-     * @param filePath          path to the backing mmap file
-     */
-    public WorkingMemoryStore(int quantizedVecBytes, int capacity, Path filePath) {
-        super(quantizedVecBytes, capacity,
-                (long) new com.spectrayan.spector.memory.synapse.CognitiveRecordLayout(quantizedVecBytes).stride() * capacity,
-                filePath);
-
-        // Restore writeIndex from metadata header extra1 field
-        if (persistent && count > 0) {
-            this.writeIndex = segment.get(ValueLayout.JAVA_INT, META_EXTRA1);
-            log.info("WorkingMemoryStore restored: writeIndex={}, count={}", writeIndex, count);
-        }
-
-        log.info("WorkingMemoryStore initialized: capacity={}, stride={}B, persistent=true",
-                capacity, layout.stride());
-    }
-
-    /**
-     * Creates a volatile Working Memory store with default capacity (100).
-     */
-    public WorkingMemoryStore(int quantizedVecBytes) {
-        this(quantizedVecBytes, 100);
-    }
-
-    @Override
-    public MemoryType type() {
-        return MemoryType.WORKING;
-    }
-
-    /**
-     * Returns the number of live records currently in working memory.
-     */
-    public int count() {
-        return count;
-    }
-
-    @Override
-    public long write(CognitiveHeader header, byte[] quantizedVec) {
-        long offset = dataOffset() + (long) writeIndex * layout.stride();
-        put(header, quantizedVec);
-        return offset;
-    }
-
-    /**
-     * Appends a record to the working memory circular buffer.
-     *
-     * <p>If the buffer is full, the oldest record is overwritten (FIFO eviction).
-     * The evicted record's tombstone flag is set before overwrite.</p>
-     *
-     * @param header       cognitive header for this memory
-     * @param quantizedVec the quantized vector bytes
-     */
-    public synchronized void put(CognitiveHeader header, byte[] quantizedVec) {
-        long offset = dataOffset() + (long) writeIndex * layout.stride();
-
-        // If we're overwriting an existing record, mark it as evicted
-        if (count >= capacity) {
-            log.trace("Working memory full — evicting slot {}", writeIndex);
-        }
-
-        // Write header
-        layout.writeHeader(segment, offset, header);
-
-        // Write quantized vector payload
-        MemorySegment.copy(
-                MemorySegment.ofArray(quantizedVec), 0,
-                segment, layout.vectorOffset(offset),
-                quantizedVec.length
-        );
-
-        // Advance circular buffer
-        writeIndex = (writeIndex + 1) % capacity;
-        count = Math.min(count + 1, capacity);
-
-        // Persist count and writeIndex to metadata header
-        persistCount();
-        if (persistent) {
-            segment.set(ValueLayout.JAVA_INT, META_EXTRA1, writeIndex);
-        }
-    }
-
-    /**
-     * Flat scans all live records and returns matching results.
-     *
-     * <p>This is a linear scan over at most {@code capacity} records.
-     * Since Working Memory is small (≤100 records), this is fast (~2-5µs).</p>
-     *
-     * @param queryTagMask synaptic tag filter (0 = match all)
-     * @return array of offsets that passed the filter, for scoring
-     */
-    public long[] scan(long queryTagMask) {
-        long[] matches = new long[count];
-        int matchCount = 0;
-
-        for (int i = 0; i < count; i++) {
-            long offset = dataOffset() + (long) i * layout.stride();
-
-            // Phase 1: Skip tombstones
-            byte flags = layout.readFlags(segment, offset);
-            if (SynapticHeaderConstants.isTombstoned(flags)) continue;
-
-            // Phase 2: Synaptic tag gating
-            if (queryTagMask != 0) {
-                long recordTags = layout.readSynapticTags(segment, offset);
-                if ((recordTags & queryTagMask) != queryTagMask) continue;
-            }
-
-            matches[matchCount++] = offset;
-        }
-
-        // Trim
-        long[] result = new long[matchCount];
-        System.arraycopy(matches, 0, result, 0, matchCount);
-        return result;
-    }
-
-    /**
-     * Scans the working memory buffer and returns the minimum L2 distance
-     * between the given query vector and any existing live record.
-     *
-     * <h3>Neurodivergent: Dopaminergic Novelty Routing</h3>
-     * <p>Used at ingestion time to compute novelty/surprise. If the new memory
-     * is very close to an existing working memory record (low L2 distance),
-     * it's "boring" — importance is suppressed. If it's far away, it's novel
-     * and importance is spiked (dopamine event).</p>
-     *
-     * <p>Cost: O(capacity × dims) — for a 100-slot WM with 768-dim vectors,
-     * this is ~0.5ms using SIMD acceleration.</p>
-     *
-     * @param queryVector the new embedding vector to compare (float32)
-     * @param mins        per-dimension minimum values from ScalarQuantizer calibration
-     * @param scales      per-dimension scale values from ScalarQuantizer calibration
-     * @return minimum L2 distance to any live record, or {@code Float.MAX_VALUE} if empty
-     */
-    public float nearestDistance(float[] queryVector, float[] mins, float[] scales) {
-        if (count == 0) return Float.MAX_VALUE;
-
-        float minDist = Float.MAX_VALUE;
-        for (int i = 0; i < count; i++) {
-            long offset = dataOffset() + (long) i * layout.stride();
-
-            // Skip tombstoned records
-            byte flags = layout.readFlags(segment, offset);
-            if (SynapticHeaderConstants.isTombstoned(flags)) continue;
-
-            // Compute calibrated L2 distance via SIMD kernel
-            float dist = SimilarityFunction.EUCLIDEAN.computeQuantizedFromSegment(
-                    queryVector, segment, layout.vectorOffset(offset),
-                    mins, scales, layout.quantizedVecBytes());
-
-            if (dist < minDist) minDist = dist;
-        }
-        return minDist;
-    }
-}
-
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/dopamine/FlashbulbPolicy.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/dopamine/FlashbulbPolicy.java
deleted file mode 100644
index 8c17ad7..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/dopamine/FlashbulbPolicy.java
+++ /dev/null
@@ -1,92 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.dopamine;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-/**
- * Fidelity escalation policy for extreme surprise events.
- *
- * <h3>Biological Analog: Flashbulb Memory Formation</h3>
- * <p>You remember exactly where you were during a life-changing moment, but not
- * what you had for lunch last Tuesday. The amygdala signals the hippocampus to
- * encode at maximum fidelity when dopamine exceeds a threshold.</p>
- *
- * <h3>Implementation</h3>
- * <p>For extreme surprise scores (z-score &gt; 3.0), this policy recommends:</p>
- * <ul>
- *   <li>Store full float32 vectors (not quantized) — zero reconstruction error</li>
- *   <li>Set the pinned flag — exempt from decay and pruning</li>
- *   <li>Set importance to maximum (10.0)</li>
- * </ul>
- */
-public final class FlashbulbPolicy {
-
-    private static final Logger log = LoggerFactory.getLogger(FlashbulbPolicy.class);
-
-    /** Z-score threshold above which flashbulb mode activates. */
-    private final double flashbulbThreshold;
-
-    /**
-     * Creates a flashbulb policy.
-     *
-     * @param flashbulbThreshold z-score threshold for activation (default: 3.0)
-     */
-    public FlashbulbPolicy(double flashbulbThreshold) {
-        this.flashbulbThreshold = flashbulbThreshold;
-    }
-
-    /**
-     * Creates a flashbulb policy with default threshold (3.0).
-     */
-    public FlashbulbPolicy() {
-        this(3.0);
-    }
-
-    /**
-     * Result of a flashbulb evaluation.
-     *
-     * @param isFlashbulb whether this memory should use full-fidelity storage
-     * @param importance  the importance to assign (10.0 for flashbulb, original otherwise)
-     * @param pinned      whether to set the pinned flag (exempt from pruning)
-     */
-    public record FlashbulbDecision(boolean isFlashbulb, float importance, boolean pinned) {
-
-        /** Normal memory — no special treatment. */
-        public static final FlashbulbDecision NORMAL =
-                new FlashbulbDecision(false, -1f, false);
-    }
-
-    /**
-     * Evaluates whether a memory should be stored with flashbulb fidelity.
-     *
-     * @param zScore the surprise z-score from the {@link SurpriseDetector}
-     * @return decision with fidelity, importance, and pin recommendations
-     */
-    public FlashbulbDecision evaluate(double zScore) {
-        if (zScore > flashbulbThreshold) {
-            log.info("Flashbulb memory triggered! z-score={} (threshold={})",
-                    zScore, flashbulbThreshold);
-            return new FlashbulbDecision(true, 10.0f, true);
-        }
-        return FlashbulbDecision.NORMAL;
-    }
-
-    /**
-     * Returns the flashbulb threshold.
-     */
-    public double flashbulbThreshold() {
-        return flashbulbThreshold;
-    }
-}
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/dopamine/SurpriseDetector.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/dopamine/SurpriseDetector.java
deleted file mode 100644
index 5ad4994..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/dopamine/SurpriseDetector.java
+++ /dev/null
@@ -1,186 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.dopamine;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-/**
- * Adaptive surprise detection engine — automatically assigns importance at ingestion time.
- *
- * <h3>Biological Analog: Dopamine Prediction Error Signaling</h3>
- * <p>The brain is a prediction engine. If you eat a normal breakfast, you forget it in
- * an hour. If the toaster catches fire, a dopamine spike sears the event into your
- * brain forever. The brain scales memory strength based on <em>Prediction Error</em> —
- * the gap between what was expected and what actually happened.</p>
- *
- * <h3>Why Not Fixed L2 Thresholds?</h3>
- * <p>Fixed thresholds (e.g., {@code L2 < 0.1 = boring}) are embedding-model-dependent.
- * {@code nomic-embed-text} (768-dim) produces very different L2 ranges than
- * {@code all-MiniLM-L6-v2} (384-dim). Z-score normalization adapts to any model
- * automatically.</p>
- *
- * <h3>Thread Safety</h3>
- * <p>This class is thread-safe. The internal {@link WelfordStats} uses synchronized
- * updates, and reads are volatile.</p>
- */
-public final class SurpriseDetector {
-
-    private static final Logger log = LoggerFactory.getLogger(SurpriseDetector.class);
-
-    private final WelfordStats stats;
-
-    /** Minimum samples required before z-score-based importance kicks in. */
-    private final int warmupSamples;
-
-    /** Default importance assigned during warmup period. */
-    private static final float DEFAULT_IMPORTANCE = 1.0f;
-
-    /**
-     * Creates a new surprise detector.
-     *
-     * @param warmupSamples minimum observations before adaptive importance activates (default: 20)
-     */
-    public SurpriseDetector(int warmupSamples) {
-        this.stats = new WelfordStats();
-        this.warmupSamples = warmupSamples;
-    }
-
-    /**
-     * Creates a surprise detector with default warmup (20 samples).
-     */
-    public SurpriseDetector() {
-        this(20);
-    }
-
-    /**
-     * Computes the surprise score for a new memory based on its distance to existing content.
-     *
-     * <p>Call this during ingestion: compute the L2 distance from the new vector to
-     * the nearest existing centroid or cluster center, then pass that distance here.</p>
-     *
-     * @param distanceToNearest L2 distance from new vector to nearest existing memory/centroid
-     * @return importance value (0.1 = mundane, 1.0 = default, 10.0 = extreme surprise)
-     */
-    public float computeImportance(float distanceToNearest) {
-        // Update running statistics
-        stats.update(distanceToNearest);
-
-        // During warmup, return default importance
-        if (stats.count() < warmupSamples) {
-            return DEFAULT_IMPORTANCE;
-        }
-
-        // Compute z-score against the running distribution
-        double zScore = stats.zScore(distanceToNearest);
-        float importance = zScoreToImportance(zScore);
-
-        if (importance >= 5.0f) {
-            log.debug("Dopamine spike! z-score={}, importance={}", zScore, importance);
-        }
-
-        return importance;
-    }
-
-    /**
-     * Maps a z-score to an importance value.
-     *
-     * <pre>
-     *   z < -1.0 → very similar to existing memories → 0.1 (suppress)
-     *   z ∈ [-1, 1] → normal → 0.5 (default)
-     *   z > 1.0 → moderately novel → 2.0
-     *   z > 2.0 → highly novel → 5.0
-     *   z > 3.0 → extreme outlier → 10.0 (dopamine spike!)
-     * </pre>
-     */
-    static float zScoreToImportance(double zScore) {
-        if (zScore < -1.0) return 0.1f;  // Very similar to known memories
-        if (zScore <= 1.0) return 0.5f;  // Normal, expected
-        if (zScore <= 2.0) return 2.0f;  // Moderately novel
-        if (zScore <= 3.0) return 5.0f;  // Highly novel
-        return 10.0f;                     // Extreme outlier — dopamine spike!
-    }
-
-    /**
-     * Returns the underlying statistics for introspection.
-     */
-    public WelfordStats stats() {
-        return stats;
-    }
-
-    // ── V2: Dual Surprise Signal (Spatial + Temporal) ──
-
-    private final WelfordStats temporalStats = new WelfordStats();
-    private final java.util.concurrent.ConcurrentHashMap<Long, Long> lastSeenByTags =
-            new java.util.concurrent.ConcurrentHashMap<>();
-
-    /**
-     * Computes dual surprise: spatial novelty + temporal recurrence.
-     *
-     * <p>Spatial surprise measures how far a new vector is from known clusters.
-     * Temporal surprise measures how long since we saw something with similar tags —
-     * a recurrence after a long gap is itself surprising (e.g., "the database crashed
-     * again" is semantically familiar but temporally novel).</p>
-     *
-     * @param distanceToNearest L2 distance from new vector to nearest existing memory
-     * @param synapticTags      Bloom filter tags of the new memory
-     * @param spatialWeight     weight for spatial surprise (default: 0.6)
-     * @param temporalWeight    weight for temporal surprise (default: 0.4)
-     * @return importance value (0.1 to 10.0)
-     */
-    public float computeDualImportance(float distanceToNearest, long synapticTags,
-                                        float spatialWeight, float temporalWeight) {
-        // Spatial surprise
-        stats.update(distanceToNearest);
-        double spatialZ = stats.count() < warmupSamples ? 0.0 : stats.zScore(distanceToNearest);
-
-        // Temporal surprise: time since last memory with overlapping tags
-        long nowMs = System.currentTimeMillis();
-        Long lastSeen = lastSeenByTags.put(synapticTags, nowMs);
-        double temporalZ = 0.0;
-
-        if (lastSeen != null) {
-            float hoursSinceLast = (nowMs - lastSeen) / (1000f * 3600f);
-            temporalStats.update(hoursSinceLast);
-            if (temporalStats.count() >= warmupSamples) {
-                temporalZ = temporalStats.zScore(hoursSinceLast);
-            }
-        }
-
-        double combinedZ = spatialWeight * spatialZ + temporalWeight * temporalZ;
-        float importance = zScoreToImportance(combinedZ);
-
-        if (importance >= 5.0f) {
-            log.debug("Dual dopamine spike! spatialZ={}, temporalZ={}, combined={}, importance={}",
-                    spatialZ, temporalZ, combinedZ, importance);
-        }
-
-        return importance;
-    }
-
-    /**
-     * Convenience: dual surprise with default weights (0.6 spatial, 0.4 temporal).
-     */
-    public float computeDualImportance(float distanceToNearest, long synapticTags) {
-        return computeDualImportance(distanceToNearest, synapticTags, 0.6f, 0.4f);
-    }
-
-    /**
-     * Resets the detector, clearing all learned baseline statistics.
-     */
-    public void reset() {
-        stats.reset();
-        temporalStats.reset();
-        lastSeenByTags.clear();
-    }
-}
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/dopamine/WelfordStats.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/dopamine/WelfordStats.java
deleted file mode 100644
index ac8b78f..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/dopamine/WelfordStats.java
+++ /dev/null
@@ -1,104 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.dopamine;
-
-import java.util.concurrent.atomic.AtomicLong;
-import java.util.concurrent.atomic.DoubleAdder;
-
-/**
- * Welford's online algorithm for computing running mean and standard deviation.
- *
- * <p>O(1) space, O(1) per update, numerically stable. Thread-safe via atomic operations.</p>
- *
- * <h3>Biological Analog: Baseline Prediction</h3>
- * <p>The brain's dopamine system maintains an internal baseline of "expected" stimuli.
- * Welford's algorithm computes that baseline (mean) and the expected variance (stddev),
- * enabling the {@link SurpriseDetector} to calculate z-scores against the running distribution.</p>
- *
- * @see <a href="https://en.wikipedia.org/wiki/Algorithms_for_calculating_variance#Welford's_online_algorithm">
- *     Welford's Algorithm (Wikipedia)</a>
- */
-public final class WelfordStats {
-
-    private final AtomicLong count = new AtomicLong(0);
-    private volatile double mean = 0.0;
-    private volatile double m2 = 0.0;
-
-    // Lock for update atomicity (cheap — updates are infrequent relative to reads)
-    private final Object lock = new Object();
-
-    /**
-     * Incorporates a new sample into the running statistics.
-     *
-     * @param value the new observation
-     */
-    public void update(double value) {
-        synchronized (lock) {
-            long n = count.incrementAndGet();
-            double delta = value - mean;
-            mean += delta / n;
-            double delta2 = value - mean;
-            m2 += delta * delta2;
-        }
-    }
-
-    /**
-     * Returns the current running mean.
-     *
-     * @return mean of all observed values, or 0.0 if no values observed
-     */
-    public double mean() {
-        return mean;
-    }
-
-    /**
-     * Returns the current population standard deviation.
-     *
-     * @return stddev, or 0.0 if fewer than 2 values observed
-     */
-    public double stddev() {
-        long n = count.get();
-        if (n < 2) return 0.0;
-        return Math.sqrt(m2 / n);
-    }
-
-    /**
-     * Computes the z-score of a value against the running distribution.
-     *
-     * @param value the value to score
-     * @return z-score (0.0 if stddev is zero or fewer than 2 samples)
-     */
-    public double zScore(double value) {
-        double sd = stddev();
-        if (sd < 1e-9) return 0.0;
-        return (value - mean) / sd;
-    }
-
-    /**
-     * Returns the number of samples observed.
-     */
-    public long count() {
-        return count.get();
-    }
-
-    /**
-     * Resets all statistics.
-     */
-    public void reset() {
-        synchronized (lock) {
-            count.set(0);
-            mean = 0.0;
-            m2 = 0.0;
-        }
-    }
-}
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/error/SpectorCoActivationException.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/error/SpectorCoActivationException.java
deleted file mode 100644
index fffb812..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/error/SpectorCoActivationException.java
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.error;
-
-import com.spectrayan.spector.commons.error.*;
-
-/**
- * Exception thrown when a co-activation tracker operation fails.
- *
- * <p>Covers pair recording, STDP updates, predictive strength
- * computation, and association lookup ({@code SPE-310-009}).</p>
- *
- * @see ErrorCode#GRAPH_COACTIVATION_FAILED
- */
-public class SpectorCoActivationException extends SpectorGraphException {
-
-    private final String operation;
-
-    public SpectorCoActivationException(String operation) {
-        super(ErrorCode.GRAPH_COACTIVATION_FAILED, operation);
-        this.operation = operation;
-    }
-
-    public SpectorCoActivationException(String operation, Throwable cause) {
-        super(ErrorCode.GRAPH_COACTIVATION_FAILED, cause, operation);
-        this.operation = operation;
-    }
-
-    /** Returns the co-activation operation that failed. */
-    public String getOperation() {
-        return operation;
-    }
-}
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/error/SpectorEntityGraphException.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/error/SpectorEntityGraphException.java
deleted file mode 100644
index eb3ee92..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/error/SpectorEntityGraphException.java
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.error;
-
-import com.spectrayan.spector.commons.error.*;
-
-/**
- * Exception thrown when an entity graph operation fails.
- *
- * <p>Covers entity addition, relation linking, entity lookup,
- * memory linking, and graph traversal ({@code SPE-310-008}).</p>
- *
- * @see ErrorCode#GRAPH_ENTITY_FAILED
- */
-public class SpectorEntityGraphException extends SpectorGraphException {
-
-    private final String operation;
-
-    public SpectorEntityGraphException(String operation) {
-        super(ErrorCode.GRAPH_ENTITY_FAILED, operation);
-        this.operation = operation;
-    }
-
-    public SpectorEntityGraphException(String operation, Throwable cause) {
-        super(ErrorCode.GRAPH_ENTITY_FAILED, cause, operation);
-        this.operation = operation;
-    }
-
-    /** Returns the entity graph operation that failed. */
-    public String getOperation() {
-        return operation;
-    }
-}
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/error/SpectorGraphDecayException.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/error/SpectorGraphDecayException.java
deleted file mode 100644
index 780fc2a..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/error/SpectorGraphDecayException.java
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.error;
-
-import com.spectrayan.spector.commons.error.*;
-
-/**
- * Exception thrown when graph decay or pruning fails during consolidation.
- *
- * <p>Covers Hebbian edge decay, temporal chain pruning,
- * and entity graph homeostasis ({@code SPE-310-011}).</p>
- *
- * @see ErrorCode#GRAPH_DECAY_FAILED
- */
-public class SpectorGraphDecayException extends SpectorGraphException {
-
-    private final String details;
-
-    public SpectorGraphDecayException(String details) {
-        super(ErrorCode.GRAPH_DECAY_FAILED, details);
-        this.details = details;
-    }
-
-    public SpectorGraphDecayException(String details, Throwable cause) {
-        super(ErrorCode.GRAPH_DECAY_FAILED, cause, details);
-        this.details = details;
-    }
-
-    /** Returns details of the decay failure. */
-    public String getDetails() {
-        return details;
-    }
-}
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/error/SpectorGraphException.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/error/SpectorGraphException.java
deleted file mode 100644
index 209f661..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/error/SpectorGraphException.java
+++ /dev/null
@@ -1,40 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.error;
-
-import com.spectrayan.spector.commons.error.*;
-
-/**
- * Exception thrown when a cognitive graph operation fails.
- *
- * <p>Covers Hebbian graph, temporal chain, entity graph,
- * and co-activation tracker operations ({@code SPE-310-006} through
- * {@code SPE-310-011}).</p>
- *
- * @see ErrorCode#GRAPH_HEBBIAN_FAILED
- * @see ErrorCode#GRAPH_TEMPORAL_FAILED
- * @see ErrorCode#GRAPH_ENTITY_FAILED
- * @see ErrorCode#GRAPH_COACTIVATION_FAILED
- * @see ErrorCode#GRAPH_PERSISTENCE_FAILED
- * @see ErrorCode#GRAPH_DECAY_FAILED
- */
-public class SpectorGraphException extends SpectorMemoryException {
-
-    public SpectorGraphException(ErrorCode errorCode, Object... args) {
-        super(errorCode, args);
-    }
-
-    public SpectorGraphException(ErrorCode errorCode, Throwable cause, Object... args) {
-        super(errorCode, cause, args);
-    }
-}
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/error/SpectorGraphPersistenceException.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/error/SpectorGraphPersistenceException.java
deleted file mode 100644
index a3f98af..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/error/SpectorGraphPersistenceException.java
+++ /dev/null
@@ -1,51 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.error;
-
-import com.spectrayan.spector.commons.error.*;
-
-/**
- * Exception thrown when graph persistence (save/load) fails.
- *
- * <p>Covers Hebbian, temporal, entity, and co-activation
- * graph file I/O ({@code SPE-310-010}).</p>
- *
- * @see ErrorCode#GRAPH_PERSISTENCE_FAILED
- */
-public class SpectorGraphPersistenceException extends SpectorGraphException {
-
-    private final String graphType;
-    private final String path;
-
-    public SpectorGraphPersistenceException(String graphType, Object path) {
-        super(ErrorCode.GRAPH_PERSISTENCE_FAILED, graphType, path);
-        this.graphType = graphType;
-        this.path = String.valueOf(path);
-    }
-
-    public SpectorGraphPersistenceException(String graphType, Object path, Throwable cause) {
-        super(ErrorCode.GRAPH_PERSISTENCE_FAILED, cause, graphType, path);
-        this.graphType = graphType;
-        this.path = String.valueOf(path);
-    }
-
-    /** Returns the type of graph that failed to persist. */
-    public String getGraphType() {
-        return graphType;
-    }
-
-    /** Returns the file path involved. */
-    public String getPath() {
-        return path;
-    }
-}
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/error/SpectorHebbianException.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/error/SpectorHebbianException.java
deleted file mode 100644
index 4085765..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/error/SpectorHebbianException.java
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.error;
-
-import com.spectrayan.spector.commons.error.*;
-
-/**
- * Exception thrown when a Hebbian graph operation fails.
- *
- * <p>Covers edge strengthening, spreading activation, decay,
- * and session boundary detection ({@code SPE-310-006}).</p>
- *
- * @see ErrorCode#GRAPH_HEBBIAN_FAILED
- */
-public class SpectorHebbianException extends SpectorGraphException {
-
-    private final String operation;
-
-    public SpectorHebbianException(String operation) {
-        super(ErrorCode.GRAPH_HEBBIAN_FAILED, operation);
-        this.operation = operation;
-    }
-
-    public SpectorHebbianException(String operation, Throwable cause) {
-        super(ErrorCode.GRAPH_HEBBIAN_FAILED, cause, operation);
-        this.operation = operation;
-    }
-
-    /** Returns the Hebbian operation that failed. */
-    public String getOperation() {
-        return operation;
-    }
-}
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/error/SpectorMemoryConsolidationException.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/error/SpectorMemoryConsolidationException.java
deleted file mode 100644
index 960d1c9..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/error/SpectorMemoryConsolidationException.java
+++ /dev/null
@@ -1,40 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.error;
-
-import com.spectrayan.spector.commons.error.*;
-
-/**
- * Exception thrown when the memory consolidation process fails.
- *
- * @see SpectorMemoryException
- */
-public class SpectorMemoryConsolidationException extends SpectorMemoryException {
-
-    private final String details;
-
-    public SpectorMemoryConsolidationException(String details) {
-        super(ErrorCode.MEMORY_CONSOLIDATION_FAILED, details);
-        this.details = details;
-    }
-
-    public SpectorMemoryConsolidationException(String details, Throwable cause) {
-        super(ErrorCode.MEMORY_CONSOLIDATION_FAILED, cause, details);
-        this.details = details;
-    }
-
-    /** Returns details of the memory consolidation failure. */
-    public String getDetails() {
-        return details;
-    }
-}
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/error/SpectorMemoryRecallException.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/error/SpectorMemoryRecallException.java
deleted file mode 100644
index b41ef5e..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/error/SpectorMemoryRecallException.java
+++ /dev/null
@@ -1,50 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.error;
-
-import com.spectrayan.spector.commons.error.*;
-
-/**
- * Exception thrown when the cognitive recall pipeline or memory identification fails.
- *
- * @see SpectorMemoryException
- */
-public class SpectorMemoryRecallException extends SpectorMemoryException {
-
-    private final String details;
-
-    public SpectorMemoryRecallException(String details) {
-        super(ErrorCode.MEMORY_RECALL_FAILED, details);
-        this.details = details;
-    }
-
-    public SpectorMemoryRecallException(String details, Throwable cause) {
-        super(ErrorCode.MEMORY_RECALL_FAILED, cause, details);
-        this.details = details;
-    }
-
-    public SpectorMemoryRecallException(ErrorCode errorCode, String details) {
-        super(errorCode, details);
-        this.details = details;
-    }
-
-    public SpectorMemoryRecallException(ErrorCode errorCode, Throwable cause, String details) {
-        super(errorCode, cause, details);
-        this.details = details;
-    }
-
-    /** Returns details of the recall pipeline failure. */
-    public String getDetails() {
-        return details;
-    }
-}
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/error/SpectorMemoryTierFullException.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/error/SpectorMemoryTierFullException.java
deleted file mode 100644
index 88a30b1..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/error/SpectorMemoryTierFullException.java
+++ /dev/null
@@ -1,48 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.error;
-
-import com.spectrayan.spector.commons.error.*;
-
-/**
- * Exception thrown when a cognitive memory tier has reached its capacity limits.
- *
- * @see SpectorMemoryException
- */
-public class SpectorMemoryTierFullException extends SpectorMemoryException {
-
-    private final String tier;
-    private final int capacity;
-
-    public SpectorMemoryTierFullException(String tier, int capacity) {
-        super(ErrorCode.MEMORY_TIER_FULL, tier, capacity);
-        this.tier = tier;
-        this.capacity = capacity;
-    }
-
-    public SpectorMemoryTierFullException(String tier, int capacity, Throwable cause) {
-        super(ErrorCode.MEMORY_TIER_FULL, cause, tier, capacity);
-        this.tier = tier;
-        this.capacity = capacity;
-    }
-
-    /** Returns the cognitive memory tier that reached capacity. */
-    public String getTier() {
-        return tier;
-    }
-
-    /** Returns the capacity limit of the tier. */
-    public int getCapacity() {
-        return capacity;
-    }
-}
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/error/SpectorTemporalChainException.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/error/SpectorTemporalChainException.java
deleted file mode 100644
index 51ad6a9..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/error/SpectorTemporalChainException.java
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.error;
-
-import com.spectrayan.spector.commons.error.*;
-
-/**
- * Exception thrown when a temporal chain operation fails.
- *
- * <p>Covers link, followForward, followBackward,
- * and session-boundary operations ({@code SPE-310-007}).</p>
- *
- * @see ErrorCode#GRAPH_TEMPORAL_FAILED
- */
-public class SpectorTemporalChainException extends SpectorGraphException {
-
-    private final String operation;
-
-    public SpectorTemporalChainException(String operation) {
-        super(ErrorCode.GRAPH_TEMPORAL_FAILED, operation);
-        this.operation = operation;
-    }
-
-    public SpectorTemporalChainException(String operation, Throwable cause) {
-        super(ErrorCode.GRAPH_TEMPORAL_FAILED, cause, operation);
-        this.operation = operation;
-    }
-
-    /** Returns the temporal chain operation that failed. */
-    public String getOperation() {
-        return operation;
-    }
-}
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/graph/EntityExtractionMode.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/graph/EntityExtractionMode.java
deleted file mode 100644
index 18cad38..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/graph/EntityExtractionMode.java
+++ /dev/null
@@ -1,30 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.graph;
-
-/**
- * Configuration mode for entity extraction during memory ingestion.
- *
- * <p>Controls whether entities are extracted from memory text during ingestion
- * and which extraction strategy is used.</p>
- */
-public enum EntityExtractionMode {
-    /** No entity extraction (default). Entity graph features are disabled. */
-    NONE,
-
-    /** LLM-powered extraction via TextGenerationProvider. */
-    LLM,
-
-    /** Custom EntityExtractor provided via Builder. */
-    CUSTOM
-}
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/graph/EntityExtractor.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/graph/EntityExtractor.java
deleted file mode 100644
index 18568e9..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/graph/EntityExtractor.java
+++ /dev/null
@@ -1,53 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.graph;
-
-import java.util.List;
-
-/**
- * Service Provider Interface for entity extraction from memory text.
- *
- * <p>Implementations analyze text to identify named entities and their relationships.
- * This follows the same pluggable pattern as
- * {@link com.spectrayan.spector.memory.pipeline.TagExtractor} and
- * {@link com.spectrayan.spector.embed.EmbeddingProvider}.</p>
- *
- * <h3>Implementations</h3>
- * <ul>
- *   <li>{@link LlmEntityExtractor} — LLM-powered extraction via TextGenerationProvider</li>
- *   <li>{@link NoOpEntityExtractor} — returns empty list (when extraction is disabled)</li>
- * </ul>
- *
- * @see ExtractedEntity
- * @see EntityGraph
- */
-public interface EntityExtractor {
-
-    /**
-     * Extracts entities and their relationships from text.
-     *
-     * @param id   the memory identifier
-     * @param text the memory content to analyze
-     * @return list of extracted entities with typed relations
-     */
-    List<ExtractedEntity> extract(String id, String text);
-
-    /**
-     * Returns whether this extractor is available and ready.
-     *
-     * @return true if the extractor can process requests
-     */
-    default boolean isAvailable() {
-        return true;
-    }
-}
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/graph/EntityGraph.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/graph/EntityGraph.java
deleted file mode 100644
index 736c7cb..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/graph/EntityGraph.java
+++ /dev/null
@@ -1,634 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.graph;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.io.IOException;
-
-import com.spectrayan.spector.memory.error.SpectorGraphPersistenceException;
-import java.lang.foreign.Arena;
-import java.lang.foreign.MemorySegment;
-import java.lang.foreign.ValueLayout;
-import java.nio.ByteBuffer;
-import java.nio.channels.FileChannel;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.nio.file.StandardOpenOption;
-import java.util.ArrayList;
-import java.util.HashSet;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Locale;
-import java.util.Map;
-import java.util.Queue;
-import java.util.Set;
-import java.util.concurrent.ConcurrentHashMap;
-
-/**
- * Off-heap entity-relationship graph for multi-hop knowledge traversal.
- *
- * <h3>Biological Analog: Semantic Network</h3>
- * <p>The brain's semantic memory stores knowledge as a network of concepts
- * connected by typed relationships. "Alice manages Project Alpha" is stored
- * as: [Alice]—MANAGES→[Project Alpha]. This graph enables multi-hop reasoning:
- * "Find memories about projects managed by the person I met yesterday."</p>
- *
- * <h3>Architecture</h3>
- * <ul>
- *   <li>Off-heap entity nodes backed by {@link MemorySegment}</li>
- *   <li>Off-heap typed edges with fixed-width adjacency</li>
- *   <li>On-heap name→id index for O(1) entity lookup (case-insensitive)</li>
- *   <li>Max 32 edges per entity, max 4 memory references per entity</li>
- *   <li>Persistence via save/load with "EGPH" magic header</li>
- * </ul>
- *
- * <h3>Layout</h3>
- * <pre>
- *   Entity Node (64 bytes, 8-byte aligned):
- *     [type:1B][pad:7B][nameHash:8B][memRef0:4B][memRef1:4B][memRef2:4B][memRef3:4B]
- *     [refCount:4B][degree:4B][edgeStart:4B][pad:20B]
- *
- *   Entity Edge (12 bytes):
- *     [targetId:4B][relationType:4B][weight:4B]
- * </pre>
- */
-public final class EntityGraph implements AutoCloseable {
-
-    private static final Logger log = LoggerFactory.getLogger(EntityGraph.class);
-
-    /** File magic: "EGPH" in ASCII. */
-    private static final int FILE_MAGIC = 0x45475048;
-    private static final int FILE_VERSION = 1;
-    private static final int FILE_HEADER_BYTES = 24; // magic + version + entityCap + edgeCap + entityCount + reserved
-
-    /** Maximum memory references per entity. */
-    public static final int MAX_MEMORY_REFS = 4;
-
-    /** Maximum edges per entity. */
-    public static final int MAX_DEGREE = 32;
-
-    // ── Entity Node Layout (64 bytes, 8-byte aligned) ──
-    static final int ENTITY_NODE_BYTES = 64;
-    private static final long ENT_OFF_TYPE = 0;         // 1B
-    // pad: 7B for alignment
-    private static final long ENT_OFF_NAME_HASH = 8;    // 8B (8-byte aligned)
-    private static final long ENT_OFF_MEM_REFS = 16;    // 4 × 4B = 16B
-    private static final long ENT_OFF_REF_COUNT = 32;   // 4B
-    private static final long ENT_OFF_DEGREE = 36;      // 4B
-    private static final long ENT_OFF_EDGE_START = 40;  // 4B (index into edge segment)
-    // pad: 20B to reach 64B
-
-    // ── Entity Edge Layout (12 bytes) ──
-    static final int EDGE_BYTES = 12;
-    private static final long EDGE_OFF_TARGET = 0;       // 4B
-    private static final long EDGE_OFF_REL_TYPE = 4;     // 4B
-    private static final long EDGE_OFF_WEIGHT = 8;       // 4B (float)
-
-    private final Arena arena;
-    private final MemorySegment entitySegment;
-    private final MemorySegment edgeSegment;
-    private final int entityCapacity;
-    private final int edgeCapacity;
-    private int entityCount;
-    private int edgeCount;
-
-    /** On-heap name→entityId index for O(1) lookup (case-insensitive). */
-    private final ConcurrentHashMap<String, Integer> nameIndex = new ConcurrentHashMap<>();
-
-    /**
-     * Creates a new entity graph.
-     *
-     * @param entityCapacity maximum number of entities
-     * @param edgeCapacity   maximum number of edges (default: entityCapacity × MAX_DEGREE)
-     */
-    public EntityGraph(int entityCapacity, int edgeCapacity) {
-        this.entityCapacity = entityCapacity;
-        this.edgeCapacity = edgeCapacity;
-        this.entityCount = 0;
-        this.edgeCount = 0;
-        this.arena = Arena.ofShared();
-        this.entitySegment = arena.allocate((long) ENTITY_NODE_BYTES * entityCapacity);
-        this.edgeSegment = arena.allocate((long) EDGE_BYTES * edgeCapacity);
-        entitySegment.fill((byte) 0);
-        edgeSegment.fill((byte) 0);
-
-        log.info("EntityGraph initialized: entities={}, edges={}, memory={}KB",
-                entityCapacity, edgeCapacity,
-                ((long) ENTITY_NODE_BYTES * entityCapacity + (long) EDGE_BYTES * edgeCapacity) / 1024);
-    }
-
-    /**
-     * Creates a new entity graph with default edge capacity.
-     *
-     * @param entityCapacity maximum number of entities
-     */
-    public EntityGraph(int entityCapacity) {
-        this(entityCapacity, entityCapacity * MAX_DEGREE);
-    }
-
-    /**
-     * Private constructor for loading from pre-existing segments.
-     */
-    private EntityGraph(int entityCapacity, int edgeCapacity, int entityCount, int edgeCount,
-                         Arena arena, MemorySegment entitySegment, MemorySegment edgeSegment,
-                         ConcurrentHashMap<String, Integer> nameIndex) {
-        this.entityCapacity = entityCapacity;
-        this.edgeCapacity = edgeCapacity;
-        this.entityCount = entityCount;
-        this.edgeCount = edgeCount;
-        this.arena = arena;
-        this.entitySegment = entitySegment;
-        this.edgeSegment = edgeSegment;
-        this.nameIndex.putAll(nameIndex);
-    }
-
-    /**
-     * Adds an entity to the graph, or returns the existing ID if already present.
-     *
-     * <p>Entity names are case-insensitive and normalized to lowercase.</p>
-     *
-     * @param name entity name
-     * @param type entity type
-     * @return entity ID (index into entity segment)
-     */
-    public int addEntity(String name, EntityType type) {
-        if (name == null || name.isBlank()) return -1;
-        if (type == null) type = EntityType.OTHER;
-        String normalized = name.trim().toLowerCase(Locale.ROOT);
-
-        // Check if already exists
-        Integer existing = nameIndex.get(normalized);
-        if (existing != null) {
-            return existing;
-        }
-
-        if (entityCount >= entityCapacity) {
-            log.warn("EntityGraph full ({} entities), rejecting '{}'", entityCapacity, name);
-            return -1;
-        }
-
-        int entityId = entityCount++;
-        long offset = (long) entityId * ENTITY_NODE_BYTES;
-
-        entitySegment.set(ValueLayout.JAVA_BYTE, offset + ENT_OFF_TYPE, (byte) type.ordinal());
-        entitySegment.set(ValueLayout.JAVA_LONG, offset + ENT_OFF_NAME_HASH, normalized.hashCode());
-        entitySegment.set(ValueLayout.JAVA_INT, offset + ENT_OFF_REF_COUNT, 0);
-        entitySegment.set(ValueLayout.JAVA_INT, offset + ENT_OFF_DEGREE, 0);
-        entitySegment.set(ValueLayout.JAVA_INT, offset + ENT_OFF_EDGE_START, -1);
-
-        nameIndex.put(normalized, entityId);
-
-        log.trace("Entity added: id={}, name='{}', type={}", entityId, name, type);
-        return entityId;
-    }
-
-    /**
-     * Adds a typed relation between two entities.
-     *
-     * @param fromEntity source entity ID
-     * @param toEntity   target entity ID
-     * @param type       relation type
-     */
-    public synchronized void addRelation(int fromEntity, int toEntity, RelationType type) {
-        if (fromEntity < 0 || fromEntity >= entityCount) return;
-        if (toEntity < 0 || toEntity >= entityCount) return;
-        if (fromEntity == toEntity) return;
-
-        long entityOffset = (long) fromEntity * ENTITY_NODE_BYTES;
-        int degree = entitySegment.get(ValueLayout.JAVA_INT, entityOffset + ENT_OFF_DEGREE);
-        int edgeStart = entitySegment.get(ValueLayout.JAVA_INT, entityOffset + ENT_OFF_EDGE_START);
-
-        // Check if relation already exists (strengthen weight)
-        if (edgeStart >= 0) {
-            for (int i = 0; i < degree; i++) {
-                long edgeOffset = (long) (edgeStart + i) * EDGE_BYTES;
-                int target = edgeSegment.get(ValueLayout.JAVA_INT, edgeOffset + EDGE_OFF_TARGET);
-                int relType = edgeSegment.get(ValueLayout.JAVA_INT, edgeOffset + EDGE_OFF_REL_TYPE);
-                if (target == toEntity && relType == type.ordinal()) {
-                    // Strengthen existing edge
-                    float weight = edgeSegment.get(ValueLayout.JAVA_FLOAT, edgeOffset + EDGE_OFF_WEIGHT);
-                    edgeSegment.set(ValueLayout.JAVA_FLOAT, edgeOffset + EDGE_OFF_WEIGHT, weight + 1.0f);
-                    return;
-                }
-            }
-        }
-
-        // Add new edge
-        if (degree >= MAX_DEGREE) {
-            log.trace("Entity {} at max degree ({}), rejecting edge to {}", fromEntity, MAX_DEGREE, toEntity);
-            return;
-        }
-        if (edgeCount >= edgeCapacity) {
-            log.warn("EntityGraph edge capacity full ({}), rejecting edge", edgeCapacity);
-            return;
-        }
-
-        // Allocate edge block if first edge for this entity
-        if (edgeStart < 0) {
-            edgeStart = edgeCount;
-            entitySegment.set(ValueLayout.JAVA_INT, entityOffset + ENT_OFF_EDGE_START, edgeStart);
-        }
-
-        int edgeIdx = edgeStart + degree;
-        // If non-contiguous, append at end
-        if (edgeIdx != edgeCount && edgeStart + degree >= edgeCount) {
-            edgeIdx = edgeCount;
-        }
-
-        long edgeOffset = (long) edgeIdx * EDGE_BYTES;
-        edgeSegment.set(ValueLayout.JAVA_INT, edgeOffset + EDGE_OFF_TARGET, toEntity);
-        edgeSegment.set(ValueLayout.JAVA_INT, edgeOffset + EDGE_OFF_REL_TYPE, type.ordinal());
-        edgeSegment.set(ValueLayout.JAVA_FLOAT, edgeOffset + EDGE_OFF_WEIGHT, 1.0f);
-
-        entitySegment.set(ValueLayout.JAVA_INT, entityOffset + ENT_OFF_DEGREE, degree + 1);
-        edgeCount = Math.max(edgeCount, edgeIdx + 1);
-    }
-
-    /**
-     * Links an entity to a memory index.
-     *
-     * @param entityId  entity ID
-     * @param memoryIdx index of the memory that mentions this entity
-     */
-    public void linkEntityToMemory(int entityId, int memoryIdx) {
-        if (entityId < 0 || entityId >= entityCount) return;
-
-        long offset = (long) entityId * ENTITY_NODE_BYTES;
-        int refCount = entitySegment.get(ValueLayout.JAVA_INT, offset + ENT_OFF_REF_COUNT);
-
-        if (refCount >= MAX_MEMORY_REFS) return; // full
-
-        // Check for duplicate
-        for (int i = 0; i < refCount; i++) {
-            int existing = entitySegment.get(ValueLayout.JAVA_INT,
-                    offset + ENT_OFF_MEM_REFS + (long) i * 4);
-            if (existing == memoryIdx) return;
-        }
-
-        entitySegment.set(ValueLayout.JAVA_INT,
-                offset + ENT_OFF_MEM_REFS + (long) refCount * 4, memoryIdx);
-        entitySegment.set(ValueLayout.JAVA_INT, offset + ENT_OFF_REF_COUNT, refCount + 1);
-    }
-
-    /**
-     * Finds an entity by name (case-insensitive).
-     *
-     * @param name entity name
-     * @return entity ID, or -1 if not found
-     */
-    public int findEntity(String name) {
-        if (name == null || name.isBlank()) return -1;
-        String normalized = name.trim().toLowerCase(Locale.ROOT);
-        Integer id = nameIndex.get(normalized);
-        return id != null ? id : -1;
-    }
-
-    /**
-     * Returns the memory indices that reference an entity.
-     *
-     * @param entityId entity ID
-     * @return array of memory indices
-     */
-    public int[] memoriesForEntity(int entityId) {
-        if (entityId < 0 || entityId >= entityCount) return new int[0];
-
-        long offset = (long) entityId * ENTITY_NODE_BYTES;
-        int refCount = entitySegment.get(ValueLayout.JAVA_INT, offset + ENT_OFF_REF_COUNT);
-        int[] result = new int[refCount];
-        for (int i = 0; i < refCount; i++) {
-            result[i] = entitySegment.get(ValueLayout.JAVA_INT,
-                    offset + ENT_OFF_MEM_REFS + (long) i * 4);
-        }
-        return result;
-    }
-
-    /**
-     * Returns the entity type for an entity ID.
-     */
-    public EntityType entityType(int entityId) {
-        if (entityId < 0 || entityId >= entityCount) return EntityType.OTHER;
-        byte typeOrd = entitySegment.get(ValueLayout.JAVA_BYTE,
-                (long) entityId * ENTITY_NODE_BYTES + ENT_OFF_TYPE);
-        EntityType[] types = EntityType.values();
-        return typeOrd >= 0 && typeOrd < types.length ? types[typeOrd] : EntityType.OTHER;
-    }
-
-    /**
-     * Returns the edges for an entity.
-     */
-    public List<EntityEdge> edges(int entityId) {
-        if (entityId < 0 || entityId >= entityCount) return List.of();
-
-        long offset = (long) entityId * ENTITY_NODE_BYTES;
-        int degree = entitySegment.get(ValueLayout.JAVA_INT, offset + ENT_OFF_DEGREE);
-        int edgeStart = entitySegment.get(ValueLayout.JAVA_INT, offset + ENT_OFF_EDGE_START);
-
-        if (edgeStart < 0 || degree == 0) return List.of();
-
-        List<EntityEdge> result = new ArrayList<>(degree);
-        for (int i = 0; i < degree; i++) {
-            long edgeOffset = (long) (edgeStart + i) * EDGE_BYTES;
-            int target = edgeSegment.get(ValueLayout.JAVA_INT, edgeOffset + EDGE_OFF_TARGET);
-            int relTypeOrd = edgeSegment.get(ValueLayout.JAVA_INT, edgeOffset + EDGE_OFF_REL_TYPE);
-            float weight = edgeSegment.get(ValueLayout.JAVA_FLOAT, edgeOffset + EDGE_OFF_WEIGHT);
-
-            RelationType[] types = RelationType.values();
-            RelationType relType = relTypeOrd >= 0 && relTypeOrd < types.length
-                    ? types[relTypeOrd] : RelationType.OTHER;
-
-            result.add(new EntityEdge(target, relType, weight));
-        }
-        return result;
-    }
-
-    /**
-     * BFS traversal from a starting entity with optional relation type filter.
-     *
-     * @param startEntity entity ID to start from
-     * @param filter      relation type filter (null = accept all)
-     * @param maxHops     maximum traversal depth
-     * @return list of reached entity IDs with their hop distances
-     */
-    public List<TraversalResult> traverse(int startEntity, RelationType filter, int maxHops) {
-        if (startEntity < 0 || startEntity >= entityCount) return List.of();
-
-        List<TraversalResult> results = new ArrayList<>();
-        Set<Integer> visited = new HashSet<>();
-        Queue<int[]> queue = new LinkedList<>(); // [entityId, depth]
-        queue.add(new int[]{startEntity, 0});
-        visited.add(startEntity);
-
-        while (!queue.isEmpty()) {
-            int[] current = queue.poll();
-            int entityId = current[0];
-            int depth = current[1];
-
-            if (depth > 0) {
-                results.add(new TraversalResult(entityId, depth));
-            }
-
-            if (depth >= maxHops) continue;
-
-            for (EntityEdge edge : edges(entityId)) {
-                if (filter != null && edge.relationType() != filter) continue;
-                if (visited.contains(edge.targetEntityId())) continue;
-                visited.add(edge.targetEntityId());
-                queue.add(new int[]{edge.targetEntityId(), depth + 1});
-            }
-        }
-
-        return results;
-    }
-
-    /**
-     * Collects all memory indices reachable from a starting entity within maxHops.
-     *
-     * @param startEntity starting entity ID
-     * @param filter      optional relation type filter
-     * @param maxHops     maximum traversal depth
-     * @return set of memory indices
-     */
-    public Set<Integer> collectMemories(int startEntity, RelationType filter, int maxHops) {
-        Set<Integer> memories = new HashSet<>();
-
-        // Include start entity's memories
-        for (int memIdx : memoriesForEntity(startEntity)) {
-            memories.add(memIdx);
-        }
-
-        // Traverse and collect
-        for (TraversalResult tr : traverse(startEntity, filter, maxHops)) {
-            for (int memIdx : memoriesForEntity(tr.entityId())) {
-                memories.add(memIdx);
-            }
-        }
-
-        return memories;
-    }
-
-    /**
-     * Returns the number of entities in the graph.
-     */
-    public int entityCount() {
-        return entityCount;
-    }
-
-    /**
-     * Returns the number of edges in the graph.
-     */
-    public int edgeCount() {
-        return edgeCount;
-    }
-
-    /**
-     * Returns the name index for inspection/debugging.
-     */
-    public Map<String, Integer> nameIndex() {
-        return Map.copyOf(nameIndex);
-    }
-
-    /**
-     * An edge in the entity graph.
-     */
-    public record EntityEdge(int targetEntityId, RelationType relationType, float weight) {}
-
-    /**
-     * A BFS traversal result.
-     */
-    public record TraversalResult(int entityId, int hopDistance) {}
-
-    // ══════════════════════════════════════════════════════════════
-    // PERSISTENCE: save / load
-    // ══════════════════════════════════════════════════════════════
-
-    /**
-     * Saves the graph to a binary file.
-     *
-     * @param filePath path to write
-     */
-    public void save(Path filePath) {
-        Path parent = filePath.getParent();
-        if (parent != null) {
-            try {
-                Files.createDirectories(parent);
-            } catch (IOException e) {
-                throw new SpectorGraphPersistenceException("EntityGraph", parent, e);
-            }
-        }
-
-        try (FileChannel ch = FileChannel.open(filePath,
-                StandardOpenOption.CREATE, StandardOpenOption.WRITE,
-                StandardOpenOption.TRUNCATE_EXISTING)) {
-
-            // Header: magic + version + entityCap + edgeCap + entityCount + edgeCount
-            ByteBuffer header = ByteBuffer.allocate(FILE_HEADER_BYTES);
-            header.putInt(FILE_MAGIC);
-            header.putInt(FILE_VERSION);
-            header.putInt(entityCapacity);
-            header.putInt(edgeCapacity);
-            header.putInt(entityCount);
-            header.putInt(edgeCount);
-            header.flip();
-            ch.write(header);
-
-            // Write entity segment
-            writeSegment(ch, entitySegment, (long) ENTITY_NODE_BYTES * entityCapacity);
-
-            // Write edge segment
-            writeSegment(ch, edgeSegment, (long) EDGE_BYTES * edgeCapacity);
-
-            // Write name index (on-heap → serialized)
-            ByteBuffer nameCountBuf = ByteBuffer.allocate(4);
-            nameCountBuf.putInt(nameIndex.size());
-            nameCountBuf.flip();
-            ch.write(nameCountBuf);
-
-            for (Map.Entry<String, Integer> entry : nameIndex.entrySet()) {
-                byte[] nameBytes = entry.getKey().getBytes(java.nio.charset.StandardCharsets.UTF_8);
-                ByteBuffer entryBuf = ByteBuffer.allocate(4 + nameBytes.length + 4);
-                entryBuf.putInt(nameBytes.length);
-                entryBuf.put(nameBytes);
-                entryBuf.putInt(entry.getValue());
-                entryBuf.flip();
-                ch.write(entryBuf);
-            }
-
-            ch.force(true);
-            log.info("EntityGraph saved: entities={}, edges={} → {}",
-                    entityCount, edgeCount, filePath);
-
-        } catch (IOException e) {
-            throw new SpectorGraphPersistenceException("EntityGraph", filePath, e);
-        }
-    }
-
-    /**
-     * Loads a graph from a binary file, or returns a new empty graph.
-     *
-     * @param filePath          path to the graph file
-     * @param defaultEntityCap  entity capacity if file doesn't exist
-     * @param defaultEdgeCap    edge capacity if file doesn't exist
-     * @return an EntityGraph (loaded or new)
-     */
-    public static EntityGraph load(Path filePath, int defaultEntityCap, int defaultEdgeCap) {
-        if (filePath == null || !Files.exists(filePath)) {
-            log.info("EntityGraph file not found, creating fresh: {}", filePath);
-            return new EntityGraph(defaultEntityCap, defaultEdgeCap);
-        }
-
-        try (FileChannel ch = FileChannel.open(filePath, StandardOpenOption.READ)) {
-            if (ch.size() < FILE_HEADER_BYTES) {
-                log.warn("EntityGraph file too small, creating fresh");
-                return new EntityGraph(defaultEntityCap, defaultEdgeCap);
-            }
-
-            ByteBuffer header = ByteBuffer.allocate(FILE_HEADER_BYTES);
-            ch.read(header);
-            header.flip();
-
-            int magic = header.getInt();
-            int version = header.getInt();
-            int entityCap = header.getInt();
-            int edgeCap = header.getInt();
-            int entCount = header.getInt();
-            int edgCount = header.getInt();
-
-            if (magic != FILE_MAGIC || version != FILE_VERSION) {
-                log.warn("Invalid EntityGraph file, creating fresh");
-                return new EntityGraph(defaultEntityCap, defaultEdgeCap);
-            }
-
-            Arena arena = Arena.ofShared();
-
-            // Read entity segment
-            long entityBytes = (long) ENTITY_NODE_BYTES * entityCap;
-            MemorySegment entSeg = arena.allocate(entityBytes);
-            readSegment(ch, entSeg, entityBytes);
-
-            // Read edge segment
-            long edgeBytes = (long) EDGE_BYTES * edgeCap;
-            MemorySegment edgSeg = arena.allocate(edgeBytes);
-            readSegment(ch, edgSeg, edgeBytes);
-
-            // Read name index
-            ConcurrentHashMap<String, Integer> names = new ConcurrentHashMap<>();
-            ByteBuffer countBuf = ByteBuffer.allocate(4);
-            ch.read(countBuf);
-            countBuf.flip();
-            int nameCount = countBuf.getInt();
-
-            for (int i = 0; i < nameCount; i++) {
-                ByteBuffer lenBuf = ByteBuffer.allocate(4);
-                ch.read(lenBuf);
-                lenBuf.flip();
-                int len = lenBuf.getInt();
-
-                ByteBuffer nameBuf = ByteBuffer.allocate(len);
-                ch.read(nameBuf);
-                nameBuf.flip();
-                String name = new String(nameBuf.array(), 0, len, java.nio.charset.StandardCharsets.UTF_8);
-
-                ByteBuffer idBuf = ByteBuffer.allocate(4);
-                ch.read(idBuf);
-                idBuf.flip();
-                int id = idBuf.getInt();
-
-                names.put(name, id);
-            }
-
-            EntityGraph graph = new EntityGraph(entityCap, edgeCap, entCount, edgCount,
-                    arena, entSeg, edgSeg, names);
-            log.info("EntityGraph loaded: entities={}, edges={} from {}",
-                    entCount, edgCount, filePath);
-            return graph;
-
-        } catch (IOException e) {
-            log.error("Failed to load EntityGraph, creating fresh: {}", e.getMessage());
-            return new EntityGraph(defaultEntityCap, defaultEdgeCap);
-        }
-    }
-
-    private static void writeSegment(FileChannel ch, MemorySegment seg, long totalBytes)
-            throws IOException {
-        long written = 0;
-        int chunkSize = 64 * 1024;
-        while (written < totalBytes) {
-            int toWrite = (int) Math.min(chunkSize, totalBytes - written);
-            ByteBuffer buf = seg.asSlice(written, toWrite).asByteBuffer().asReadOnlyBuffer();
-            ch.write(buf);
-            written += toWrite;
-        }
-    }
-
-    private static void readSegment(FileChannel ch, MemorySegment seg, long totalBytes)
-            throws IOException {
-        long read = 0;
-        int chunkSize = 64 * 1024;
-        while (read < totalBytes) {
-            int toRead = (int) Math.min(chunkSize, totalBytes - read);
-            ByteBuffer buf = ByteBuffer.allocate(toRead);
-            ch.read(buf);
-            buf.flip();
-            MemorySegment.copy(MemorySegment.ofBuffer(buf), 0, seg, read, toRead);
-            read += toRead;
-        }
-    }
-
-    @Override
-    public void close() {
-        log.info("EntityGraph closing (entities={}, edges={})", entityCount, edgeCount);
-        arena.close();
-    }
-}
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/graph/EntityRelation.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/graph/EntityRelation.java
deleted file mode 100644
index b2e3249..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/graph/EntityRelation.java
+++ /dev/null
@@ -1,24 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.graph;
-
-/**
- * A typed relation between two entities extracted from memory text.
- *
- * @param targetEntityName name of the target entity (will be resolved to ID during graph population)
- * @param relationType     the type of relationship
- */
-public record EntityRelation(
-        String targetEntityName,
-        RelationType relationType
-) {}
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/graph/EntityType.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/graph/EntityType.java
deleted file mode 100644
index ba06f17..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/graph/EntityType.java
+++ /dev/null
@@ -1,91 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.graph;
-
-/**
- * Entity types for the knowledge graph.
- *
- * <p>Entities extracted from memory text are classified into these categories
- * to enable typed traversal and filtering in the entity-relationship graph.</p>
- *
- * <h3>Category Groups</h3>
- * <ul>
- *   <li><b>People &amp; Org:</b> PERSON, ORGANIZATION, TEAM, ROLE</li>
- *   <li><b>Projects &amp; Products:</b> PROJECT, PRODUCT, TASK</li>
- *   <li><b>Knowledge:</b> CONCEPT, TOPIC, SKILL, DECISION</li>
- *   <li><b>Tech:</b> TECHNOLOGY, TOOL, API, ARTIFACT</li>
- *   <li><b>World:</b> EVENT, LOCATION, DATE_TIME</li>
- *   <li><b>Process &amp; Data:</b> PROCESS, METRIC, DOCUMENT</li>
- *   <li><b>Catch-all:</b> OTHER</li>
- * </ul>
- */
-public enum EntityType {
-
-    // ── People & Organizations ──
-    /** A person: user, colleague, customer, author, etc. */
-    PERSON,
-    /** A company, institution, government body, or formal organization. */
-    ORGANIZATION,
-    /** A team, squad, department, group, or committee. */
-    TEAM,
-    /** A job title, role, or position (e.g., "tech lead", "reviewer"). */
-    ROLE,
-
-    // ── Projects & Products ──
-    /** A project, initiative, or workstream. */
-    PROJECT,
-    /** A software product, service, or SaaS tool. */
-    PRODUCT,
-    /** A task, ticket, issue, bug, or action item. */
-    TASK,
-
-    // ── Knowledge & Decisions ──
-    /** An abstract concept, idea, or theory. */
-    CONCEPT,
-    /** A knowledge domain, subject area, or discipline. */
-    TOPIC,
-    /** A skill, competency, or expertise area. */
-    SKILL,
-    /** An architectural decision, ADR, or policy choice. */
-    DECISION,
-
-    // ── Technology ──
-    /** A programming language, framework, library, or platform. */
-    TECHNOLOGY,
-    /** A tool, utility, or instrument. */
-    TOOL,
-    /** An API, endpoint, interface, or protocol. */
-    API,
-    /** A code file, commit, branch, PR, or configuration artifact. */
-    ARTIFACT,
-
-    // ── World ──
-    /** An event, meeting, conference, incident, or milestone. */
-    EVENT,
-    /** A physical or virtual location, address, or region. */
-    LOCATION,
-    /** A specific date, time, period, or deadline. */
-    DATE_TIME,
-
-    // ── Process & Data ──
-    /** A workflow, pipeline, methodology, or procedure. */
-    PROCESS,
-    /** A KPI, measurement, quantity, or metric. */
-    METRIC,
-    /** A document, file, paper, article, or report. */
-    DOCUMENT,
-
-    // ── Catch-all ──
-    /** Any entity that doesn't fit the above categories. */
-    OTHER
-}
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/graph/ExtractedEntity.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/graph/ExtractedEntity.java
deleted file mode 100644
index 5107ba7..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/graph/ExtractedEntity.java
+++ /dev/null
@@ -1,38 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.graph;
-
-import java.util.List;
-
-/**
- * An entity extracted from memory text, with its type and relations.
- *
- * <p>Returned by {@link EntityExtractor} during ingestion. The entity name
- * is case-insensitive (normalized during graph population).</p>
- *
- * @param name      entity name (e.g., "Alice", "Project Alpha")
- * @param type      entity classification
- * @param relations typed edges to other entities mentioned in the same text
- */
-public record ExtractedEntity(
-        String name,
-        EntityType type,
-        List<EntityRelation> relations
-) {
-    /**
-     * Creates an entity with no relations.
-     */
-    public ExtractedEntity(String name, EntityType type) {
-        this(name, type, List.of());
-    }
-}
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/graph/LlmEntityExtractor.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/graph/LlmEntityExtractor.java
deleted file mode 100644
index 41ed817..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/graph/LlmEntityExtractor.java
+++ /dev/null
@@ -1,208 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.graph;
-
-import com.spectrayan.spector.commons.ResourceUtils;
-import com.spectrayan.spector.embed.TextGenerationProvider;
-import com.spectrayan.spector.memory.error.SpectorEntityGraphException;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Locale;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
-
-/**
- * LLM-powered entity extractor using a {@link TextGenerationProvider}.
- *
- * <h3>How It Works</h3>
- * <p>Sends a structured prompt to the LLM asking it to identify entities
- * and their relationships from the text. The prompt is loaded from the
- * classpath resource {@code prompts/entity-extraction.txt} and cached
- * by {@link ResourceUtils}. The LLM returns a simple line-based format
- * which is parsed into {@link ExtractedEntity} records.</p>
- *
- * <h3>Output Format Expected from LLM</h3>
- * <pre>
- *   ENTITY: Alice | PERSON
- *   ENTITY: Project Alpha | PROJECT
- *   RELATION: Alice | MANAGES | Project Alpha
- * </pre>
- *
- * <h3>Fallback</h3>
- * <p>If the LLM is unavailable or returns unparseable output,
- * returns an empty list (graceful degradation).</p>
- *
- * <h3>Performance Note</h3>
- * <p>LLM inference adds ~500ms–2s per memory. Use this extractor for
- * high-value ingestion where entity quality justifies the latency.</p>
- *
- * @see EntityExtractor
- * @see TextGenerationProvider
- * @see ResourceUtils
- */
-public final class LlmEntityExtractor implements EntityExtractor {
-
-    private static final Logger log = LoggerFactory.getLogger(LlmEntityExtractor.class);
-
-    /** Classpath path to the entity extraction prompt template. */
-    private static final String PROMPT_RESOURCE = "prompts/entity-extraction.txt";
-
-    private static final int MAX_CONTENT_FOR_PROMPT = 1500;
-    private static final int DEFAULT_MAX_ENTITIES = 10;
-    private static final int DEFAULT_MAX_RELATIONS = 20;
-
-    private static final Pattern ENTITY_PATTERN = Pattern.compile(
-            "^ENTITY:\\s*(.+?)\\s*\\|\\s*(\\w+)\\s*$", Pattern.MULTILINE);
-    private static final Pattern RELATION_PATTERN = Pattern.compile(
-            "^RELATION:\\s*(.+?)\\s*\\|\\s*(\\w+)\\s*\\|\\s*(.+?)\\s*$", Pattern.MULTILINE);
-
-    private final TextGenerationProvider generator;
-    private final int maxEntities;
-    private final int maxRelations;
-
-    /**
-     * Creates an LLM entity extractor with default limits.
-     *
-     * @param generator the text generation provider
-     */
-    public LlmEntityExtractor(TextGenerationProvider generator) {
-        this(generator, DEFAULT_MAX_ENTITIES, DEFAULT_MAX_RELATIONS);
-    }
-
-    /**
-     * Creates an LLM entity extractor with custom limits.
-     *
-     * @param generator    the text generation provider
-     * @param maxEntities  maximum entities to extract per memory
-     * @param maxRelations maximum relations to extract per memory
-     */
-    public LlmEntityExtractor(TextGenerationProvider generator,
-                               int maxEntities, int maxRelations) {
-        this.generator = generator;
-        this.maxEntities = maxEntities;
-        this.maxRelations = maxRelations;
-    }
-
-    @Override
-    public List<ExtractedEntity> extract(String id, String text) {
-        if (generator == null || !generator.isAvailable()) {
-            return List.of();
-        }
-
-        try {
-            String content = text != null && text.length() > MAX_CONTENT_FOR_PROMPT
-                    ? text.substring(0, MAX_CONTENT_FOR_PROMPT) : text;
-
-            // Load prompt template from classpath (cached by ResourceUtils)
-            String promptTemplate = ResourceUtils.loadResource(PROMPT_RESOURCE);
-            String prompt = String.format(promptTemplate,
-                    maxEntities, maxRelations,
-                    content != null ? content : id);
-            String response = generator.generate(prompt);
-
-            if (response == null || response.isBlank()) {
-                log.debug("LLM returned empty entities for '{}', skipping", id);
-                return List.of();
-            }
-
-            return parseResponse(response, id);
-
-        } catch (RuntimeException e) {
-            SpectorEntityGraphException ex = new SpectorEntityGraphException("LLM extraction", e);
-            log.warn(ex.getMessage());
-            return List.of();
-        }
-    }
-
-    @Override
-    public boolean isAvailable() {
-        return generator != null && generator.isAvailable();
-    }
-
-    /**
-     * Parses the LLM response into extracted entities with relations.
-     */
-    private List<ExtractedEntity> parseResponse(String response, String id) {
-        // Parse entities
-        List<String> entityNames = new ArrayList<>();
-        List<EntityType> entityTypes = new ArrayList<>();
-
-        Matcher entityMatcher = ENTITY_PATTERN.matcher(response);
-        int entityCount = 0;
-        while (entityMatcher.find() && entityCount < maxEntities) {
-            String name = entityMatcher.group(1).trim();
-            String typeStr = entityMatcher.group(2).trim().toUpperCase(Locale.ROOT);
-
-            EntityType type;
-            try {
-                type = EntityType.valueOf(typeStr);
-            } catch (IllegalArgumentException e) {
-                type = EntityType.OTHER;
-            }
-
-            entityNames.add(name);
-            entityTypes.add(type);
-            entityCount++;
-        }
-
-        if (entityNames.isEmpty()) {
-            log.debug("No entities parsed from LLM response for '{}'", id);
-            return List.of();
-        }
-
-        // Parse relations
-        List<RelationTriple> relations = new ArrayList<>();
-        Matcher relationMatcher = RELATION_PATTERN.matcher(response);
-        int relationCount = 0;
-        while (relationMatcher.find() && relationCount < maxRelations) {
-            String source = relationMatcher.group(1).trim();
-            String typeStr = relationMatcher.group(2).trim().toUpperCase(Locale.ROOT);
-            String target = relationMatcher.group(3).trim();
-
-            RelationType relType;
-            try {
-                relType = RelationType.valueOf(typeStr);
-            } catch (IllegalArgumentException e) {
-                relType = RelationType.OTHER;
-            }
-
-            relations.add(new RelationTriple(source, relType, target));
-            relationCount++;
-        }
-
-        // Build ExtractedEntity list with attached relations
-        List<ExtractedEntity> result = new ArrayList<>();
-        for (int i = 0; i < entityNames.size(); i++) {
-            String name = entityNames.get(i);
-            EntityType type = entityTypes.get(i);
-
-            // Collect relations where this entity is the source
-            List<EntityRelation> entityRelations = relations.stream()
-                    .filter(r -> r.source.equalsIgnoreCase(name))
-                    .map(r -> new EntityRelation(r.target, r.type))
-                    .toList();
-
-            result.add(new ExtractedEntity(name, type, entityRelations));
-        }
-
-        log.debug("LLM extracted {} entities, {} relations for '{}'",
-                entityNames.size(), relations.size(), id);
-        return result;
-    }
-
-    private record RelationTriple(String source, RelationType type, String target) {}
-}
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/graph/NoOpEntityExtractor.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/graph/NoOpEntityExtractor.java
deleted file mode 100644
index 0d2bb2a..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/graph/NoOpEntityExtractor.java
+++ /dev/null
@@ -1,39 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.graph;
-
-import java.util.List;
-
-/**
- * No-op entity extractor that returns an empty list.
- *
- * <p>Used when entity extraction is disabled ({@link EntityExtractionMode#NONE}).
- * All calls to {@link #extract} return immediately with no overhead.</p>
- */
-public final class NoOpEntityExtractor implements EntityExtractor {
-
-    /** Singleton instance. */
-    public static final NoOpEntityExtractor INSTANCE = new NoOpEntityExtractor();
-
-    private NoOpEntityExtractor() {}
-
-    @Override
-    public List<ExtractedEntity> extract(String id, String text) {
-        return List.of();
-    }
-
-    @Override
-    public boolean isAvailable() {
-        return true;
-    }
-}
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/graph/RelationType.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/graph/RelationType.java
deleted file mode 100644
index 8408cc3..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/graph/RelationType.java
+++ /dev/null
@@ -1,86 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.graph;
-
-/**
- * Relation types for edges in the entity-relationship graph.
- *
- * <p>Each edge between two entities carries a typed relation that enables
- * directed traversal and semantic filtering during recall.</p>
- *
- * <h3>Category Groups</h3>
- * <ul>
- *   <li><b>People:</b> MANAGES, REPORTS_TO, KNOWS, ASSIGNED_TO, AUTHORED</li>
- *   <li><b>Work:</b> WORKS_ON, CREATED_BY, OWNS, IMPLEMENTS</li>
- *   <li><b>Structure:</b> PART_OF, CONTAINS, DEPENDS_ON, USES</li>
- *   <li><b>Causality:</b> CAUSES, BLOCKS, SUPERSEDES, PRECEDES, FOLLOWS</li>
- *   <li><b>Location:</b> LOCATED_AT</li>
- *   <li><b>Catch-all:</b> RELATED_TO, OTHER</li>
- * </ul>
- */
-public enum RelationType {
-
-    // ── People & Roles ──
-    /** A manages B (team lead → engineer, PM → project). */
-    MANAGES,
-    /** A reports to B (engineer → team lead). */
-    REPORTS_TO,
-    /** A knows B (interpersonal knowledge). */
-    KNOWS,
-    /** A is assigned to B (person → task/ticket). */
-    ASSIGNED_TO,
-    /** A authored/created B (person → document/artifact). */
-    AUTHORED,
-
-    // ── Work & Ownership ──
-    /** A works on B (person → project/task). */
-    WORKS_ON,
-    /** A was created by B (artifact → person/tool). */
-    CREATED_BY,
-    /** A owns B (team → service, person → repo). */
-    OWNS,
-    /** A implements B (code → design, service → API). */
-    IMPLEMENTS,
-
-    // ── Structural ──
-    /** A is part of B (component → system, file → module). */
-    PART_OF,
-    /** A contains B (module → class, project → task). */
-    CONTAINS,
-    /** A depends on B (service → library, task → prerequisite). */
-    DEPENDS_ON,
-    /** A uses B (project → technology, person → tool). */
-    USES,
-
-    // ── Causality & Temporal ──
-    /** A causes B (action → consequence, decision → outcome). */
-    CAUSES,
-    /** A blocks B (blocker → blocked task). */
-    BLOCKS,
-    /** A supersedes/replaces B (new version → old version). */
-    SUPERSEDES,
-    /** A precedes B in time (event A → event B). */
-    PRECEDES,
-    /** A follows B in time (event B → event A). */
-    FOLLOWS,
-
-    // ── Location ──
-    /** A is located at B (entity → location). */
-    LOCATED_AT,
-
-    // ── General ──
-    /** A is related to B (generic association). */
-    RELATED_TO,
-    /** Fallback for unrecognized relation types. */
-    OTHER
-}
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/habituation/HabituationPenalty.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/habituation/HabituationPenalty.java
deleted file mode 100644
index 33805cf..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/habituation/HabituationPenalty.java
+++ /dev/null
@@ -1,219 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.habituation;
-
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.atomic.AtomicInteger;
-
-/**
- * Session-level result diversity penalty to prevent recall fixation.
- *
- * <h3>Biological Analog: Sensory Habituation</h3>
- * <p>Repeated exposure to the same stimulus decreases neural response. You stop
- * hearing the clock ticking after a few minutes. The brain deprioritizes repetitive
- * input to make room for novel information.</p>
- *
- * <h3>Anti-Filter-Bubble Mechanism</h3>
- * <p>Tracks how many times each memory has been returned in the current session.
- * Applies a diminishing multiplier to frequently-returned memories, forcing the
- * agent to consider alternative information.</p>
- *
- * <pre>
- *   1st return → 1.0x (no penalty)
- *   5th return → 0.5x
- *   10th return → 0.33x
- *   20th return → 0.2x
- * </pre>
- *
- * <h3>Thread Safety</h3>
- * <p>Fully concurrent via {@link ConcurrentHashMap} + {@link AtomicInteger}.</p>
- */
-public final class HabituationPenalty {
-
-    /** Habituation decay rate. Higher = faster habituation. */
-    private final float decayRate;
-
-    /** Per-memory return counts for this session. */
-    private final ConcurrentHashMap<String, AtomicInteger> returnCounts = new ConcurrentHashMap<>();
-
-    // ── Inhibition of Return (TTL-based refractory period) ──
-
-    /** Per-memory last-recall timestamps for IOR penalty. */
-    private final ConcurrentHashMap<String, Long> lastRecallTimestamps = new ConcurrentHashMap<>();
-
-    /** Inhibition of Return TTL in milliseconds (default: 5 minutes). */
-    private final long inhibitionTtlMs;
-
-    /** Minimum multiplier during IOR (default: 0.1 = 90% suppression). */
-    private final float inhibitionFloor;
-
-    /**
-     * Creates a habituation penalty calculator.
-     *
-     * @param decayRate habituation strength (default: 0.2, higher = faster habituation)
-     * @param inhibitionTtlMs IOR refractory period in millis (default: 300_000 = 5 minutes)
-     * @param inhibitionFloor minimum IOR multiplier (default: 0.1)
-     */
-    public HabituationPenalty(float decayRate, long inhibitionTtlMs, float inhibitionFloor) {
-        this.decayRate = decayRate;
-        this.inhibitionTtlMs = inhibitionTtlMs;
-        this.inhibitionFloor = inhibitionFloor;
-    }
-
-    /**
-     * Creates a habituation penalty calculator with default IOR settings.
-     *
-     * @param decayRate habituation strength (default: 0.2, higher = faster habituation)
-     */
-    public HabituationPenalty(float decayRate) {
-        this(decayRate, 300_000L, 0.1f);
-    }
-
-    /**
-     * Creates a habituation penalty with all defaults (decayRate=0.2, TTL=5min, floor=0.1).
-     */
-    public HabituationPenalty() {
-        this(0.2f, 300_000L, 0.1f);
-    }
-
-    /**
-     * Records that a memory was returned in a recall result and computes the
-     * habituation multiplier.
-     *
-     * @param memoryId the memory that was returned
-     * @return habituation multiplier (1.0 = first time, decreasing for repeats)
-     */
-    public float recordAndComputePenalty(String memoryId) {
-        int timesReturned = returnCounts
-                .computeIfAbsent(memoryId, k -> new AtomicInteger(0))
-                .incrementAndGet();
-        return computePenalty(timesReturned);
-    }
-
-    /**
-     * Computes the habituation penalty without recording a return.
-     *
-     * @param memoryId the memory to check
-     * @return current habituation multiplier
-     */
-    public float currentPenalty(String memoryId) {
-        AtomicInteger count = returnCounts.get(memoryId);
-        if (count == null) return 1.0f;
-        return computePenalty(count.get());
-    }
-
-    /**
-     * Computes the penalty for a given return count.
-     * Formula: 1.0 / (1.0 + timesReturned * decayRate)
-     */
-    private float computePenalty(int timesReturned) {
-        return 1.0f / (1.0f + (timesReturned - 1) * decayRate);
-    }
-
-    /**
-     * Returns the number of unique memories tracked.
-     */
-    public int trackedCount() {
-        return returnCounts.size();
-    }
-
-    /**
-     * Clears all habituation data and IOR timestamps (typically at session end).
-     */
-    public void clear() {
-        returnCounts.clear();
-        lastRecallTimestamps.clear();
-    }
-
-    // ══════════════════════════════════════════════════════════════
-    // INHIBITION OF RETURN — TTL-based refractory period
-    // ══════════════════════════════════════════════════════════════
-
-    /**
-     * Records a recall timestamp for Inhibition of Return tracking.
-     *
-     * <p>Call this after a memory is returned in a recall result. The timestamp
-     * is used to compute the IOR penalty on subsequent recalls.</p>
-     *
-     * @param memoryId the recalled memory's ID
-     * @param nowMs    current time in epoch millis
-     */
-    public void recordRecall(String memoryId, long nowMs) {
-        lastRecallTimestamps.put(memoryId, nowMs);
-    }
-
-    /**
-     * Computes the Inhibition of Return penalty for a memory.
-     *
-     * <h3>Biological Analog: Refractory Period</h3>
-     * <p>After a neuron fires, it enters a refractory period where it cannot
-     * fire again at full strength. This prevents the brain from getting stuck
-     * in activation loops. The penalty recovers linearly from {@code inhibitionFloor}
-     * to {@code 1.0} over the TTL duration.</p>
-     *
-     * <pre>
-     *   Just recalled → 0.1x (strong suppression)
-     *   2.5 min later → 0.55x (recovering)
-     *   5+ min later  → 1.0x (fully recovered)
-     * </pre>
-     *
-     * @param memoryId the memory to check
-     * @param nowMs    current time in epoch millis
-     * @return multiplier in [{@code inhibitionFloor}, 1.0]
-     */
-    public float computeInhibitionOfReturn(String memoryId, long nowMs) {
-        Long lastRecall = lastRecallTimestamps.get(memoryId);
-        if (lastRecall == null) return 1.0f;
-
-        long ageMs = nowMs - lastRecall;
-        if (ageMs >= inhibitionTtlMs) {
-            lastRecallTimestamps.remove(memoryId); // cleanup expired
-            return 1.0f;
-        }
-
-        // Linear recovery: inhibitionFloor → 1.0 over TTL
-        return inhibitionFloor + (1.0f - inhibitionFloor) * ((float) ageMs / inhibitionTtlMs);
-    }
-
-    /**
-     * Returns the IOR TTL in milliseconds.
-     */
-    public long inhibitionTtlMs() {
-        return inhibitionTtlMs;
-    }
-
-    /**
-     * Returns the number of memories with active IOR timestamps.
-     */
-    public int iorTrackedCount() {
-        return lastRecallTimestamps.size();
-    }
-
-    /**
-     * Batch penalty computation — records all IDs and returns their penalties.
-     *
-     * <p>Minimizes ConcurrentHashMap contention by processing all results
-     * in a tight loop. Particularly effective when called from a single
-     * recall thread (no cross-thread CHM contention).</p>
-     *
-     * @param memoryIds array of memory IDs to record
-     * @return array of habituation multipliers (1.0 = first time, decreasing for repeats)
-     */
-    public float[] recordAndComputeBatch(String[] memoryIds) {
-        float[] penalties = new float[memoryIds.length];
-        for (int i = 0; i < memoryIds.length; i++) {
-            penalties[i] = recordAndComputePenalty(memoryIds[i]);
-        }
-        return penalties;
-    }
-}
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/hebbian/CoActivationTracker.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/hebbian/CoActivationTracker.java
deleted file mode 100644
index 1f2ab34..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/hebbian/CoActivationTracker.java
+++ /dev/null
@@ -1,567 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.hebbian;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.io.IOException;
-
-import com.spectrayan.spector.memory.error.SpectorGraphPersistenceException;
-import java.lang.foreign.Arena;
-import java.nio.ByteBuffer;
-import java.nio.channels.FileChannel;
-import java.nio.charset.StandardCharsets;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.nio.file.StandardOpenOption;
-import java.util.List;
-import java.util.Map;
-import java.util.concurrent.ConcurrentHashMap;
-
-/**
- * Off-heap synaptic tag co-occurrence and STDP tracking for Hebbian learning.
- *
- * <h3>Biological Analog: Hebbian Learning + STDP</h3>
- * <p>"Cells that fire together wire together" (Hebb, 1949). When two neurons
- * fire simultaneously, the synapse between them strengthens. Over time,
- * activating one neuron automatically activates the other — this is the
- * basis of associative memory.</p>
- *
- * <h3>Spike-Timing-Dependent Plasticity (STDP)</h3>
- * <p>STDP extends basic Hebbian learning with <em>temporal direction</em>.
- * If neuron A fires <b>before</b> neuron B (causal), the A→B synapse is
- * <b>strengthened</b> (Long-Term Potentiation). If A fires <b>after</b> B
- * (anti-causal), the B→A synapse is <b>weakened</b> (Long-Term Depression).
- * This produces directed, predictive associations — "tag A predicts tag B."</p>
- *
- * <h3>Architecture</h3>
- * <p>This class coordinates two independent off-heap hash tables:</p>
- * <ul>
- *   <li>{@link OffHeapPairTable} — undirected co-activation pairs (32B/slot)</li>
- *   <li>{@link OffHeapEdgeTable} — directed STDP edges (40B/slot)</li>
- * </ul>
- * <p>Each table has its own {@code ReentrantLock}, so pair writes never
- * block edge writes and vice versa.</p>
- *
- * @see OffHeapPairTable
- * @see OffHeapEdgeTable
- * @see HebbianCoActivationListener
- */
-public final class CoActivationTracker implements AutoCloseable {
-
-    private static final Logger log = LoggerFactory.getLogger(CoActivationTracker.class);
-
-    // ── STDP Constants ──
-
-    /** A+ (LTP amplitude): maximum weight increase for causal pairings. */
-    private static final float A_PLUS = 0.1f;
-
-    /** A- (LTD amplitude): maximum weight decrease for anti-causal pairings. */
-    private static final float A_MINUS = 0.05f;
-
-    /** τ+ (LTP time constant): causal window in milliseconds. */
-    private static final float TAU_PLUS = 30_000f;  // 30 seconds
-
-    /** τ- (LTD time constant): anti-causal window in milliseconds. */
-    private static final float TAU_MINUS = 30_000f;  // 30 seconds
-
-    /** Minimum weight (prevent complete erasure). */
-    static final float MIN_WEIGHT = 0.0f;
-
-    /** Maximum weight (prevent runaway potentiation). */
-    static final float MAX_WEIGHT = 1.0f;
-
-    // ── Persistence ──
-
-    /** File magic: "COAX" in ASCII. */
-    private static final int FILE_MAGIC = 0x434F4158;
-    private static final int FILE_VERSION = 1;
-    /** Header: magic(4) + version(4) + pairCap(4) + edgeCap(4) + pairCount(4) + edgeCount(4) = 24B. */
-    private static final int FILE_HEADER_BYTES = 24;
-
-    // ── State ──
-
-    private final Arena arena;
-    private final OffHeapPairTable pairTable;
-    private final OffHeapEdgeTable edgeTable;
-
-    /** On-heap name↔hash resolution (small — only unique tag strings). */
-    private final ConcurrentHashMap<Long, String> hashToTag = new ConcurrentHashMap<>();
-
-    // ── Records ──
-
-    /**
-     * A directed edge between two synaptic tags.
-     */
-    public record DirectedEdge(String sourceTag, String targetTag) {
-        @Override
-        public String toString() {
-            return sourceTag + "→" + targetTag;
-        }
-    }
-
-    /**
-     * STDP edge weight with temporal metadata.
-     *
-     * @param weight           current STDP weight (0.0 to 1.0)
-     * @param lastActivatedMs  epoch millis of last activation
-     * @param activationCount  total number of sequential activations
-     */
-    public record EdgeWeight(float weight, long lastActivatedMs, int activationCount) {
-        /** Returns a new EdgeWeight with updated weight and timestamp. */
-        public EdgeWeight withUpdate(float deltaWeight, long nowMs) {
-            float newWeight = Math.clamp(weight + deltaWeight, MIN_WEIGHT, MAX_WEIGHT);
-            return new EdgeWeight(newWeight, nowMs, activationCount + 1);
-        }
-    }
-
-    // ══════════════════════════════════════════════════════════════
-    // Constructors
-    // ══════════════════════════════════════════════════════════════
-
-    /**
-     * Creates a co-activation tracker with default capacities (10_000 pairs, 20_000 edges).
-     */
-    public CoActivationTracker() {
-        this(10_000);
-    }
-
-    /**
-     * Creates a co-activation tracker.
-     *
-     * @param maxPairs maximum tracked undirected pairs
-     */
-    public CoActivationTracker(int maxPairs) {
-        this(maxPairs, maxPairs * 2);
-    }
-
-    /**
-     * Creates a co-activation tracker with custom limits.
-     *
-     * @param maxPairs maximum tracked undirected pairs
-     * @param maxEdges maximum tracked STDP directed edges
-     */
-    public CoActivationTracker(int maxPairs, int maxEdges) {
-        int pairCap = nextPowerOf2(Math.max(64, maxPairs * 2));
-        int edgeCap = nextPowerOf2(Math.max(64, maxEdges * 2));
-        this.arena = Arena.ofShared();
-        this.pairTable = new OffHeapPairTable(pairCap, arena);
-        this.edgeTable = new OffHeapEdgeTable(edgeCap, arena);
-
-        log.info("CoActivationTracker initialized (off-heap): pairSlots={}, edgeSlots={}, memory={}KB",
-                pairCap, edgeCap,
-                ((long) OffHeapPairTable.SLOT_BYTES * pairCap
-                        + (long) OffHeapEdgeTable.SLOT_BYTES * edgeCap) / 1024);
-    }
-
-    /** Private constructor for loading from pre-existing tables. */
-    private CoActivationTracker(Arena arena, OffHeapPairTable pairTable, OffHeapEdgeTable edgeTable,
-                                 ConcurrentHashMap<Long, String> hashToTag) {
-        this.arena = arena;
-        this.pairTable = pairTable;
-        this.edgeTable = edgeTable;
-        this.hashToTag.putAll(hashToTag);
-    }
-
-    // ══════════════════════════════════════════════════════════════
-    // Undirected Co-Activation (Original Hebbian)
-    // ══════════════════════════════════════════════════════════════
-
-    /**
-     * Records co-activation of tags that appeared together in a recall result set.
-     *
-     * @param tags array of tag strings that appeared together in recall results
-     */
-    public void recordCoActivation(String... tags) {
-        if (tags == null || tags.length < 2) return;
-
-        for (int i = 0; i < tags.length; i++) {
-            for (int j = i + 1; j < tags.length; j++) {
-                long hashA = hashTag(tags[i]);
-                long hashB = hashTag(tags[j]);
-                registerTag(tags[i], hashA);
-                registerTag(tags[j], hashB);
-
-                // Ensure canonical order: smaller hash first
-                long keyA = Math.min(hashA, hashB);
-                long keyB = Math.max(hashA, hashB);
-
-                pairTable.increment(keyA, keyB);
-            }
-        }
-    }
-
-    /**
-     * Returns the co-activation count for a tag pair.
-     *
-     * @param tagA first tag
-     * @param tagB second tag
-     * @return co-activation count (0 if never co-activated)
-     */
-    public int getCoActivation(String tagA, String tagB) {
-        long hashA = hashTag(tagA);
-        long hashB = hashTag(tagB);
-        long keyA = Math.min(hashA, hashB);
-        long keyB = Math.max(hashA, hashB);
-        return pairTable.get(keyA, keyB);
-    }
-
-    /**
-     * Returns the top-N most co-activated tags for a given tag.
-     *
-     * @param tag   the source tag
-     * @param topN  maximum number of associated tags to return
-     * @return list of associated tag names sorted by co-activation strength
-     */
-    public List<String> getAssociatedTags(String tag, int topN) {
-        long tagHash = hashTag(tag);
-
-        record TagCount(String name, int count) {}
-
-        return pairTable.findAssociations(tagHash).stream()
-                .map(arr -> {
-                    String name = hashToTag.get(arr[0]);
-                    return name != null ? new TagCount(name, (int) arr[1]) : null;
-                })
-                .filter(tc -> tc != null)
-                .sorted((a, b) -> Integer.compare(b.count(), a.count()))
-                .limit(topN)
-                .map(TagCount::name)
-                .toList();
-    }
-
-    // ══════════════════════════════════════════════════════════════
-    // STDP — Spike-Timing-Dependent Plasticity
-    // ══════════════════════════════════════════════════════════════
-
-    /**
-     * Records a sequential activation pair for STDP weight update.
-     *
-     * @param tagBefore  the tag that was activated first
-     * @param tagAfter   the tag that was activated second
-     * @param timeBefore epoch millis when tagBefore was activated
-     * @param timeAfter  epoch millis when tagAfter was activated
-     */
-    public void recordSequentialActivation(String tagBefore, String tagAfter,
-                                            long timeBefore, long timeAfter) {
-        if (tagBefore.equals(tagAfter)) return;
-        if (timeAfter < timeBefore) return;
-
-        long dt = timeAfter - timeBefore;
-        long hashBefore = hashTag(tagBefore);
-        long hashAfter = hashTag(tagAfter);
-        registerTag(tagBefore, hashBefore);
-        registerTag(tagAfter, hashAfter);
-
-        // Causal: A→B (strengthen)
-        float dW_causal = A_PLUS * (float) Math.exp(-dt / TAU_PLUS);
-        edgeTable.update(hashBefore, hashAfter, dW_causal, timeAfter);
-
-        // Anti-causal: B→A (weaken)
-        float dW_anti = -A_MINUS * (float) Math.exp(-dt / TAU_MINUS);
-        edgeTable.update(hashAfter, hashBefore, dW_anti, timeAfter);
-
-        log.trace("STDP: {}→{} Δt={}ms, causal ΔW={}, anti-causal ΔW={}",
-                tagBefore, tagAfter, dt,
-                String.format("%.4f", dW_causal), String.format("%.4f", dW_anti));
-    }
-
-    /**
-     * Records sequential activations from an ordered list of tags with timestamps.
-     *
-     * @param orderedTags tags in temporal order (first = earliest)
-     * @param timestamps  corresponding epoch millis for each tag
-     */
-    public void recordSequentialActivations(List<String> orderedTags, List<Long> timestamps) {
-        if (orderedTags.size() < 2) return;
-        if (orderedTags.size() != timestamps.size()) return;
-
-        for (int i = 0; i < orderedTags.size() - 1; i++) {
-            recordSequentialActivation(
-                    orderedTags.get(i), orderedTags.get(i + 1),
-                    timestamps.get(i), timestamps.get(i + 1));
-        }
-    }
-
-    /**
-     * Returns the STDP predictive strength from query tags to a result's tags.
-     *
-     * @param queryTags  tags from the query context
-     * @param resultTags tags from a candidate result
-     * @return maximum predictive strength (0.0 if no causal link exists)
-     */
-    public float getPredictiveStrength(List<String> queryTags, String[] resultTags) {
-        if (queryTags == null || queryTags.isEmpty() || resultTags == null || resultTags.length == 0) {
-            return 0.0f;
-        }
-
-        float maxStrength = 0.0f;
-        for (String qTag : queryTags) {
-            long srcHash = hashTag(qTag);
-            for (String rTag : resultTags) {
-                long tgtHash = hashTag(rTag);
-                float weight = edgeTable.getWeight(srcHash, tgtHash);
-                if (weight > maxStrength) maxStrength = weight;
-            }
-        }
-        return maxStrength;
-    }
-
-    /**
-     * Returns the average predictive strength (mean of all matching edges).
-     *
-     * @param queryTags  tags from the query context
-     * @param resultTags tags from a candidate result
-     * @return average predictive strength across all matching edges
-     */
-    public float getAveragePredictiveStrength(List<String> queryTags, String[] resultTags) {
-        if (queryTags == null || queryTags.isEmpty() || resultTags == null || resultTags.length == 0) {
-            return 0.0f;
-        }
-
-        float sum = 0.0f;
-        int matchCount = 0;
-        for (String qTag : queryTags) {
-            long srcHash = hashTag(qTag);
-            for (String rTag : resultTags) {
-                long tgtHash = hashTag(rTag);
-                float weight = edgeTable.getWeight(srcHash, tgtHash);
-                if (weight > 0) {
-                    sum += weight;
-                    matchCount++;
-                }
-            }
-        }
-        return matchCount > 0 ? sum / matchCount : 0.0f;
-    }
-
-    /**
-     * Returns the STDP edge weight for a specific directed edge.
-     *
-     * @param sourceTag the source tag
-     * @param targetTag the target tag
-     * @return the edge weight, or null if no edge exists
-     */
-    public EdgeWeight getEdge(String sourceTag, String targetTag) {
-        long srcHash = hashTag(sourceTag);
-        long tgtHash = hashTag(targetTag);
-        return edgeTable.getEdge(srcHash, tgtHash);
-    }
-
-    // ══════════════════════════════════════════════════════════════
-    // Counts / Reset / Close
-    // ══════════════════════════════════════════════════════════════
-
-    /** Returns the number of STDP directed edges. */
-    public int edgeCount() { return edgeTable.count(); }
-
-    /** Returns the number of tracked undirected tag pairs. */
-    public int pairCount() { return pairTable.count(); }
-
-    /** Resets all co-activation and STDP data. */
-    public void reset() {
-        pairTable.reset();
-        edgeTable.reset();
-        hashToTag.clear();
-    }
-
-    @Override
-    public void close() {
-        log.info("CoActivationTracker closing (pairs={}, edges={})", pairCount(), edgeCount());
-        arena.close();
-    }
-
-    // ══════════════════════════════════════════════════════════════
-    // Tag Hashing
-    // ══════════════════════════════════════════════════════════════
-
-    /**
-     * FNV-1a 64-bit hash of a tag string.
-     */
-    static long hashTag(String tag) {
-        long hash = 0xcbf29ce484222325L;
-        for (int i = 0; i < tag.length(); i++) {
-            hash ^= tag.charAt(i);
-            hash *= 0x100000001b3L;
-        }
-        return hash == 0 ? 1 : hash; // avoid 0 which means empty slot
-    }
-
-    private void registerTag(String tag, long hash) {
-        hashToTag.putIfAbsent(hash, tag);
-    }
-
-    // ══════════════════════════════════════════════════════════════
-    // PERSISTENCE: save / load
-    // ══════════════════════════════════════════════════════════════
-
-    /**
-     * Saves the tracker state to a binary file.
-     *
-     * @param filePath path to write
-     */
-    public void save(Path filePath) {
-        Path parent = filePath.getParent();
-        if (parent != null) {
-            try {
-                Files.createDirectories(parent);
-            } catch (IOException e) {
-                throw new SpectorGraphPersistenceException("CoActivationTracker", parent, e);
-            }
-        }
-
-        try (FileChannel ch = FileChannel.open(filePath,
-                StandardOpenOption.CREATE, StandardOpenOption.WRITE,
-                StandardOpenOption.TRUNCATE_EXISTING)) {
-
-            // Header
-            ByteBuffer header = ByteBuffer.allocate(FILE_HEADER_BYTES);
-            header.putInt(FILE_MAGIC);
-            header.putInt(FILE_VERSION);
-            header.putInt(pairTable.capacity());
-            header.putInt(edgeTable.capacity());
-            header.putInt(pairTable.count());
-            header.putInt(edgeTable.count());
-            header.flip();
-            ch.write(header);
-
-            // Delegate segment I/O to tables
-            pairTable.writeTo(ch);
-            edgeTable.writeTo(ch);
-
-            // Tag name index
-            writeTagIndex(ch);
-
-            ch.force(true);
-            log.info("CoActivationTracker saved: pairs={}, edges={}, tags={} → {}",
-                    pairCount(), edgeCount(), hashToTag.size(), filePath);
-
-        } catch (IOException e) {
-            throw new SpectorGraphPersistenceException("CoActivationTracker", filePath, e);
-        }
-    }
-
-    /**
-     * Loads a tracker from a binary file, or returns a new empty tracker.
-     *
-     * @param filePath       path to the tracker file
-     * @param defaultPairs   default pair capacity if file doesn't exist
-     * @param defaultEdges   default edge capacity if file doesn't exist
-     * @return a CoActivationTracker (loaded or new)
-     */
-    public static CoActivationTracker load(Path filePath, int defaultPairs, int defaultEdges) {
-        if (filePath == null || !Files.exists(filePath)) {
-            log.info("CoActivationTracker file not found, creating fresh: {}", filePath);
-            return new CoActivationTracker(defaultPairs, defaultEdges);
-        }
-
-        try (FileChannel ch = FileChannel.open(filePath, StandardOpenOption.READ)) {
-            if (ch.size() < FILE_HEADER_BYTES) {
-                log.warn("CoActivationTracker file too small, creating fresh");
-                return new CoActivationTracker(defaultPairs, defaultEdges);
-            }
-
-            ByteBuffer header = ByteBuffer.allocate(FILE_HEADER_BYTES);
-            ch.read(header);
-            header.flip();
-
-            int magic = header.getInt();
-            int version = header.getInt();
-            int pairCap = header.getInt();
-            int edgeCap = header.getInt();
-            int pairs = header.getInt();
-            int edges = header.getInt();
-
-            if (magic != FILE_MAGIC || version != FILE_VERSION) {
-                log.warn("Invalid CoActivationTracker file, creating fresh");
-                return new CoActivationTracker(defaultPairs, defaultEdges);
-            }
-
-            Arena arena = Arena.ofShared();
-
-            // Delegate segment I/O to tables
-            OffHeapPairTable pairTable = OffHeapPairTable.readFrom(ch, pairCap, pairs, arena);
-            OffHeapEdgeTable edgeTable = OffHeapEdgeTable.readFrom(ch, edgeCap, edges, arena);
-
-            // Tag name index
-            ConcurrentHashMap<Long, String> names = readTagIndex(ch);
-
-            CoActivationTracker tracker = new CoActivationTracker(arena, pairTable, edgeTable, names);
-            log.info("CoActivationTracker loaded: pairs={}, edges={}, tags={} from {}",
-                    pairs, edges, names.size(), filePath);
-            return tracker;
-
-        } catch (IOException e) {
-            log.error("Failed to load CoActivationTracker, creating fresh: {}", e.getMessage());
-            return new CoActivationTracker(defaultPairs, defaultEdges);
-        }
-    }
-
-    // ── Tag Index I/O ──
-
-    private void writeTagIndex(FileChannel ch) throws IOException {
-        ByteBuffer countBuf = ByteBuffer.allocate(4);
-        countBuf.putInt(hashToTag.size());
-        countBuf.flip();
-        ch.write(countBuf);
-
-        for (Map.Entry<Long, String> entry : hashToTag.entrySet()) {
-            byte[] nameBytes = entry.getValue().getBytes(StandardCharsets.UTF_8);
-            ByteBuffer entryBuf = ByteBuffer.allocate(8 + 4 + nameBytes.length);
-            entryBuf.putLong(entry.getKey());
-            entryBuf.putInt(nameBytes.length);
-            entryBuf.put(nameBytes);
-            entryBuf.flip();
-            ch.write(entryBuf);
-        }
-    }
-
-    private static ConcurrentHashMap<Long, String> readTagIndex(FileChannel ch) throws IOException {
-        ConcurrentHashMap<Long, String> names = new ConcurrentHashMap<>();
-
-        ByteBuffer countBuf = ByteBuffer.allocate(4);
-        ch.read(countBuf);
-        countBuf.flip();
-        int nameCount = countBuf.getInt();
-
-        for (int i = 0; i < nameCount; i++) {
-            ByteBuffer hashBuf = ByteBuffer.allocate(8);
-            ch.read(hashBuf);
-            hashBuf.flip();
-            long hash = hashBuf.getLong();
-
-            ByteBuffer lenBuf = ByteBuffer.allocate(4);
-            ch.read(lenBuf);
-            lenBuf.flip();
-            int len = lenBuf.getInt();
-
-            ByteBuffer nameBuf = ByteBuffer.allocate(len);
-            ch.read(nameBuf);
-            nameBuf.flip();
-            String name = new String(nameBuf.array(), 0, len, StandardCharsets.UTF_8);
-
-            names.put(hash, name);
-        }
-
-        return names;
-    }
-
-    // ── Utility ──
-
-    private static int nextPowerOf2(int n) {
-        int p = 1;
-        while (p < n) p <<= 1;
-        return p;
-    }
-}
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/hebbian/HebbianGraph.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/hebbian/HebbianGraph.java
deleted file mode 100644
index 0f10ce1..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/hebbian/HebbianGraph.java
+++ /dev/null
@@ -1,463 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.hebbian;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.io.IOException;
-
-import com.spectrayan.spector.memory.error.SpectorGraphPersistenceException;
-import java.lang.foreign.Arena;
-import java.lang.foreign.MemorySegment;
-import java.lang.foreign.ValueLayout;
-import java.nio.ByteBuffer;
-import java.nio.channels.FileChannel;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.nio.file.StandardOpenOption;
-import java.util.ArrayList;
-import java.util.List;
-
-/**
- * Off-heap adjacency list for full Hebbian graph associations (V2).
- *
- * <h3>Biological Analog: Cortical Network Wiring</h3>
- * <p>In the cortex, neurons form complex networks where activating one node
- * (memory) spreads activation to connected nodes. This graph stores explicit
- * memory-to-memory edges with association weights.</p>
- *
- * <h3>Design</h3>
- * <ul>
- *   <li>Off-heap adjacency list backed by {@link MemorySegment}</li>
- *   <li>Bounded degree: max 20 neighbors per memory (prevents graph explosion)</li>
- *   <li>Edge weight = co-recall count (strengthened each time both are recalled together)</li>
- *   <li>Enables spreading activation: "if you recalled A, also consider B and C"</li>
- *   <li>Persistence: save/load via raw segment serialization to file</li>
- * </ul>
- */
-public final class HebbianGraph implements AutoCloseable {
-
-    private static final Logger log = LoggerFactory.getLogger(HebbianGraph.class);
-
-    /** File magic: "HGPH" in ASCII. */
-    private static final int FILE_MAGIC = 0x48475048;
-
-    /** File format version. */
-    private static final int FILE_VERSION = 1;
-
-    /** File header: 4B magic + 4B version + 4B capacity + 4B reserved = 16 bytes. */
-    private static final int FILE_HEADER_BYTES = 16;
-
-    /** Maximum number of Hebbian neighbors per memory. */
-    public static final int MAX_DEGREE = 20;
-
-    /** Bytes per edge: 4B (neighbor index) + 4B (weight as float). */
-    private static final int EDGE_BYTES = 8;
-
-    /** Bytes per node: 4B (degree) + MAX_DEGREE * EDGE_BYTES. */
-    static final int NODE_BYTES = 4 + MAX_DEGREE * EDGE_BYTES;
-
-    private final Arena arena;
-    private final MemorySegment segment;
-    private final int capacity;
-
-    /**
-     * Creates a Hebbian graph.
-     *
-     * @param capacity maximum number of nodes (memories)
-     */
-    public HebbianGraph(int capacity) {
-        this.capacity = capacity;
-        this.arena = Arena.ofShared();
-        this.segment = arena.allocate((long) NODE_BYTES * capacity);
-        // Zero-initialize (all degrees start at 0)
-        segment.fill((byte) 0);
-
-        log.info("HebbianGraph initialized: capacity={}, memory={}KB",
-                capacity, (long) NODE_BYTES * capacity / 1024);
-    }
-
-    /**
-     * Private constructor for loading from a pre-existing segment (deserialization).
-     */
-    private HebbianGraph(int capacity, Arena arena, MemorySegment segment) {
-        this.capacity = capacity;
-        this.arena = arena;
-        this.segment = segment;
-    }
-
-    /**
-     * Returns the capacity (maximum number of nodes).
-     */
-    public int capacity() {
-        return capacity;
-    }
-
-    /**
-     * Adds or strengthens a bidirectional Hebbian edge between two memories.
-     *
-     * @param nodeA index of first memory
-     * @param nodeB index of second memory
-     * @param weightDelta weight to add to the edge (default: 1.0)
-     */
-    public synchronized void strengthen(int nodeA, int nodeB, float weightDelta) {
-        if (nodeA < 0 || nodeA >= capacity || nodeB < 0 || nodeB >= capacity) return;
-        if (nodeA == nodeB) return;
-        addOrUpdateEdge(nodeA, nodeB, weightDelta);
-        addOrUpdateEdge(nodeB, nodeA, weightDelta);
-    }
-
-    /**
-     * Returns the Hebbian neighbors of a memory, sorted by descending weight.
-     *
-     * @param node memory index
-     * @return list of (neighborIndex, weight) pairs
-     */
-    public List<HebbianEdge> neighbors(int node) {
-        if (node < 0 || node >= capacity) return List.of();
-        long nodeOffset = (long) node * NODE_BYTES;
-        int degree = segment.get(ValueLayout.JAVA_INT, nodeOffset);
-
-        List<HebbianEdge> edges = new ArrayList<>(degree);
-        for (int i = 0; i < degree; i++) {
-            long edgeOffset = nodeOffset + 4 + (long) i * EDGE_BYTES;
-            int neighbor = segment.get(ValueLayout.JAVA_INT, edgeOffset);
-            float weight = segment.get(ValueLayout.JAVA_FLOAT, edgeOffset + 4);
-            edges.add(new HebbianEdge(neighbor, weight));
-        }
-
-        edges.sort((a, b) -> Float.compare(b.weight(), a.weight()));
-        return edges;
-    }
-
-    /**
-     * Returns the degree (number of Hebbian edges) for a node.
-     */
-    public int degree(int node) {
-        if (node < 0 || node >= capacity) return 0;
-        return segment.get(ValueLayout.JAVA_INT, (long) node * NODE_BYTES);
-    }
-
-    /**
-     * Returns the total number of edges across all nodes.
-     */
-    public int totalEdges() {
-        int total = 0;
-        for (int i = 0; i < capacity; i++) {
-            total += degree(i);
-        }
-        return total;
-    }
-
-    private void addOrUpdateEdge(int from, int to, float weightDelta) {
-        long nodeOffset = (long) from * NODE_BYTES;
-        int degree = segment.get(ValueLayout.JAVA_INT, nodeOffset);
-
-        // Check if edge already exists
-        for (int i = 0; i < degree; i++) {
-            long edgeOffset = nodeOffset + 4 + (long) i * EDGE_BYTES;
-            int neighbor = segment.get(ValueLayout.JAVA_INT, edgeOffset);
-            if (neighbor == to) {
-                // Strengthen existing edge
-                float weight = segment.get(ValueLayout.JAVA_FLOAT, edgeOffset + 4);
-                segment.set(ValueLayout.JAVA_FLOAT, edgeOffset + 4, weight + weightDelta);
-                return;
-            }
-        }
-
-        // Add new edge (if room)
-        if (degree < MAX_DEGREE) {
-            long edgeOffset = nodeOffset + 4 + (long) degree * EDGE_BYTES;
-            segment.set(ValueLayout.JAVA_INT, edgeOffset, to);
-            segment.set(ValueLayout.JAVA_FLOAT, edgeOffset + 4, weightDelta);
-            segment.set(ValueLayout.JAVA_INT, nodeOffset, degree + 1);
-        } else {
-            // Replace weakest edge if new weight exceeds it
-            replaceWeakest(nodeOffset, degree, to, weightDelta);
-        }
-    }
-
-    private void replaceWeakest(long nodeOffset, int degree, int newNeighbor, float newWeight) {
-        float minWeight = Float.MAX_VALUE;
-        int minIndex = -1;
-
-        for (int i = 0; i < degree; i++) {
-            long edgeOffset = nodeOffset + 4 + (long) i * EDGE_BYTES;
-            float weight = segment.get(ValueLayout.JAVA_FLOAT, edgeOffset + 4);
-            if (weight < minWeight) {
-                minWeight = weight;
-                minIndex = i;
-            }
-        }
-
-        if (newWeight > minWeight && minIndex >= 0) {
-            long edgeOffset = nodeOffset + 4 + (long) minIndex * EDGE_BYTES;
-            segment.set(ValueLayout.JAVA_INT, edgeOffset, newNeighbor);
-            segment.set(ValueLayout.JAVA_FLOAT, edgeOffset + 4, newWeight);
-        }
-    }
-
-    /**
-     * Immutable Hebbian edge record.
-     *
-     * @param neighborIndex index of the connected memory
-     * @param weight        association strength
-     */
-    public record HebbianEdge(int neighborIndex, float weight) {}
-
-    // ── V3: Edge Decay + Session Boundaries + Spreading Activation ──
-
-    private long lastActivityMs = System.currentTimeMillis();
-    private long sessionBoundaryMs = 5 * 60 * 1000L; // 5 minutes default
-
-    /**
-     * Configures the session boundary inactivity threshold.
-     *
-     * @param durationMs milliseconds of inactivity that defines a session break
-     */
-    public void setSessionBoundary(long durationMs) {
-        this.sessionBoundaryMs = durationMs;
-    }
-
-    /**
-     * Checks if a new session has started (inactivity exceeded boundary).
-     *
-     * @return true if a new session has started since the last activity
-     */
-    public boolean isNewSession() {
-        long now = System.currentTimeMillis();
-        boolean isNew = (now - lastActivityMs) > sessionBoundaryMs;
-        lastActivityMs = now;
-        return isNew;
-    }
-
-    /**
-     * Decays all edge weights by a factor (V3: called during ReflectDaemon cycles).
-     *
-     * <p>Unused associations weaken over time — edges that are never re-strengthened
-     * eventually drop to zero and get replaced by new associations.</p>
-     *
-     * @param decayFactor multiplier (e.g., 0.9 = 10% decay per cycle)
-     * @return number of edges that dropped below threshold and were removed
-     */
-    public synchronized int decayEdges(float decayFactor) {
-        int removed = 0;
-        float removalThreshold = 0.01f; // edges below this are effectively dead
-
-        for (int node = 0; node < capacity; node++) {
-            long nodeOffset = (long) node * NODE_BYTES;
-            int degree = segment.get(ValueLayout.JAVA_INT, nodeOffset);
-            int newDegree = 0;
-
-            for (int i = 0; i < degree; i++) {
-                long edgeOffset = nodeOffset + 4 + (long) i * EDGE_BYTES;
-                float weight = segment.get(ValueLayout.JAVA_FLOAT, edgeOffset + 4);
-                float decayed = weight * decayFactor;
-
-                if (decayed >= removalThreshold) {
-                    // Keep edge — compact if needed
-                    if (newDegree != i) {
-                        long newOffset = nodeOffset + 4 + (long) newDegree * EDGE_BYTES;
-                        int neighbor = segment.get(ValueLayout.JAVA_INT, edgeOffset);
-                        segment.set(ValueLayout.JAVA_INT, newOffset, neighbor);
-                        segment.set(ValueLayout.JAVA_FLOAT, newOffset + 4, decayed);
-                    } else {
-                        segment.set(ValueLayout.JAVA_FLOAT, edgeOffset + 4, decayed);
-                    }
-                    newDegree++;
-                } else {
-                    removed++;
-                }
-            }
-
-            segment.set(ValueLayout.JAVA_INT, nodeOffset, newDegree);
-        }
-
-        if (removed > 0) {
-            log.debug("Hebbian edge decay: {} edges removed (factor={})", removed, decayFactor);
-        }
-        return removed;
-    }
-
-    /**
-     * Returns the Hebbian neighbors of a memory at a given depth (spreading activation).
-     *
-     * <p>Depth 1 = direct neighbors. Depth 2 = neighbors of neighbors.
-     * Activation strength decreases with each hop.</p>
-     *
-     * @param node  starting memory index
-     * @param depth activation depth (1-3 recommended)
-     * @return list of activated edges with compound weights
-     */
-    public List<HebbianEdge> activateNeighbors(int node, int depth) {
-        if (node < 0 || node >= capacity) return List.of();
-        List<HebbianEdge> activated = new ArrayList<>();
-        activateRecursive(node, depth, 1.0f, activated, new java.util.HashSet<>());
-        activated.sort((a, b) -> Float.compare(b.weight(), a.weight()));
-        return activated;
-    }
-
-    private void activateRecursive(int node, int depth, float attenuation,
-                                    List<HebbianEdge> activated, java.util.Set<Integer> visited) {
-        if (depth <= 0 || visited.contains(node)) return;
-        visited.add(node);
-
-        for (HebbianEdge edge : neighbors(node)) {
-            float compoundWeight = edge.weight() * attenuation;
-            if (compoundWeight > 0.01f && !visited.contains(edge.neighborIndex())) {
-                activated.add(new HebbianEdge(edge.neighborIndex(), compoundWeight));
-                activateRecursive(edge.neighborIndex(), depth - 1, compoundWeight * 0.5f,
-                        activated, visited);
-            }
-        }
-    }
-
-    // ══════════════════════════════════════════════════════════════
-    // PERSISTENCE: save / load
-    // ══════════════════════════════════════════════════════════════
-
-    /**
-     * Saves the graph to a binary file.
-     *
-     * <h3>File Format</h3>
-     * <pre>
-     *   [4B magic: "HGPH"]  [4B version: 1]  [4B capacity]  [4B reserved]
-     *   [raw segment bytes: capacity × NODE_BYTES]
-     * </pre>
-     *
-     * @param filePath path to write the graph file
-     */
-    public void save(Path filePath) {
-        Path parent = filePath.getParent();
-        if (parent != null) {
-            try {
-                Files.createDirectories(parent);
-            } catch (IOException e) {
-                throw new SpectorGraphPersistenceException("HebbianGraph", parent, e);
-            }
-        }
-
-        try (FileChannel ch = FileChannel.open(filePath,
-                StandardOpenOption.CREATE, StandardOpenOption.WRITE,
-                StandardOpenOption.TRUNCATE_EXISTING)) {
-
-            // Write file header
-            ByteBuffer header = ByteBuffer.allocate(FILE_HEADER_BYTES);
-            header.putInt(FILE_MAGIC);
-            header.putInt(FILE_VERSION);
-            header.putInt(capacity);
-            header.putInt(0); // reserved
-            header.flip();
-            ch.write(header);
-
-            // Write raw segment bytes in chunks
-            long totalBytes = (long) NODE_BYTES * capacity;
-            long written = 0;
-            int chunkSize = 64 * 1024; // 64KB chunks
-            while (written < totalBytes) {
-                int toWrite = (int) Math.min(chunkSize, totalBytes - written);
-                ByteBuffer buf = segment.asSlice(written, toWrite)
-                        .asByteBuffer().asReadOnlyBuffer();
-                ch.write(buf);
-                written += toWrite;
-            }
-
-            ch.force(true);
-            log.info("HebbianGraph saved: capacity={}, edges={} → {}",
-                    capacity, totalEdges(), filePath);
-
-        } catch (IOException e) {
-            throw new SpectorGraphPersistenceException("HebbianGraph", filePath, e);
-        }
-    }
-
-    /**
-     * Loads a graph from a binary file, or returns a new empty graph
-     * if the file doesn't exist.
-     *
-     * @param filePath path to the graph file
-     * @param defaultCapacity capacity to use if file doesn't exist
-     * @return a HebbianGraph (loaded or new)
-     */
-    public static HebbianGraph load(Path filePath, int defaultCapacity) {
-        if (filePath == null || !Files.exists(filePath)) {
-            log.info("HebbianGraph file not found, creating fresh: {}", filePath);
-            return new HebbianGraph(defaultCapacity);
-        }
-
-        try (FileChannel ch = FileChannel.open(filePath, StandardOpenOption.READ)) {
-            long fileSize = ch.size();
-            if (fileSize < FILE_HEADER_BYTES) {
-                log.warn("HebbianGraph file too small ({}B), creating fresh", fileSize);
-                return new HebbianGraph(defaultCapacity);
-            }
-
-            // Read file header
-            ByteBuffer header = ByteBuffer.allocate(FILE_HEADER_BYTES);
-            ch.read(header);
-            header.flip();
-
-            int magic = header.getInt();
-            int version = header.getInt();
-            int capacity = header.getInt();
-            header.getInt(); // reserved
-
-            if (magic != FILE_MAGIC) {
-                log.warn("Invalid HebbianGraph magic: 0x{}, creating fresh",
-                        Integer.toHexString(magic));
-                return new HebbianGraph(defaultCapacity);
-            }
-            if (version != FILE_VERSION) {
-                log.warn("Unsupported HebbianGraph version: {}, creating fresh", version);
-                return new HebbianGraph(defaultCapacity);
-            }
-
-            long expectedBytes = (long) NODE_BYTES * capacity;
-            if (fileSize < FILE_HEADER_BYTES + expectedBytes) {
-                log.warn("HebbianGraph file truncated, creating fresh");
-                return new HebbianGraph(defaultCapacity);
-            }
-
-            // Read segment data
-            Arena arena = Arena.ofShared();
-            MemorySegment seg = arena.allocate(expectedBytes);
-            long read = 0;
-            int chunkSize = 64 * 1024;
-            while (read < expectedBytes) {
-                int toRead = (int) Math.min(chunkSize, expectedBytes - read);
-                ByteBuffer buf = ByteBuffer.allocate(toRead);
-                ch.read(buf);
-                buf.flip();
-                MemorySegment.copy(MemorySegment.ofBuffer(buf), 0, seg, read, toRead);
-                read += toRead;
-            }
-
-            HebbianGraph graph = new HebbianGraph(capacity, arena, seg);
-            log.info("HebbianGraph loaded: capacity={}, edges={} from {}",
-                    capacity, graph.totalEdges(), filePath);
-            return graph;
-
-        } catch (IOException e) {
-            log.error("Failed to load HebbianGraph from {}, creating fresh: {}",
-                    filePath, e.getMessage());
-            return new HebbianGraph(defaultCapacity);
-        }
-    }
-
-    @Override
-    public void close() {
-        log.info("HebbianGraph closing (capacity={})", capacity);
-        arena.close();
-    }
-}
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/hebbian/OffHeapEdgeTable.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/hebbian/OffHeapEdgeTable.java
deleted file mode 100644
index da88330..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/hebbian/OffHeapEdgeTable.java
+++ /dev/null
@@ -1,281 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.hebbian;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.lang.foreign.Arena;
-import java.lang.foreign.MemorySegment;
-import java.lang.foreign.ValueLayout;
-import java.nio.ByteBuffer;
-import java.nio.channels.FileChannel;
-import java.io.IOException;
-import java.util.Arrays;
-import java.util.concurrent.locks.ReentrantLock;
-
-/**
- * Off-heap open-addressing hash table for <b>directed</b> STDP edges.
- *
- * <h3>Biological Analog: Spike-Timing-Dependent Plasticity</h3>
- * <p>If neuron A fires <b>before</b> neuron B (causal), the A→B synapse is
- * strengthened (LTP). If A fires <b>after</b> B (anti-causal), the B→A
- * synapse is weakened (LTD). This produces predictive associations.</p>
- *
- * <h3>Slot Layout (40 bytes, 8-byte aligned)</h3>
- * <pre>
- *   [srcHash:8B][tgtHash:8B][weight:4B][pad:4B][lastActivatedMs:8B][activationCount:4B][flags:4B]
- * </pre>
- *
- * <h3>Thread Safety</h3>
- * <p>Writes are guarded by a {@link ReentrantLock}. Reads are lock-free.</p>
- *
- * @see CoActivationTracker
- */
-final class OffHeapEdgeTable {
-
-    private static final Logger log = LoggerFactory.getLogger(OffHeapEdgeTable.class);
-
-    // ── Slot layout ──
-    static final int SLOT_BYTES = 40;
-    static final long OFF_SRC = 0;
-    static final long OFF_TGT = 8;
-    static final long OFF_WEIGHT = 16;
-    // pad: 4B at offset 20 for alignment
-    static final long OFF_LAST_MS = 24;
-    static final long OFF_ACT_COUNT = 32;
-    static final long OFF_FLAGS = 36;
-
-    /** Flag: slot is occupied. */
-    static final int FLAG_OCCUPIED = 1;
-
-    /** Minimum weight (prevent complete erasure). */
-    static final float MIN_WEIGHT = 0.0f;
-
-    /** Maximum weight (prevent runaway potentiation). */
-    static final float MAX_WEIGHT = 1.0f;
-
-    private final MemorySegment segment;
-    private final int capacity;
-    private final ReentrantLock writeLock = new ReentrantLock();
-    private volatile int count;
-
-    // ── Construction ──
-
-    /**
-     * Creates a new empty edge table.
-     *
-     * @param capacity number of hash table slots (must be power of 2)
-     * @param arena    arena to allocate from
-     */
-    OffHeapEdgeTable(int capacity, Arena arena) {
-        this.capacity = capacity;
-        this.segment = arena.allocate((long) SLOT_BYTES * capacity);
-        this.segment.fill((byte) 0);
-        this.count = 0;
-    }
-
-    /**
-     * Wraps a pre-loaded segment (used during deserialization).
-     */
-    OffHeapEdgeTable(int capacity, MemorySegment segment, int count) {
-        this.capacity = capacity;
-        this.segment = segment;
-        this.count = count;
-    }
-
-    // ── Writes (locked) ──
-
-    /**
-     * Updates or inserts a directed STDP edge.
-     *
-     * @param srcHash     FNV-1a hash of the source tag
-     * @param tgtHash     FNV-1a hash of the target tag
-     * @param deltaWeight weight change (positive = LTP, negative = LTD)
-     * @param nowMs       current epoch millis
-     */
-    void update(long srcHash, long tgtHash, float deltaWeight, long nowMs) {
-        writeLock.lock();
-        try {
-            int slot = findSlot(srcHash, tgtHash);
-
-            if (slot >= 0) {
-                // Exists — update
-                long offset = (long) slot * SLOT_BYTES;
-                float weight = segment.get(ValueLayout.JAVA_FLOAT, offset + OFF_WEIGHT);
-                float newWeight = Math.clamp(weight + deltaWeight, MIN_WEIGHT, MAX_WEIGHT);
-                int actCount = segment.get(ValueLayout.JAVA_INT, offset + OFF_ACT_COUNT);
-
-                segment.set(ValueLayout.JAVA_FLOAT, offset + OFF_WEIGHT, newWeight);
-                segment.set(ValueLayout.JAVA_LONG, offset + OFF_LAST_MS, nowMs);
-                segment.set(ValueLayout.JAVA_INT, offset + OFF_ACT_COUNT, actCount + 1);
-            } else {
-                // Insert
-                int insertSlot = ~slot;
-                if (insertSlot < 0 || count >= capacity / 2) {
-                    pruneWeakest();
-                    slot = findSlot(srcHash, tgtHash);
-                    insertSlot = slot >= 0 ? slot : ~slot;
-                    if (insertSlot < 0) return;
-                }
-
-                long offset = (long) insertSlot * SLOT_BYTES;
-                float initialWeight = Math.max(MIN_WEIGHT, deltaWeight);
-                segment.set(ValueLayout.JAVA_LONG, offset + OFF_SRC, srcHash);
-                segment.set(ValueLayout.JAVA_LONG, offset + OFF_TGT, tgtHash);
-                segment.set(ValueLayout.JAVA_FLOAT, offset + OFF_WEIGHT, initialWeight);
-                segment.set(ValueLayout.JAVA_LONG, offset + OFF_LAST_MS, nowMs);
-                segment.set(ValueLayout.JAVA_INT, offset + OFF_ACT_COUNT, 1);
-                segment.set(ValueLayout.JAVA_INT, offset + OFF_FLAGS, FLAG_OCCUPIED);
-                count++;
-            }
-        } finally {
-            writeLock.unlock();
-        }
-    }
-
-    /**
-     * Resets all edge data. Caller must hold no other locks.
-     */
-    void reset() {
-        writeLock.lock();
-        try {
-            segment.fill((byte) 0);
-            count = 0;
-        } finally {
-            writeLock.unlock();
-        }
-    }
-
-    // ── Reads (lock-free) ──
-
-    /**
-     * Returns the STDP weight for a specific directed edge, or -1 if absent.
-     */
-    float getWeight(long srcHash, long tgtHash) {
-        int slot = findSlot(srcHash, tgtHash);
-        if (slot < 0) return -1f;
-        long offset = (long) slot * SLOT_BYTES;
-        return segment.get(ValueLayout.JAVA_FLOAT, offset + OFF_WEIGHT);
-    }
-
-    /**
-     * Returns full edge metadata, or null if absent.
-     */
-    CoActivationTracker.EdgeWeight getEdge(long srcHash, long tgtHash) {
-        int slot = findSlot(srcHash, tgtHash);
-        if (slot < 0) return null;
-        long offset = (long) slot * SLOT_BYTES;
-        float weight = segment.get(ValueLayout.JAVA_FLOAT, offset + OFF_WEIGHT);
-        long lastMs = segment.get(ValueLayout.JAVA_LONG, offset + OFF_LAST_MS);
-        int actCount = segment.get(ValueLayout.JAVA_INT, offset + OFF_ACT_COUNT);
-        return new CoActivationTracker.EdgeWeight(weight, lastMs, actCount);
-    }
-
-    int count() { return count; }
-    int capacity() { return capacity; }
-    MemorySegment segment() { return segment; }
-
-    // ── Hash Table Internals ──
-
-    /**
-     * Finds an edge slot by source and target hashes.
-     *
-     * @return slot index if found, or ~insertionPoint if not found
-     */
-    private int findSlot(long srcHash, long tgtHash) {
-        int mask = capacity - 1;
-        int idx = (int) ((srcHash * 0x517CC1B727220A95L + tgtHash) & mask);
-
-        for (int probe = 0; probe < capacity; probe++) {
-            int slot = (idx + probe) & mask;
-            long offset = (long) slot * SLOT_BYTES;
-            int flags = segment.get(ValueLayout.JAVA_INT, offset + OFF_FLAGS);
-
-            if ((flags & FLAG_OCCUPIED) == 0) return ~slot;
-            long s = segment.get(ValueLayout.JAVA_LONG, offset + OFF_SRC);
-            long t = segment.get(ValueLayout.JAVA_LONG, offset + OFF_TGT);
-            if (s == srcHash && t == tgtHash) return slot;
-        }
-        return -1;
-    }
-
-    /**
-     * Prunes the weakest 10% of edges by weight. Must be called under writeLock.
-     */
-    private void pruneWeakest() {
-        if (count == 0) return;
-        int toPrune = Math.max(1, count / 10);
-
-        float[] weights = new float[count];
-        int idx = 0;
-        for (int i = 0; i < capacity && idx < count; i++) {
-            long offset = (long) i * SLOT_BYTES;
-            int flags = segment.get(ValueLayout.JAVA_INT, offset + OFF_FLAGS);
-            if ((flags & FLAG_OCCUPIED) != 0) {
-                weights[idx++] = segment.get(ValueLayout.JAVA_FLOAT, offset + OFF_WEIGHT);
-            }
-        }
-        Arrays.sort(weights, 0, idx);
-        float threshold = idx > toPrune ? weights[toPrune] : weights[0];
-
-        int removed = 0;
-        for (int i = 0; i < capacity && removed < toPrune; i++) {
-            long offset = (long) i * SLOT_BYTES;
-            int flags = segment.get(ValueLayout.JAVA_INT, offset + OFF_FLAGS);
-            if ((flags & FLAG_OCCUPIED) != 0) {
-                float weight = segment.get(ValueLayout.JAVA_FLOAT, offset + OFF_WEIGHT);
-                if (weight <= threshold) {
-                    for (int b = 0; b < SLOT_BYTES; b += 4) {
-                        segment.set(ValueLayout.JAVA_INT, offset + b, 0);
-                    }
-                    removed++;
-                    count--;
-                }
-            }
-        }
-
-        log.debug("Pruned {} weak STDP edges (remaining={})", removed, count);
-    }
-
-    // ── Persistence helpers ──
-
-    void writeTo(FileChannel ch) throws IOException {
-        long totalBytes = (long) SLOT_BYTES * capacity;
-        long written = 0;
-        int chunkSize = 64 * 1024;
-        while (written < totalBytes) {
-            int toWrite = (int) Math.min(chunkSize, totalBytes - written);
-            ByteBuffer buf = segment.asSlice(written, toWrite).asByteBuffer().asReadOnlyBuffer();
-            ch.write(buf);
-            written += toWrite;
-        }
-    }
-
-    static OffHeapEdgeTable readFrom(FileChannel ch, int capacity, int count, Arena arena)
-            throws IOException {
-        long totalBytes = (long) SLOT_BYTES * capacity;
-        MemorySegment seg = arena.allocate(totalBytes);
-        long read = 0;
-        int chunkSize = 64 * 1024;
-        while (read < totalBytes) {
-            int toRead = (int) Math.min(chunkSize, totalBytes - read);
-            ByteBuffer buf = ByteBuffer.allocate(toRead);
-            ch.read(buf);
-            buf.flip();
-            MemorySegment.copy(MemorySegment.ofBuffer(buf), 0, seg, read, toRead);
-            read += toRead;
-        }
-        return new OffHeapEdgeTable(capacity, seg, count);
-    }
-}
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/hebbian/OffHeapPairTable.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/hebbian/OffHeapPairTable.java
deleted file mode 100644
index d53fac4..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/hebbian/OffHeapPairTable.java
+++ /dev/null
@@ -1,272 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.hebbian;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.lang.foreign.Arena;
-import java.lang.foreign.MemorySegment;
-import java.lang.foreign.ValueLayout;
-import java.nio.ByteBuffer;
-import java.nio.channels.FileChannel;
-import java.io.IOException;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.locks.ReentrantLock;
-
-/**
- * Off-heap open-addressing hash table for <b>undirected</b> co-activation pairs.
- *
- * <h3>Biological Analog</h3>
- * <p>"Cells that fire together wire together" (Hebb, 1949). Each entry
- * records how many times two synaptic tags were recalled together.</p>
- *
- * <h3>Slot Layout (32 bytes, 8-byte aligned)</h3>
- * <pre>
- *   [hashA:8B][hashB:8B][count:4B][flags:4B][pad:8B]
- * </pre>
- *
- * <h3>Thread Safety</h3>
- * <p>Writes are guarded by a {@link ReentrantLock}. Reads are lock-free
- * (may see slightly stale data — acceptable for soft-scoring signals).</p>
- *
- * @see CoActivationTracker
- */
-final class OffHeapPairTable {
-
-    private static final Logger log = LoggerFactory.getLogger(OffHeapPairTable.class);
-
-    // ── Slot layout ──
-    static final int SLOT_BYTES = 32;
-    static final long OFF_HASH_A = 0;
-    static final long OFF_HASH_B = 8;
-    static final long OFF_COUNT = 16;
-    static final long OFF_FLAGS = 20;
-
-    /** Flag: slot is occupied. */
-    static final int FLAG_OCCUPIED = 1;
-
-    private final MemorySegment segment;
-    private final int capacity;
-    private final ReentrantLock writeLock = new ReentrantLock();
-    private volatile int count;
-
-    // ── Construction ──
-
-    /**
-     * Creates a new empty pair table.
-     *
-     * @param capacity number of hash table slots (must be power of 2)
-     * @param arena    arena to allocate from
-     */
-    OffHeapPairTable(int capacity, Arena arena) {
-        this.capacity = capacity;
-        this.segment = arena.allocate((long) SLOT_BYTES * capacity);
-        this.segment.fill((byte) 0);
-        this.count = 0;
-    }
-
-    /**
-     * Wraps a pre-loaded segment (used during deserialization).
-     */
-    OffHeapPairTable(int capacity, MemorySegment segment, int count) {
-        this.capacity = capacity;
-        this.segment = segment;
-        this.count = count;
-    }
-
-    // ── Writes (locked) ──
-
-    /**
-     * Records a co-activation for the given canonical hash pair.
-     * The caller must ensure hashA &lt;= hashB for canonical ordering.
-     */
-    void increment(long hashA, long hashB) {
-        writeLock.lock();
-        try {
-            int slot = findSlot(hashA, hashB);
-
-            if (slot >= 0) {
-                long offset = (long) slot * SLOT_BYTES;
-                int c = segment.get(ValueLayout.JAVA_INT, offset + OFF_COUNT);
-                segment.set(ValueLayout.JAVA_INT, offset + OFF_COUNT, c + 1);
-            } else {
-                int insertSlot = ~slot;
-                if (insertSlot < 0 || count >= capacity / 2) {
-                    pruneWeakest();
-                    slot = findSlot(hashA, hashB);
-                    insertSlot = slot >= 0 ? slot : ~slot;
-                    if (insertSlot < 0) return;
-                }
-
-                long offset = (long) insertSlot * SLOT_BYTES;
-                segment.set(ValueLayout.JAVA_LONG, offset + OFF_HASH_A, hashA);
-                segment.set(ValueLayout.JAVA_LONG, offset + OFF_HASH_B, hashB);
-                segment.set(ValueLayout.JAVA_INT, offset + OFF_COUNT, 1);
-                segment.set(ValueLayout.JAVA_INT, offset + OFF_FLAGS, FLAG_OCCUPIED);
-                count++;
-            }
-        } finally {
-            writeLock.unlock();
-        }
-    }
-
-    /**
-     * Resets all pair data. Caller must hold no other locks.
-     */
-    void reset() {
-        writeLock.lock();
-        try {
-            segment.fill((byte) 0);
-            count = 0;
-        } finally {
-            writeLock.unlock();
-        }
-    }
-
-    // ── Reads (lock-free) ──
-
-    /**
-     * Returns the co-activation count for a canonical hash pair, or 0 if absent.
-     */
-    int get(long hashA, long hashB) {
-        int slot = findSlot(hashA, hashB);
-        if (slot < 0) return 0;
-        long offset = (long) slot * SLOT_BYTES;
-        return segment.get(ValueLayout.JAVA_INT, offset + OFF_COUNT);
-    }
-
-    /**
-     * Scans all occupied slots for pairs containing {@code tagHash} and
-     * returns associated (otherHash, count) pairs.
-     */
-    List<long[]> findAssociations(long tagHash) {
-        List<long[]> results = new ArrayList<>();
-        for (int i = 0; i < capacity; i++) {
-            long offset = (long) i * SLOT_BYTES;
-            int flags = segment.get(ValueLayout.JAVA_INT, offset + OFF_FLAGS);
-            if ((flags & FLAG_OCCUPIED) == 0) continue;
-
-            long hA = segment.get(ValueLayout.JAVA_LONG, offset + OFF_HASH_A);
-            long hB = segment.get(ValueLayout.JAVA_LONG, offset + OFF_HASH_B);
-
-            if (hA == tagHash || hB == tagHash) {
-                long otherHash = (hA == tagHash) ? hB : hA;
-                int c = segment.get(ValueLayout.JAVA_INT, offset + OFF_COUNT);
-                results.add(new long[]{otherHash, c});
-            }
-        }
-        return results;
-    }
-
-    int count() { return count; }
-    int capacity() { return capacity; }
-    MemorySegment segment() { return segment; }
-
-    // ── Hash Table Internals ──
-
-    /**
-     * Finds a pair slot by hash keys.
-     *
-     * @return slot index if found, or ~insertionPoint if not found
-     */
-    private int findSlot(long hashA, long hashB) {
-        int mask = capacity - 1;
-        int idx = (int) ((hashA * 0x9E3779B97F4A7C15L + hashB) & mask);
-
-        for (int probe = 0; probe < capacity; probe++) {
-            int slot = (idx + probe) & mask;
-            long offset = (long) slot * SLOT_BYTES;
-            int flags = segment.get(ValueLayout.JAVA_INT, offset + OFF_FLAGS);
-
-            if ((flags & FLAG_OCCUPIED) == 0) return ~slot;
-            long a = segment.get(ValueLayout.JAVA_LONG, offset + OFF_HASH_A);
-            long b = segment.get(ValueLayout.JAVA_LONG, offset + OFF_HASH_B);
-            if (a == hashA && b == hashB) return slot;
-        }
-        return -1;
-    }
-
-    /**
-     * Prunes the weakest 10% of pairs by count. Must be called under writeLock.
-     */
-    private void pruneWeakest() {
-        if (count == 0) return;
-        int toPrune = Math.max(1, count / 10);
-
-        int[] counts = new int[count];
-        int idx = 0;
-        for (int i = 0; i < capacity && idx < count; i++) {
-            long offset = (long) i * SLOT_BYTES;
-            int flags = segment.get(ValueLayout.JAVA_INT, offset + OFF_FLAGS);
-            if ((flags & FLAG_OCCUPIED) != 0) {
-                counts[idx++] = segment.get(ValueLayout.JAVA_INT, offset + OFF_COUNT);
-            }
-        }
-        Arrays.sort(counts, 0, idx);
-        int threshold = idx > toPrune ? counts[toPrune] : counts[0];
-
-        int removed = 0;
-        for (int i = 0; i < capacity && removed < toPrune; i++) {
-            long offset = (long) i * SLOT_BYTES;
-            int flags = segment.get(ValueLayout.JAVA_INT, offset + OFF_FLAGS);
-            if ((flags & FLAG_OCCUPIED) != 0) {
-                int c = segment.get(ValueLayout.JAVA_INT, offset + OFF_COUNT);
-                if (c <= threshold) {
-                    segment.set(ValueLayout.JAVA_INT, offset + OFF_FLAGS, 0);
-                    segment.set(ValueLayout.JAVA_LONG, offset + OFF_HASH_A, 0L);
-                    segment.set(ValueLayout.JAVA_LONG, offset + OFF_HASH_B, 0L);
-                    segment.set(ValueLayout.JAVA_INT, offset + OFF_COUNT, 0);
-                    removed++;
-                    count--;
-                }
-            }
-        }
-
-        log.debug("Pruned {} weak co-activation pairs (remaining={})", removed, count);
-    }
-
-    // ── Persistence helpers ──
-
-    void writeTo(FileChannel ch) throws IOException {
-        long totalBytes = (long) SLOT_BYTES * capacity;
-        long written = 0;
-        int chunkSize = 64 * 1024;
-        while (written < totalBytes) {
-            int toWrite = (int) Math.min(chunkSize, totalBytes - written);
-            ByteBuffer buf = segment.asSlice(written, toWrite).asByteBuffer().asReadOnlyBuffer();
-            ch.write(buf);
-            written += toWrite;
-        }
-    }
-
-    static OffHeapPairTable readFrom(FileChannel ch, int capacity, int count, Arena arena)
-            throws IOException {
-        long totalBytes = (long) SLOT_BYTES * capacity;
-        MemorySegment seg = arena.allocate(totalBytes);
-        long read = 0;
-        int chunkSize = 64 * 1024;
-        while (read < totalBytes) {
-            int toRead = (int) Math.min(chunkSize, totalBytes - read);
-            ByteBuffer buf = ByteBuffer.allocate(toRead);
-            ch.read(buf);
-            buf.flip();
-            MemorySegment.copy(MemorySegment.ofBuffer(buf), 0, seg, read, toRead);
-            read += toRead;
-        }
-        return new OffHeapPairTable(capacity, seg, count);
-    }
-}
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/hippocampus/CircadianPolicy.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/hippocampus/CircadianPolicy.java
deleted file mode 100644
index 53e755e..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/hippocampus/CircadianPolicy.java
+++ /dev/null
@@ -1,118 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.hippocampus;
-
-import java.time.Duration;
-
-/**
- * Configuration for the {@link ReflectDaemon}'s sleep cycle triggers.
- *
- * <h3>Biological Analog: Circadian Rhythm</h3>
- * <p>The brain consolidates memories during sleep, triggered by both volume
- * (amount of new information) and time (circadian clock). This policy mirrors
- * that dual-trigger approach.</p>
- *
- * <h3>Three-Mode Trigger</h3>
- * <ul>
- *   <li><b>Volume:</b> Triggers after N new episodic memories (burst workloads)</li>
- *   <li><b>Time:</b> At most once per interval (steady-state operation)</li>
- *   <li><b>Manual:</b> {@code memory.reflect()} called explicitly (developer control)</li>
- * </ul>
- */
-public record CircadianPolicy(
-        int volumeTrigger,
-        Duration timeTrigger,
-        float tombstoneThreshold,
-        float decayPruneThreshold,
-        float interferenceThreshold,
-        float interferenceDecayFactor
-) {
-
-    /** Default policy: reflect after 100 memories or 1 hour, prune below 0.05 decay. */
-    public static final CircadianPolicy DEFAULT = new CircadianPolicy(
-            100,
-            Duration.ofHours(1),
-            0.30f,
-            0.05f,
-            0.12f,
-            0.7f
-    );
-
-    /**
-     * Creates a builder for custom configuration.
-     */
-    public static Builder builder() {
-        return new Builder();
-    }
-
-    /**
-     * Builder for {@link CircadianPolicy}.
-     */
-    public static final class Builder {
-        private int volumeTrigger = 100;
-        private Duration timeTrigger = Duration.ofHours(1);
-        private float tombstoneThreshold = 0.30f;
-        private float decayPruneThreshold = 0.05f;
-        private float interferenceThreshold = 0.12f;
-        private float interferenceDecayFactor = 0.7f;
-
-        /**
-         * Number of new episodic memories that triggers a reflection cycle.
-         */
-        public Builder volumeTrigger(int volumeTrigger) {
-            this.volumeTrigger = volumeTrigger;
-            return this;
-        }
-
-        /**
-         * Maximum time between reflection cycles.
-         */
-        public Builder timeTrigger(Duration timeTrigger) {
-            this.timeTrigger = timeTrigger;
-            return this;
-        }
-
-        /**
-         * Tombstone ratio that triggers partition rebuild (default: 0.30 = 30%).
-         */
-        public Builder tombstoneThreshold(float tombstoneThreshold) {
-            this.tombstoneThreshold = tombstoneThreshold;
-            return this;
-        }
-
-        /**
-         * Decay score below which memories are tombstoned during Deep Sleep.
-         */
-        public Builder decayPruneThreshold(float decayPruneThreshold) {
-            this.decayPruneThreshold = decayPruneThreshold;
-            return this;
-        }
-
-        /**
-         * L2 distance threshold for near-duplicate interference detection (default: 0.12).
-         * Records within this distance compete during sleep — the older one decays.
-         */
-        public Builder interferenceThreshold(float t) { this.interferenceThreshold = t; return this; }
-
-        /**
-         * Importance decay factor for the older near-duplicate (default: 0.7 = 30% reduction).
-         */
-        public Builder interferenceDecayFactor(float f) { this.interferenceDecayFactor = f; return this; }
-
-        public CircadianPolicy build() {
-            return new CircadianPolicy(volumeTrigger, timeTrigger,
-                    tombstoneThreshold, decayPruneThreshold,
-                    interferenceThreshold, interferenceDecayFactor);
-        }
-    }
-}
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/hippocampus/ReflectDaemon.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/hippocampus/ReflectDaemon.java
deleted file mode 100644
index d483134..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/hippocampus/ReflectDaemon.java
+++ /dev/null
@@ -1,687 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.hippocampus;
-
-import com.spectrayan.spector.commons.concurrent.ConcurrentTasks;
-import com.spectrayan.spector.commons.concurrent.ConcurrentExecutionException;
-import com.spectrayan.spector.memory.MemoryType;
-import com.spectrayan.spector.memory.ReflectReport;
-import com.spectrayan.spector.memory.cortex.CentroidRouter;
-import com.spectrayan.spector.memory.cortex.EpisodicMemoryStore;
-import com.spectrayan.spector.memory.cortex.EpisodicMemoryStore.EpisodicPartition;
-import com.spectrayan.spector.memory.cortex.SemanticMemoryStore;
-import com.spectrayan.spector.memory.synapse.CognitiveRecordLayout;
-import com.spectrayan.spector.memory.synapse.CognitiveRecordLayout.CognitiveHeader;
-import com.spectrayan.spector.memory.synapse.SynapticHeaderConstants;
-import com.spectrayan.spector.embed.EmbeddingProvider;
-import com.spectrayan.spector.embed.TextGenerationProvider;
-import com.spectrayan.spector.embed.GenerationOptions;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.time.Duration;
-import java.time.Instant;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.concurrent.Callable;
-import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.function.Function;
-import java.util.stream.Collectors;
-
-/**
- * Background Virtual Thread that runs the two-phase sleep consolidation cycle.
- *
- * <h3>Biological Analog: Hippocampal Replay During Sleep</h3>
- * <p>During sleep, the hippocampus replays episodic memories to the neocortex
- * for consolidation. Dense clusters of related episodes are compressed into
- * permanent semantic facts. Weak, isolated memories are pruned.</p>
- *
- * <h3>Two-Phase Sleep Cycle — NREM + REM Mapping</h3>
- *
- * <table border="1">
- *   <tr><th>Spector Phase</th><th>Sleep Stage</th><th>Neuroscience Mechanism</th><th>Implementation</th></tr>
- *   <tr>
- *     <td><b>Deep Sleep</b></td>
- *     <td>NREM Stage 3-4 (Slow-Wave Sleep)</td>
- *     <td><b>Synaptic Homeostasis Hypothesis (SHY)</b> — Tononi &amp; Cirelli, 2003.
- *         During waking hours, synapses are strengthened by learning (LTP).
- *         During SWS, global synaptic downscaling occurs: weak synapses are
- *         pruned while strong ones are preserved. This prevents saturation
- *         and frees capacity for new learning.</td>
- *     <td>Scan episodic partitions, tombstone records where
- *         {@code decayed_importance &lt; threshold}. Trigger compaction
- *         when tombstone ratio exceeds 30%. This is the digital analog
- *         of synaptic downscaling.</td>
- *   </tr>
- *   <tr>
- *     <td><b>REM Sleep</b></td>
- *     <td>REM (Rapid Eye Movement)</td>
- *     <td><b>Memory Consolidation &amp; Schema Integration.</b> During REM,
- *         the hippocampus replays episodic traces while the neocortex
- *         integrates them into existing knowledge schemas. Related episodes
- *         are generalized into semantic facts (gist extraction). This is
- *         why "sleeping on it" helps problem-solving — REM finds patterns
- *         across disparate episodes.</td>
- *     <td>Cluster episodic memories by IVF centroid proximity. Dense
- *         clusters (≥5 episodes) are synthesized into semantic facts via
- *         LLM summarization or highest-importance promotion. Source
- *         episodes are tombstoned (unless {@code pinSourceEpisodes=true}
- *         for lossless consolidation).</td>
- *   </tr>
- * </table>
- *
- * <h3>Circadian Timing</h3>
- * <p>Real brains consolidate on a ~90-minute ultradian cycle during sleep.
- * The {@link CircadianPolicy} controls when the ReflectDaemon runs: either
- * on a fixed interval (e.g., every 30 minutes of wall-clock time) or
- * event-driven (when episodic partition fill reaches a threshold). This
- * mimics the sleep pressure accumulation mechanism (Process S).</p>
- *
- * <h3>V3: IVF Centroid Clustering + LLM Synthesis</h3>
- * <ul>
- *   <li>Groups non-consolidated episodic records by {@code centroid_id}</li>
- *   <li>Processes clusters ≥ {@code minClusterSize} (default: 5)</li>
- *   <li>Extracts common synaptic tags via bitmap AND</li>
- *   <li>When {@code TextGenerationProvider} is available:
- *       sends cluster texts to LLM for factual summarization</li>
- *   <li>When no LLM: falls back to highest-importance selection</li>
- * </ul>
- */
-public final class ReflectDaemon {
-
-    private static final Logger log = LoggerFactory.getLogger(ReflectDaemon.class);
-
-    /** Default minimum cluster size for REM consolidation. */
-    private static final int DEFAULT_MIN_CLUSTER_SIZE = 5;
-
-    private final CircadianPolicy policy;
-    private final TombstoneCompactor compactor;
-    private final AtomicBoolean running = new AtomicBoolean(false);
-
-    // ── Optional providers (null = graceful fallback to basic behavior) ──
-    private final CentroidRouter centroidRouter;
-    private final TextGenerationProvider textGenerator;
-    private final EmbeddingProvider embeddingProvider;
-    private final int minClusterSize;
-
-    // ── Neurodivergent: Lossless Consolidation ──
-    private final boolean pinSourceEpisodes;
-    private final int pinnedQuota;
-    private int pinnedCount = 0; // tracks pinned records across cycles
-
-    /**
-     * Creates a ReflectDaemon with full V3 capabilities.
-     *
-     * @param policy             circadian policy for trigger configuration
-     * @param centroidRouter     centroid router for IVF clustering (null = basic fallback)
-     * @param textGenerator      LLM for cluster synthesis (null = promote highest importance)
-     * @param embeddingProvider  embedding provider for synthesized text (null = skip embedding)
-     * @param minClusterSize     minimum cluster size for consolidation (default: 5)
-     */
-    public ReflectDaemon(CircadianPolicy policy, CentroidRouter centroidRouter,
-                          TextGenerationProvider textGenerator, EmbeddingProvider embeddingProvider,
-                          int minClusterSize, boolean pinSourceEpisodes, int pinnedQuota) {
-        this.policy = policy;
-        this.compactor = new TombstoneCompactor(policy.tombstoneThreshold());
-        this.centroidRouter = centroidRouter;
-        this.textGenerator = textGenerator;
-        this.embeddingProvider = embeddingProvider;
-        this.minClusterSize = minClusterSize;
-        this.pinSourceEpisodes = pinSourceEpisodes;
-        this.pinnedQuota = pinnedQuota;
-    }
-
-    /**
-     * Creates a ReflectDaemon with full V3 capabilities (no lossless consolidation).
-     */
-    public ReflectDaemon(CircadianPolicy policy, CentroidRouter centroidRouter,
-                          TextGenerationProvider textGenerator, EmbeddingProvider embeddingProvider,
-                          int minClusterSize) {
-        this(policy, centroidRouter, textGenerator, embeddingProvider,
-                minClusterSize, false, 10_000);
-    }
-
-    /**
-     * Creates a ReflectDaemon with optional V3 providers and default cluster size.
-     */
-    public ReflectDaemon(CircadianPolicy policy, CentroidRouter centroidRouter,
-                          TextGenerationProvider textGenerator, EmbeddingProvider embeddingProvider) {
-        this(policy, centroidRouter, textGenerator, embeddingProvider, DEFAULT_MIN_CLUSTER_SIZE);
-    }
-
-    /**
-     * Creates a ReflectDaemon with basic behavior (no clustering, no LLM).
-     */
-    public ReflectDaemon(CircadianPolicy policy) {
-        this(policy, null, null, null, DEFAULT_MIN_CLUSTER_SIZE);
-    }
-
-    /**
-     * Creates a ReflectDaemon with default policy.
-     */
-    public ReflectDaemon() {
-        this(CircadianPolicy.DEFAULT);
-    }
-
-    /**
-     * Runs a single synchronous reflection cycle.
-     *
-     * <p>Backward-compatible overload — delegates with null
-     * text lookup (falls back to basic behavior).</p>
-     *
-     * @param episodicStore the episodic memory store to scan
-     * @param semanticStore the semantic store to promote into (may be null for basic mode)
-     * @return report summarizing what was done
-     */
-    public ReflectReport runCycle(EpisodicMemoryStore episodicStore,
-                                   SemanticMemoryStore semanticStore) {
-        return runCycle(episodicStore, semanticStore, null);
-    }
-
-    /**
-     * Runs a single synchronous reflection cycle with text lookup for IVF clustering.
-     *
-     * @param episodicStore the episodic memory store to scan
-     * @param semanticStore the semantic store to promote into
-     * @param textLookup    function to look up text by memory offset (nullable)
-     * @return report summarizing what was done
-     */
-    public ReflectReport runCycle(EpisodicMemoryStore episodicStore,
-                                   SemanticMemoryStore semanticStore,
-                                   Function<Long, String> textLookup) {
-        if (!running.compareAndSet(false, true)) {
-            log.warn("Reflection cycle already in progress — skipping");
-            return ReflectReport.EMPTY;
-        }
-
-        Instant start = Instant.now();
-        int totalTombstoned = 0;
-        int totalCompacted = 0;
-        int totalConsolidated = 0;
-
-        try {
-            long nowMs = System.currentTimeMillis();
-
-            // ── Phase 1: Deep Sleep (Synaptic Pruning) — parallel partitions ──
-            log.info("Deep Sleep starting — scanning {} partitions",
-                    episodicStore.partitionCount());
-
-            List<EpisodicPartition> allPartitions = episodicStore.partitions();
-            
-            // Native POSIX Optimization: advise sequential access on all episodic segments before scan
-            for (EpisodicPartition partition : allPartitions) {
-                if (partition.segment() != null && partition.segment().isMapped()) {
-                    com.spectrayan.spector.commons.concurrent.NativeOsMemory.advise(partition.segment(), com.spectrayan.spector.commons.concurrent.NativeOsMemory.MADV_SEQUENTIAL);
-                }
-            }
-
-            try {
-                // Parallel prune: each partition scanned on its own Virtual Thread
-                List<Callable<Integer>> pruneTasks = new ArrayList<>(allPartitions.size());
-                for (EpisodicPartition partition : allPartitions) {
-                    pruneTasks.add(() -> compactor.pruneDecayed(partition,
-                            policy.decayPruneThreshold(), nowMs));
-                }
-                List<Integer> prunedCounts = ConcurrentTasks.forkJoinAll(pruneTasks);
-                for (int p : prunedCounts) totalTombstoned += p;
-            } catch (ConcurrentExecutionException | InterruptedException e) {
-                Thread.currentThread().interrupt();
-                log.warn("Parallel prune failed, falling back to sequential: {}", e.getMessage());
-                for (EpisodicPartition partition : allPartitions) {
-                    totalTombstoned += compactor.pruneDecayed(partition,
-                            policy.decayPruneThreshold(), nowMs);
-                }
-            }
-
-            // Compaction check (sequential — involves atomic partition swap)
-            for (EpisodicPartition partition : allPartitions) {
-                if (compactor.shouldCompact(partition)) {
-                    String key = episodicStore.keyForPartition(partition);
-                    log.info("Partition {} exceeds tombstone threshold ({:.0f}%) — compacting",
-                            partition.path(), partition.tombstoneRatio() * 100);
-
-                    if (key != null) {
-                        EpisodicPartition compacted = compactor.compact(
-                                partition, episodicStore.partitions().getFirst().path().getParent(), key);
-                        if (compacted != null) {
-                            episodicStore.replacePartition(key, partition, compacted);
-                            totalCompacted++;
-
-                            // Native POSIX Optimization: Immediately release old partition segment page cache
-                            if (partition.segment() != null && partition.segment().isMapped()) {
-                                com.spectrayan.spector.commons.concurrent.NativeOsMemory.advise(partition.segment(), com.spectrayan.spector.commons.concurrent.NativeOsMemory.MADV_DONTNEED);
-                            }
-                        }
-                    }
-                }
-            }
-
-            // ── Phase 2: REM Sleep (Dreaming/Synthesis) — parallel partitions ──
-            log.info("REM Sleep starting — looking for dense episodic clusters");
-
-            try {
-                List<Callable<Integer>> remTasks = new ArrayList<>(allPartitions.size());
-                for (EpisodicPartition partition : episodicStore.partitions()) {
-                    remTasks.add(() -> {
-                        if (centroidRouter != null) {
-                            return clusterAndSynthesize(partition, semanticStore, textLookup);
-                        } else {
-                            return promoteHighestImportance(partition, semanticStore);
-                        }
-                    });
-                }
-                List<Integer> consolidated = ConcurrentTasks.forkJoinAll(remTasks);
-                for (int c : consolidated) totalConsolidated += c;
-            } catch (ConcurrentExecutionException | InterruptedException e) {
-                Thread.currentThread().interrupt();
-                log.warn("Parallel REM failed, falling back to sequential: {}", e.getMessage());
-                for (EpisodicPartition partition : episodicStore.partitions()) {
-                    int promoted = centroidRouter != null
-                            ? clusterAndSynthesize(partition, semanticStore, textLookup)
-                            : promoteHighestImportance(partition, semanticStore);
-                    totalConsolidated += promoted;
-                }
-            }
-
-            Duration elapsed = Duration.between(start, Instant.now());
-            log.info("Reflection complete: consolidated={}, tombstoned={}, compacted={}, duration={}ms",
-                    totalConsolidated, totalTombstoned, totalCompacted, elapsed.toMillis());
-
-            // Native POSIX Optimization: Release page-cache for all episodic segments once sleep consolidation is fully complete
-            for (EpisodicPartition partition : allPartitions) {
-                if (partition.segment() != null && partition.segment().isMapped()) {
-                    com.spectrayan.spector.commons.concurrent.NativeOsMemory.advise(partition.segment(), com.spectrayan.spector.commons.concurrent.NativeOsMemory.MADV_DONTNEED);
-                }
-            }
-
-            return new ReflectReport(totalConsolidated, totalTombstoned,
-                    totalCompacted, elapsed);
-
-        } finally {
-            running.set(false);
-        }
-    }
-
-    // ── V3: IVF Centroid-Based Clustering + LLM Synthesis ──
-
-    /**
-     * Clusters non-consolidated records by centroid ID and promotes dense clusters.
-     *
-     * <p>Algorithm:</p>
-     * <ol>
-     *   <li>Group records by {@code centroid_id} (read from header at offset 24)</li>
-     *   <li>Filter: only process clusters ≥ {@code minClusterSize}</li>
-     *   <li>For each dense cluster:
-     *     <ul>
-     *       <li>Compute common synaptic tags via bitmap AND</li>
-     *       <li>If TextGenerationProvider available: synthesize factual summary</li>
-     *       <li>If no LLM: select highest-importance record as representative</li>
-     *     </ul>
-     *   </li>
-     *   <li>Promote into Semantic tier with {@code MemorySource.REFLECTED}</li>
-     *   <li>Mark all cluster members as consolidated</li>
-     * </ol>
-     */
-    private int clusterAndSynthesize(EpisodicPartition partition,
-                                      SemanticMemoryStore semanticStore,
-                                      Function<Long, String> textLookup) {
-        if (semanticStore == null || partition.count() == 0) return 0;
-
-        CognitiveRecordLayout layout = partition.layout();
-        var segment = partition.segment();
-        int count = partition.count();
-
-        // Step 1: Group non-consolidated records by centroid ID
-        Map<Integer, List<Integer>> centroidClusters = new HashMap<>();
-
-        for (int i = 0; i < count; i++) {
-            long offset = partition.recordOffset(i);
-            byte flags = layout.readFlags(segment, offset);
-
-            if (SynapticHeaderConstants.isTombstoned(flags)) continue;
-            if (SynapticHeaderConstants.isConsolidated(flags)) continue;
-
-            CognitiveHeader header = layout.readHeader(segment, offset);
-            int centroidId = header.centroidId();
-
-            centroidClusters.computeIfAbsent(centroidId, k -> new ArrayList<>()).add(i);
-        }
-
-        // Step 2: Process dense clusters
-        int totalPromoted = 0;
-
-        for (Map.Entry<Integer, List<Integer>> entry : centroidClusters.entrySet()) {
-            List<Integer> clusterIndices = entry.getValue();
-            if (clusterIndices.size() < minClusterSize) continue;
-
-            int centroidId = entry.getKey();
-            log.debug("REM: Processing cluster {} ({} records)", centroidId, clusterIndices.size());
-
-            // Step 2.5: Proactive Interference — decay near-duplicates within cluster
-            int degraded = applyProactiveInterference(partition, clusterIndices);
-            if (degraded > 0) {
-                log.debug("REM: Cluster {} — {} near-duplicates had importance decayed",
-                        centroidId, degraded);
-            }
-
-            // Step 3: Compute common synaptic tags (bitmap AND across cluster)
-            long commonTags = ~0L; // start with all bits set
-            float maxImportance = -1f;
-            int bestIndex = -1;
-            List<String> clusterTexts = new ArrayList<>();
-
-            for (int idx : clusterIndices) {
-                long offset = partition.recordOffset(idx);
-                CognitiveHeader header = layout.readHeader(segment, offset);
-
-                commonTags &= header.synapticTags();
-
-                if (header.importance() > maxImportance) {
-                    maxImportance = header.importance();
-                    bestIndex = idx;
-                }
-
-                // Collect text for LLM synthesis
-                if (textLookup != null) {
-                    String text = textLookup.apply(offset);
-                    if (text != null && !text.isEmpty()) {
-                        clusterTexts.add(text);
-                    }
-                }
-            }
-
-            if (bestIndex < 0) continue;
-
-            // Step 4: Synthesize or select representative
-            CognitiveHeader promotedHeader;
-
-            if (textGenerator != null && !clusterTexts.isEmpty() && embeddingProvider != null) {
-                // V3: LLM-based synthesis
-                promotedHeader = synthesizeWithLlm(clusterTexts, commonTags, maxImportance);
-            } else {
-                // Fallback: promote highest-importance record (no LLM available)
-                long bestOffset = partition.recordOffset(bestIndex);
-                CognitiveHeader episodicHeader = layout.readHeader(segment, bestOffset);
-                promotedHeader = createSemanticHeader(episodicHeader, commonTags);
-            }
-
-            if (promotedHeader != null) {
-                semanticStore.store(promotedHeader);
-                totalPromoted++;
-
-                // Step 5: Mark all cluster members as consolidated
-                for (int idx : clusterIndices) {
-                    long offset = partition.recordOffset(idx);
-                    layout.markConsolidated(segment, offset);
-
-                    // Neurodivergent: Lossless consolidation — pin source episodes
-                    // to preserve encyclopedic detail alongside the semantic fact.
-                    if (pinSourceEpisodes && pinnedCount < pinnedQuota) {
-                        layout.pin(segment, offset);
-                        pinnedCount++;
-                    }
-                }
-
-                log.debug("REM: Cluster {} consolidated ({} records → 1 semantic fact, importance={})",
-                        centroidId, clusterIndices.size(), maxImportance);
-            }
-        }
-
-        return totalPromoted;
-    }
-
-    // ── Proactive Interference ──
-
-    /** Maximum records to compare per cluster (bounds O(N²) cost). */
-    private static final int MAX_INTERFERENCE_CANDIDATES = 20;
-
-    /**
-     * Proactive Interference — competitive degradation of near-duplicate memories.
-     *
-     * <h3>Biological Analog</h3>
-     * <p>New memories overwrite old similar ones (retroactive interference). In the
-     * brain, similar memories compete for the same neural pathways. The newer,
-     * more recently encoded memory wins, and the older one fades.</p>
-     *
-     * <h3>Implementation</h3>
-     * <p>Within each centroid cluster, finds pairs of records within
-     * {@code interferenceThreshold} L2 distance. For each pair, the older
-     * record's importance is multiplied by {@code interferenceDecayFactor}
-     * (default: 0.7 = 30% reduction per cycle). This is less violent than
-     * halving recall_count — the old memory fades naturally via importance
-     * decay rather than losing its entire recall history.</p>
-     *
-     * <h3>Performance</h3>
-     * <p>Caps comparisons at the top-{@value #MAX_INTERFERENCE_CANDIDATES}
-     * records by importance (descending) to bound the O(N²/cluster) cost.
-     * For a cluster of 50 records, this reduces comparisons from 1,225 to 190.</p>
-     *
-     * @param partition       the episodic partition being processed
-     * @param clusterIndices  indices of records in this centroid cluster
-     * @return count of records whose importance was decayed
-     */
-    private int applyProactiveInterference(EpisodicPartition partition,
-                                            List<Integer> clusterIndices) {
-        if (clusterIndices.size() < 2) return 0;
-
-        CognitiveRecordLayout layout = partition.layout();
-        var segment = partition.segment();
-        float threshold = policy.interferenceThreshold();
-        float decayFactor = policy.interferenceDecayFactor();
-
-        // Select top candidates by importance (cap at MAX_INTERFERENCE_CANDIDATES)
-        List<Integer> candidates;
-        if (clusterIndices.size() <= MAX_INTERFERENCE_CANDIDATES) {
-            candidates = clusterIndices;
-        } else {
-            // Sort a copy by importance descending, take top N
-            candidates = new ArrayList<>(clusterIndices);
-            candidates.sort((a, b) -> {
-                float ia = layout.readImportance(segment, partition.recordOffset(a));
-                float ib = layout.readImportance(segment, partition.recordOffset(b));
-                return Float.compare(ib, ia); // descending
-            });
-            candidates = candidates.subList(0, MAX_INTERFERENCE_CANDIDATES);
-        }
-
-        int degradedCount = 0;
-
-        for (int i = 0; i < candidates.size(); i++) {
-            long offsetA = partition.recordOffset(candidates.get(i));
-            CognitiveHeader headerA = layout.readHeader(segment, offsetA);
-            if (SynapticHeaderConstants.isTombstoned(headerA.flags())) continue;
-
-            for (int j = i + 1; j < candidates.size(); j++) {
-                long offsetB = partition.recordOffset(candidates.get(j));
-                CognitiveHeader headerB = layout.readHeader(segment, offsetB);
-                if (SynapticHeaderConstants.isTombstoned(headerB.flags())) continue;
-
-                // Compute L2 distance between quantized vectors.
-                // Read A's quantized bytes → dequantize to float[] → compare against B.
-                // This allocates a float[] per pair, acceptable since this runs during sleep.
-                int vecBytes = layout.quantizedVecBytes();
-                float[] vecA = new float[vecBytes];
-                long vecOffsetA = layout.vectorOffset(offsetA);
-                for (int d = 0; d < vecBytes; d++) {
-                    vecA[d] = (segment.get(java.lang.foreign.ValueLayout.JAVA_BYTE, vecOffsetA + d) & 0xFF);
-                }
-                // Use identity calibration (both vectors quantized the same way)
-                float[] identityMins = com.spectrayan.spector.memory.synapse.IdentityCalibration.mins(vecBytes);
-                float[] identityScales = com.spectrayan.spector.memory.synapse.IdentityCalibration.scales(vecBytes);
-                float dist = com.spectrayan.spector.core.similarity.SimilarityFunction.EUCLIDEAN
-                        .computeQuantizedFromSegment(vecA, segment, layout.vectorOffset(offsetB),
-                                identityMins, identityScales, vecBytes);
-
-                if (dist <= threshold) {
-                    // Near-duplicate: decay the OLDER one's importance
-                    long tsA = headerA.timestampMs();
-                    long tsB = headerB.timestampMs();
-
-                    long olderOffset = tsA <= tsB ? offsetA : offsetB;
-                    float olderImportance = layout.readImportance(segment, olderOffset);
-                    float decayed = olderImportance * decayFactor;
-
-                    layout.writeImportance(segment, olderOffset, decayed);
-                    degradedCount++;
-
-                    log.trace("Proactive interference: decayed importance at offset {} " +
-                            "from {} → {} (L2={}, threshold={})",
-                            olderOffset, olderImportance, decayed, dist, threshold);
-                }
-            }
-        }
-
-        return degradedCount;
-    }
-
-    /**
-     * Synthesizes a semantic fact from cluster texts using the LLM.
-     */
-    private CognitiveHeader synthesizeWithLlm(List<String> clusterTexts, long commonTags,
-                                                float maxImportance) {
-        try {
-            // Build prompt
-            String memoriesText = clusterTexts.stream()
-                    .limit(10) // cap at 10 memories to avoid token overflow
-                    .collect(Collectors.joining("\n- ", "- ", ""));
-
-            String prompt = String.format(
-                    "Summarize these %d related episodic memories into a single factual statement. " +
-                    "Be concise and factual.\n\nMemories:\n%s\n\nFactual summary:",
-                    clusterTexts.size(), memoriesText);
-
-            String synthesized = textGenerator.generate(prompt, GenerationOptions.CONCISE);
-
-            if (synthesized == null || synthesized.isBlank()) {
-                log.warn("REM: LLM returned empty synthesis — falling back to selection");
-                return null;
-            }
-
-            log.debug("REM: LLM synthesized: '{}'", synthesized.substring(0, Math.min(100, synthesized.length())));
-
-            // Build semantic header for the synthesized fact
-            // Embed synthesized text to compute exactNorm (if embedding provider available)
-            float exactNorm = 1.0f;
-            if (embeddingProvider != null) {
-                try {
-                    float[] vec = embeddingProvider.embed(synthesized).vector();
-                    float sum = 0f;
-                    for (float v : vec) sum += v * v;
-                    exactNorm = (float) Math.sqrt(sum);
-                } catch (Exception e) {
-                    log.warn("REM: Failed to embed synthesized text: {}", e.getMessage());
-                }
-            }
-
-            byte semanticFlags = SynapticHeaderConstants.withMemoryType(
-                    SynapticHeaderConstants.FLAG_CONSOLIDATED,
-                    MemoryType.SEMANTIC.ordinal());
-
-            return new CognitiveHeader(
-                    System.currentTimeMillis(), commonTags, exactNorm, maxImportance,
-                    0, (short) 0, (byte) 0, semanticFlags);
-
-        } catch (Exception e) {
-            log.warn("REM: LLM synthesis failed: {} — falling back to selection", e.getMessage());
-            return null;
-        }
-    }
-
-    /**
-     * Creates a SEMANTIC-type header from an episodic header, with consolidated flag.
-     */
-    private CognitiveHeader createSemanticHeader(CognitiveHeader episodicHeader, long commonTags) {
-        byte semanticFlags = SynapticHeaderConstants.withMemoryType(
-                (byte) (episodicHeader.flags() | SynapticHeaderConstants.FLAG_CONSOLIDATED),
-                MemoryType.SEMANTIC.ordinal());
-
-        return new CognitiveHeader(
-                episodicHeader.timestampMs(),
-                commonTags != 0 ? commonTags : episodicHeader.synapticTags(),
-                episodicHeader.exactNorm(),
-                episodicHeader.importance(),
-                episodicHeader.recallCount(),
-                episodicHeader.centroidId(),
-                episodicHeader.valence(),
-                semanticFlags);
-    }
-
-    // ── Simple Highest-Importance Promotion (fallback path) ──
-
-    /**
-     * Promotes the highest-importance non-consolidated memory from a partition
-     * into the semantic store. Used as fallback when clustering is not configured.
-     */
-    private int promoteHighestImportance(EpisodicPartition partition,
-                                          SemanticMemoryStore semanticStore) {
-        if (semanticStore == null || partition.count() == 0) return 0;
-
-        CognitiveRecordLayout layout = partition.layout();
-        var segment = partition.segment();
-        int count = partition.count();
-
-        float maxImportance = -1f;
-        int bestIndex = -1;
-
-        for (int i = 0; i < count; i++) {
-            long offset = partition.recordOffset(i);
-            byte flags = layout.readFlags(segment, offset);
-
-            // Skip tombstoned and already-consolidated
-            if (SynapticHeaderConstants.isTombstoned(flags)) continue;
-            if (SynapticHeaderConstants.isConsolidated(flags)) continue;
-
-            float importance = layout.readImportance(segment, offset);
-            if (importance > maxImportance) {
-                maxImportance = importance;
-                bestIndex = i;
-            }
-        }
-
-        if (bestIndex >= 0 && maxImportance >= 1.0f) {
-            long offset = partition.recordOffset(bestIndex);
-
-            // Read the header and re-create as SEMANTIC type
-            CognitiveHeader episodicHeader = layout.readHeader(segment, offset);
-            CognitiveHeader semanticHeader = createSemanticHeader(episodicHeader,
-                    episodicHeader.synapticTags());
-
-            semanticStore.store(semanticHeader);
-
-            // Mark the episodic original as consolidated
-            layout.markConsolidated(segment, offset);
-
-            // Neurodivergent: Lossless consolidation — pin promoted source
-            if (pinSourceEpisodes && pinnedCount < pinnedQuota) {
-                layout.pin(segment, offset);
-                pinnedCount++;
-            }
-
-            log.debug("REM: Promoted episodic record {} to semantic (importance={})",
-                    bestIndex, maxImportance);
-            return 1;
-        }
-
-        return 0;
-    }
-
-    /**
-     * Returns whether a reflection cycle is currently running.
-     */
-    public boolean isRunning() {
-        return running.get();
-    }
-}
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/hippocampus/TombstoneCompactor.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/hippocampus/TombstoneCompactor.java
deleted file mode 100644
index fce1f02..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/hippocampus/TombstoneCompactor.java
+++ /dev/null
@@ -1,215 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.hippocampus;
-
-import com.spectrayan.spector.memory.cortex.EpisodicMemoryStore;
-import com.spectrayan.spector.memory.cortex.EpisodicMemoryStore.EpisodicPartition;
-import com.spectrayan.spector.memory.synapse.CognitiveRecordLayout;
-import com.spectrayan.spector.memory.synapse.CognitiveRecordLayout.CognitiveHeader;
-import com.spectrayan.spector.memory.synapse.DecayStrategy;
-import com.spectrayan.spector.memory.synapse.SynapticHeaderConstants;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.lang.foreign.MemorySegment;
-import java.nio.file.Path;
-import java.util.HashMap;
-import java.util.Map;
-
-/**
- * Partition rebuild when tombstone ratio exceeds threshold.
- *
- * <h3>Biological Analog: Synaptic Pruning</h3>
- * <p>The brain prunes weak synaptic connections during sleep to make room for
- * new learning. Tombstone compaction is the digital equivalent — removing
- * logically-deleted records so that scans remain fast.</p>
- *
- * <h3>Design: Tombstone + Rebuild (Not In-Place Compaction)</h3>
- * <p>Moving records in-place invalidates HNSW edges and WAL references.
- * Instead, we mark records as tombstoned (1 byte flag write), then
- * rebuild entire partitions when the tombstone ratio exceeds a threshold.</p>
- *
- * <h3>V3: Full Partition Rebuild</h3>
- * <p>When compaction is triggered, a new dense partition is created containing
- * only live (non-tombstoned) records. The old partition is atomically swapped
- * out via {@link EpisodicMemoryStore#replacePartition}. An offset remap is
- * produced so callers can update their ID index entries.</p>
- */
-public final class TombstoneCompactor {
-
-    private static final Logger log = LoggerFactory.getLogger(TombstoneCompactor.class);
-
-    private final float tombstoneThreshold;
-
-    /**
-     * Creates a compactor.
-     *
-     * @param tombstoneThreshold ratio above which compaction triggers (default: 0.30 = 30%)
-     */
-    public TombstoneCompactor(float tombstoneThreshold) {
-        this.tombstoneThreshold = tombstoneThreshold;
-    }
-
-    /**
-     * Checks if a partition should be compacted.
-     */
-    public boolean shouldCompact(EpisodicPartition partition) {
-        return partition.tombstoneRatio() > tombstoneThreshold;
-    }
-
-    /**
-     * Scans a partition and tombstones records whose decayed score falls below
-     * the prune threshold.
-     *
-     * @param partition       the episodic partition to scan
-     * @param pruneThreshold  minimum decay score to survive (records below are tombstoned)
-     * @param nowMs           current time in epoch millis
-     * @return number of records tombstoned in this pass
-     */
-    public int pruneDecayed(EpisodicPartition partition, float pruneThreshold, long nowMs) {
-        int pruned = 0;
-        CognitiveRecordLayout layout = partition.layout();
-        MemorySegment segment = partition.segment();
-        int count = partition.count();
-
-        for (int i = 0; i < count; i++) {
-            long offset = partition.recordOffset(i);
-
-            byte flags = layout.readFlags(segment, offset);
-            if (SynapticHeaderConstants.isTombstoned(flags)) continue;
-
-            // Don't prune pinned memories
-            if (SynapticHeaderConstants.isPinned(flags)) continue;
-
-            long timestamp = layout.readTimestamp(segment, offset);
-            int recallCount = layout.readRecallCount(segment, offset);
-            float importance = layout.readImportance(segment, offset);
-
-            float decay = DecayStrategy.computeDecay(timestamp, nowMs, recallCount);
-            float score = importance * decay;
-
-            if (score < pruneThreshold) {
-                layout.tombstone(segment, offset);
-                partition.incrementTombstoneCount();
-                pruned++;
-            }
-        }
-
-        if (pruned > 0) {
-            log.info("Deep Sleep: tombstoned {} records in partition {} (threshold={})",
-                    pruned, partition.path(), pruneThreshold);
-        }
-
-        return pruned;
-    }
-
-    /**
-     * Compacts a partition by copying all live (non-tombstoned) records into a
-     * new, dense partition.
-     *
-     * <p>The new partition is created at {@code basePath/episodic-{key}-compacted.mem}
-     * with capacity equal to the live record count. All live records are copied
-     * sequentially, producing a dense, gap-free partition.</p>
-     *
-     * @param source   the partition to compact
-     * @param basePath the episodic store base directory
-     * @param key      the partition key (e.g., "20260526")
-     * @return the compacted partition, or null if there are no live records
-     */
-    public EpisodicPartition compact(EpisodicPartition source, Path basePath, String key) {
-        CognitiveRecordLayout layout = source.layout();
-        MemorySegment srcSegment = source.segment();
-        int srcCount = source.count();
-
-        // Count live records
-        int liveCount = 0;
-        for (int i = 0; i < srcCount; i++) {
-            long offset = source.recordOffset(i);
-            byte flags = layout.readFlags(srcSegment, offset);
-            if (!SynapticHeaderConstants.isTombstoned(flags)) {
-                liveCount++;
-            }
-        }
-
-        if (liveCount == 0) {
-            log.info("Compaction: partition {} has no live records — skipping", key);
-            return null;
-        }
-
-        // Create new dense partition
-        Path compactedPath = basePath.resolve("episodic-" + key + "-compacted.mem");
-        EpisodicPartition compacted = new EpisodicPartition(
-                compactedPath, layout, liveCount, true);
-
-        // Copy live records
-        int copied = 0;
-        for (int i = 0; i < srcCount; i++) {
-            long srcOffset = source.recordOffset(i);
-            byte flags = layout.readFlags(srcSegment, srcOffset);
-            if (SynapticHeaderConstants.isTombstoned(flags)) continue;
-
-            // Read header from source
-            CognitiveHeader header = layout.readHeader(srcSegment, srcOffset);
-
-            // Read quantized vector from source
-            byte[] quantizedVec = new byte[layout.quantizedVecBytes()];
-            MemorySegment.copy(srcSegment, layout.vectorOffset(srcOffset),
-                    MemorySegment.ofArray(quantizedVec), 0,
-                    quantizedVec.length);
-
-            // Write to compacted partition
-            compacted.append(header, quantizedVec);
-            copied++;
-        }
-
-        // Mark as compacted state
-        compacted.setState(EpisodicMemoryStore.PartitionState.ACTIVE);
-
-        log.info("Compaction complete: partition {} — {} → {} records (removed {} tombstones)",
-                key, srcCount, copied, srcCount - copied);
-
-        return compacted;
-    }
-
-    /**
-     * Builds an offset remap for updating the ID index after compaction.
-     *
-     * <p>Returns a map of {@code oldOffset → newOffset} for all live records.
-     * Callers use this to update their {@code MemoryLocation} entries.</p>
-     *
-     * @param source   the original partition (before compaction)
-     * @param compacted the compacted partition (after compaction)
-     * @return map of old byte offsets to new byte offsets
-     */
-    public Map<Long, Long> buildOffsetRemap(EpisodicPartition source, EpisodicPartition compacted) {
-        CognitiveRecordLayout layout = source.layout();
-        MemorySegment srcSegment = source.segment();
-        int srcCount = source.count();
-
-        Map<Long, Long> remap = new HashMap<>();
-        int destIndex = 0;
-
-        for (int i = 0; i < srcCount; i++) {
-            long srcOffset = source.recordOffset(i);
-            byte flags = layout.readFlags(srcSegment, srcOffset);
-            if (SynapticHeaderConstants.isTombstoned(flags)) continue;
-
-            long destOffset = compacted.recordOffset(destIndex);
-            remap.put(srcOffset, destOffset);
-            destIndex++;
-        }
-
-        return remap;
-    }
-}
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/index/MemoryIndex.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/index/MemoryIndex.java
deleted file mode 100644
index 1704e77..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/index/MemoryIndex.java
+++ /dev/null
@@ -1,418 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.index;
-
-import com.spectrayan.spector.memory.MemoryType;
-import com.spectrayan.spector.memory.cortex.MemorySource;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.io.IOException;
-import java.io.UncheckedIOException;
-import java.nio.ByteBuffer;
-import java.nio.channels.FileChannel;
-import java.nio.charset.StandardCharsets;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.nio.file.StandardOpenOption;
-import java.util.Map;
-import java.util.concurrent.ConcurrentHashMap;
-
-/**
- * Centralized ID → metadata index for cognitive memories.
- *
- * <h3>Responsibility</h3>
- * <p>Owns the concurrent maps that track memory locations, raw text,
- * provenance sources, and synaptic tag strings. Provides O(1) lookup by ID
- * and O(1) reverse-lookup by offset (via dedicated reverse index).</p>
- *
- * <h3>Persistence</h3>
- * <p>Supports binary serialization via {@link #save(Path)} and {@link #load(Path)}.
- * The file format uses a "MIDX" magic header followed by variable-length records.
- * On startup, the index can be rebuilt from disk without re-ingestion.</p>
- *
- * <h3>Performance: O(1) Reverse Index</h3>
- * <p>A dedicated {@code reverseIndex} maps {@code (type, offset) → id} for
- * constant-time reverse lookups during recall result assembly. The key is
- * computed as {@code (type.ordinal() << 48) | offset}, packing both into
- * a single {@code long} to avoid String concatenation.</p>
- *
- * <h3>Thread Safety</h3>
- * <p>All maps are {@link ConcurrentHashMap} — safe for concurrent ingestion
- * (Virtual Threads) and recall (parallel scans).</p>
- */
-public final class MemoryIndex {
-
-    private static final Logger log = LoggerFactory.getLogger(MemoryIndex.class);
-
-    /** File magic: "MIDX" in ASCII. */
-    private static final int INDEX_MAGIC = 0x4D494458;
-
-    /** File format version. */
-    private static final int INDEX_VERSION = 1;
-
-    /** File header: 4B magic + 4B version + 4B count + 4B reserved = 16 bytes. */
-    private static final int FILE_HEADER_BYTES = 16;
-
-    /**
-     * Tracks where a memory is physically stored.
-     *
-     * @param type            cognitive tier
-     * @param offset          byte offset within the tier's segment
-     * @param partitionIndex  partition index (episodic only, -1 otherwise)
-     */
-    public record MemoryLocation(MemoryType type, long offset, int partitionIndex) {}
-
-    // ── Forward index: id → metadata ──
-    private final ConcurrentHashMap<String, MemoryLocation> locations = new ConcurrentHashMap<>();
-    private final ConcurrentHashMap<String, String> texts = new ConcurrentHashMap<>();
-    private final ConcurrentHashMap<String, MemorySource> sources = new ConcurrentHashMap<>();
-    private final ConcurrentHashMap<String, String[]> tags = new ConcurrentHashMap<>();
-
-    // ── Reverse index: (type, offset) → id  [O(1) lookup for recall result assembly] ──
-    private final ConcurrentHashMap<Long, String> reverseIndex = new ConcurrentHashMap<>();
-
-    /**
-     * Computes the reverse-index key from a memory type and byte offset.
-     *
-     * <p>Packs type ordinal into the upper 16 bits and offset into the lower 48 bits.
-     * This supports offsets up to 256 TB per tier — far beyond any practical limit.</p>
-     */
-    private static long reverseKey(MemoryType type, long offset) {
-        return ((long) type.ordinal() << 48) | (offset & 0x0000_FFFF_FFFF_FFFFL);
-    }
-
-    /**
-     * Registers a new memory in the index.
-     *
-     * <p>Maintains both forward (id → metadata) and reverse ((type, offset) → id)
-     * indexes for O(1) lookups in both directions.</p>
-     *
-     * @param id       unique memory identifier
-     * @param location physical storage location
-     * @param text     raw text content
-     * @param source   provenance source
-     * @param tagArray synaptic tag strings
-     */
-    public void register(String id, MemoryLocation location, String text,
-                          MemorySource source, String[] tagArray) {
-        locations.put(id, location);
-        texts.put(id, text);
-        sources.put(id, source);
-        tags.put(id, tagArray);
-
-        // O(1) reverse index
-        reverseIndex.put(reverseKey(location.type(), location.offset()), id);
-    }
-
-    /**
-     * Removes a memory from both forward and reverse indexes.
-     */
-    public void remove(String id) {
-        MemoryLocation loc = locations.remove(id);
-        texts.remove(id);
-        sources.remove(id);
-        tags.remove(id);
-
-        // Clean reverse index
-        if (loc != null) {
-            reverseIndex.remove(reverseKey(loc.type(), loc.offset()));
-        }
-    }
-
-    /**
-     * Returns the physical location for a memory ID, or null if not found.
-     * O(1) via ConcurrentHashMap.
-     */
-    public MemoryLocation locate(String id) {
-        return locations.get(id);
-    }
-
-    /**
-     * Returns the raw text for a memory ID, or empty string if not found.
-     */
-    public String text(String id) {
-        return texts.getOrDefault(id, "");
-    }
-
-    /**
-     * Returns the provenance source for a memory ID.
-     */
-    public MemorySource source(String id) {
-        return sources.getOrDefault(id, MemorySource.OBSERVED);
-    }
-
-    /**
-     * Returns the synaptic tag strings for a memory ID.
-     */
-    public String[] tags(String id) {
-        return tags.getOrDefault(id, new String[0]);
-    }
-
-    /**
-     * O(1) reverse-lookup: finds the memory ID stored at a given offset in a given tier.
-     *
-     * <p>Uses a dedicated reverse index ({@code ConcurrentHashMap<Long, String>})
-     * instead of the previous O(n) linear scan over the location map.</p>
-     *
-     * @param type   memory tier to search
-     * @param offset byte offset to match
-     * @return the memory ID, or null if not found
-     */
-    public String findIdByOffset(MemoryType type, long offset) {
-        return reverseIndex.get(reverseKey(type, offset));
-    }
-
-    /**
-     * Returns the text for a memory stored at a given offset.
-     * O(1) via reverse index.
-     */
-    public String findTextByOffset(MemoryType type, long offset) {
-        String id = findIdByOffset(type, offset);
-        return id != null ? texts.get(id) : null;
-    }
-
-    /**
-     * Returns the total number of indexed memories.
-     */
-    public int size() {
-        return locations.size();
-    }
-
-    /**
-     * Returns the raw location map (for iteration in decay, etc.).
-     */
-    public ConcurrentHashMap<String, MemoryLocation> locationMap() {
-        return locations;
-    }
-
-    // ══════════════════════════════════════════════════════════════
-    // PERSISTENCE: save / load
-    // ══════════════════════════════════════════════════════════════
-
-    /**
-     * Saves the entire index to a binary file.
-     *
-     * <h3>File Format</h3>
-     * <pre>
-     *   [4B magic: "MIDX"]  [4B version: 1]  [4B entry_count]  [4B reserved]
-     *   For each entry:
-     *     [4B id_len] [N id_bytes]
-     *     [4B type_ordinal] [8B offset] [4B partition_index]
-     *     [4B text_len] [N text_bytes]
-     *     [4B source_ordinal]
-     *     [4B tag_count] { [4B tag_len] [N tag_bytes] }*
-     * </pre>
-     *
-     * @param filePath path to write the index file
-     */
-    public void save(Path filePath) {
-        Path parent = filePath.getParent();
-        if (parent != null) {
-            try {
-                Files.createDirectories(parent);
-            } catch (IOException e) {
-                throw new UncheckedIOException("Cannot create index directory: " + parent, e);
-            }
-        }
-
-        try (FileChannel ch = FileChannel.open(filePath,
-                StandardOpenOption.CREATE, StandardOpenOption.WRITE,
-                StandardOpenOption.TRUNCATE_EXISTING)) {
-
-            // Write file header
-            ByteBuffer header = ByteBuffer.allocate(FILE_HEADER_BYTES);
-            header.putInt(INDEX_MAGIC);
-            header.putInt(INDEX_VERSION);
-            header.putInt(locations.size());
-            header.putInt(0); // reserved
-            header.flip();
-            ch.write(header);
-
-            // Write each entry
-            for (Map.Entry<String, MemoryLocation> entry : locations.entrySet()) {
-                String id = entry.getKey();
-                MemoryLocation loc = entry.getValue();
-                String text = texts.getOrDefault(id, "");
-                MemorySource source = sources.getOrDefault(id, MemorySource.OBSERVED);
-                String[] tagArray = tags.getOrDefault(id, new String[0]);
-
-                writeEntry(ch, id, loc, text, source, tagArray);
-            }
-
-            ch.force(true);
-            log.info("MemoryIndex saved: {} entries → {}", locations.size(), filePath);
-
-        } catch (IOException e) {
-            throw new UncheckedIOException("Failed to save MemoryIndex: " + filePath, e);
-        }
-    }
-
-    /**
-     * Loads an index from a binary file, or returns a new empty index
-     * if the file doesn't exist.
-     *
-     * @param filePath path to the index file
-     * @return a populated MemoryIndex (or empty if file missing)
-     */
-    public static MemoryIndex load(Path filePath) {
-        MemoryIndex index = new MemoryIndex();
-
-        if (filePath == null || !Files.exists(filePath)) {
-            log.info("MemoryIndex file not found, starting fresh: {}", filePath);
-            return index;
-        }
-
-        try (FileChannel ch = FileChannel.open(filePath, StandardOpenOption.READ)) {
-            long fileSize = ch.size();
-            if (fileSize < FILE_HEADER_BYTES) {
-                log.warn("MemoryIndex file too small ({}B), starting fresh", fileSize);
-                return index;
-            }
-
-            // Read file header
-            ByteBuffer header = ByteBuffer.allocate(FILE_HEADER_BYTES);
-            ch.read(header);
-            header.flip();
-
-            int magic = header.getInt();
-            int version = header.getInt();
-            int entryCount = header.getInt();
-            header.getInt(); // reserved
-
-            if (magic != INDEX_MAGIC) {
-                log.warn("Invalid MemoryIndex magic: 0x{} (expected 0x{}), starting fresh",
-                        Integer.toHexString(magic), Integer.toHexString(INDEX_MAGIC));
-                return index;
-            }
-            if (version != INDEX_VERSION) {
-                log.warn("Unsupported MemoryIndex version: {} (expected {}), starting fresh",
-                        version, INDEX_VERSION);
-                return index;
-            }
-
-            // Read entries
-            for (int i = 0; i < entryCount; i++) {
-                readEntry(ch, index);
-            }
-
-            log.info("MemoryIndex loaded: {} entries from {}", index.size(), filePath);
-
-        } catch (IOException e) {
-            log.error("Failed to load MemoryIndex from {}, starting fresh: {}", filePath, e.getMessage());
-        }
-
-        return index;
-    }
-
-    // ── Internal serialization helpers ──
-
-    private void writeEntry(FileChannel ch, String id, MemoryLocation loc,
-                             String text, MemorySource source, String[] tagArray) throws IOException {
-        byte[] idBytes = id.getBytes(StandardCharsets.UTF_8);
-        byte[] textBytes = text.getBytes(StandardCharsets.UTF_8);
-
-        // Calculate total size for this entry
-        int size = 4 + idBytes.length      // id
-                + 4 + 8 + 4               // location (type + offset + partitionIndex)
-                + 4 + textBytes.length     // text
-                + 4                        // source
-                + 4;                       // tag count
-
-        for (String tag : tagArray) {
-            size += 4 + tag.getBytes(StandardCharsets.UTF_8).length;
-        }
-
-        ByteBuffer buf = ByteBuffer.allocate(size);
-
-        // ID
-        buf.putInt(idBytes.length);
-        buf.put(idBytes);
-
-        // Location
-        buf.putInt(loc.type().ordinal());
-        buf.putLong(loc.offset());
-        buf.putInt(loc.partitionIndex());
-
-        // Text
-        buf.putInt(textBytes.length);
-        buf.put(textBytes);
-
-        // Source
-        buf.putInt(source.ordinal());
-
-        // Tags
-        buf.putInt(tagArray.length);
-        for (String tag : tagArray) {
-            byte[] tagBytes = tag.getBytes(StandardCharsets.UTF_8);
-            buf.putInt(tagBytes.length);
-            buf.put(tagBytes);
-        }
-
-        buf.flip();
-        ch.write(buf);
-    }
-
-    private static void readEntry(FileChannel ch, MemoryIndex index) throws IOException {
-        // ID
-        String id = readString(ch);
-
-        // Location
-        ByteBuffer locBuf = ByteBuffer.allocate(4 + 8 + 4);
-        ch.read(locBuf);
-        locBuf.flip();
-        int typeOrd = locBuf.getInt();
-        long offset = locBuf.getLong();
-        int partitionIndex = locBuf.getInt();
-        MemoryType type = MemoryType.values()[typeOrd];
-        MemoryLocation loc = new MemoryLocation(type, offset, partitionIndex);
-
-        // Text
-        String text = readString(ch);
-
-        // Source
-        ByteBuffer srcBuf = ByteBuffer.allocate(4);
-        ch.read(srcBuf);
-        srcBuf.flip();
-        int sourceOrd = srcBuf.getInt();
-        MemorySource source = MemorySource.values()[sourceOrd];
-
-        // Tags
-        ByteBuffer tagCountBuf = ByteBuffer.allocate(4);
-        ch.read(tagCountBuf);
-        tagCountBuf.flip();
-        int tagCount = tagCountBuf.getInt();
-        String[] tagArray = new String[tagCount];
-        for (int t = 0; t < tagCount; t++) {
-            tagArray[t] = readString(ch);
-        }
-
-        index.register(id, loc, text, source, tagArray);
-    }
-
-    private static String readString(FileChannel ch) throws IOException {
-        ByteBuffer lenBuf = ByteBuffer.allocate(4);
-        ch.read(lenBuf);
-        lenBuf.flip();
-        int len = lenBuf.getInt();
-
-        if (len == 0) return "";
-
-        ByteBuffer strBuf = ByteBuffer.allocate(len);
-        ch.read(strBuf);
-        strBuf.flip();
-        return new String(strBuf.array(), 0, len, StandardCharsets.UTF_8);
-    }
-}
-
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/inhibition/SuppressionSet.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/inhibition/SuppressionSet.java
deleted file mode 100644
index a0012ff..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/inhibition/SuppressionSet.java
+++ /dev/null
@@ -1,147 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.inhibition;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.util.Collections;
-import java.util.Set;
-import java.util.concurrent.ConcurrentHashMap;
-
-/**
- * Session-level recall suppression set.
- *
- * <h3>Biological Analog: Prefrontal Cortex Inhibition</h3>
- * <p>The prefrontal cortex actively suppresses irrelevant memories during focused
- * retrieval. This is why you can concentrate on a task despite having millions
- * of memories competing for attention.</p>
- *
- * <h3>Anti-Hallucination Mechanism</h3>
- * <p>If the agent recalls a memory that leads to a wrong answer, suppressing it
- * prevents repeating the same mistake in the same conversation. The suppression
- * is volatile — it dies when the session ends.</p>
- *
- * <h3>Thread Safety</h3>
- * <p>Backed by {@link ConcurrentHashMap} key set — fully concurrent.</p>
- */
-public final class SuppressionSet {
-
-    private static final Logger log = LoggerFactory.getLogger(SuppressionSet.class);
-
-    /** String ID based suppression (primary). */
-    private final Set<String> suppressed = ConcurrentHashMap.newKeySet();
-
-    /**
-     * Offset-indexed suppression for hot-loop filtering.
-     * Key = packed {@code (type_ordinal << 48 | offset)} for O(1) lookup
-     * during scoring without requiring String ID resolution.
-     */
-    private final Set<Long> suppressedOffsets = ConcurrentHashMap.newKeySet();
-
-    /**
-     * Suppresses a memory by ID for the remainder of this session.
-     *
-     * @param memoryId the memory to suppress
-     * @param reason   optional reason for suppression (for logging)
-     */
-    public void suppress(String memoryId, String reason) {
-        suppressed.add(memoryId);
-        log.debug("Memory suppressed: '{}' (reason: {})", memoryId,
-                reason != null ? reason : "unspecified");
-    }
-
-    /**
-     * Suppresses a memory by ID.
-     */
-    public void suppress(String memoryId) {
-        suppress(memoryId, null);
-    }
-
-    /**
-     * Registers a suppressed memory's offset for hot-loop filtering.
-     *
-     * <p>Call this after {@link #suppress(String)} when the memory's
-     * location is known, to enable pre-scoring suppression checks.</p>
-     *
-     * @param typeOrdinal the memory type ordinal (e.g., MemoryType.EPISODIC.ordinal())
-     * @param offset      the byte offset of the record in its tier segment
-     */
-    public void registerOffset(int typeOrdinal, long offset) {
-        suppressedOffsets.add(packOffset(typeOrdinal, offset));
-    }
-
-    /**
-     * Checks if a memory at the given offset is suppressed.
-     *
-     * <p>O(1) lookup for use in scoring hot loops — avoids the String ID
-     * lookup required by {@link #isSuppressed(String)}.</p>
-     *
-     * @param typeOrdinal the memory type ordinal
-     * @param offset      the byte offset of the record
-     * @return true if the memory at this offset is suppressed
-     */
-    public boolean isSuppressedByOffset(int typeOrdinal, long offset) {
-        return suppressedOffsets.contains(packOffset(typeOrdinal, offset));
-    }
-
-    /**
-     * Checks if a memory ID is currently suppressed.
-     *
-     * @param memoryId the memory to check
-     * @return true if suppressed
-     */
-    public boolean isSuppressed(String memoryId) {
-        return suppressed.contains(memoryId);
-    }
-
-    /**
-     * Removes suppression for a memory.
-     *
-     * @param memoryId the memory to unsuppress
-     */
-    public void unsuppress(String memoryId) {
-        suppressed.remove(memoryId);
-        log.debug("Memory unsuppressed: '{}'", memoryId);
-    }
-
-    /**
-     * Returns the number of currently suppressed memories.
-     */
-    public int size() {
-        return suppressed.size();
-    }
-
-    /**
-     * Returns an unmodifiable view of all suppressed memory IDs.
-     */
-    public Set<String> suppressedIds() {
-        return Collections.unmodifiableSet(suppressed);
-    }
-
-    /**
-     * Clears all suppressions (typically called at session end).
-     */
-    public void clear() {
-        int count = suppressed.size();
-        suppressed.clear();
-        suppressedOffsets.clear();
-        log.debug("Suppression set cleared ({} entries)", count);
-    }
-
-    // ── Internal ──
-
-    private static long packOffset(int typeOrdinal, long offset) {
-        return ((long) typeOrdinal << 48) | (offset & 0x0000_FFFF_FFFF_FFFFL);
-    }
-}
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/interference/SemanticDeduplicator.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/interference/SemanticDeduplicator.java
deleted file mode 100644
index b8e82c8..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/interference/SemanticDeduplicator.java
+++ /dev/null
@@ -1,183 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.interference;
-
-import com.spectrayan.spector.core.similarity.SimilarityFunction;
-import com.spectrayan.spector.memory.synapse.CognitiveRecordLayout;
-import com.spectrayan.spector.memory.synapse.CognitiveRecordLayout.CognitiveHeader;
-import com.spectrayan.spector.memory.synapse.IdentityCalibration;
-import com.spectrayan.spector.memory.synapse.SynapticHeaderConstants;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.lang.foreign.MemorySegment;
-import java.util.Optional;
-
-/**
- * Merge-on-ingest semantic deduplication.
- *
- * <h3>Biological Analog: Memory Interference</h3>
- * <p>Old memories interfere with learning new ones (proactive interference), and
- * new memories overwrite old ones (retroactive interference). You can't remember
- * your old phone number after learning a new one.</p>
- *
- * <h3>Implementation</h3>
- * <p>During ingestion, if a new memory's vector falls within a tight L2 radius
- * of an existing one in the same tier, don't create a duplicate — merge:
- * refresh timestamp, bump importance, OR the Bloom filters.</p>
- *
- * <h3>Distance Computation</h3>
- * <p>Delegates to {@link SimilarityFunction#computeQuantizedFromSegment} — the
- * same zero-copy off-heap kernel used by {@code CognitiveScorer}, {@code spector-storage},
- * and {@code spector-index}. Accepts optional calibration parameters from
- * {@link com.spectrayan.spector.core.quantization.ScalarQuantizer} for accurate
- * per-dimension affine dequantization.</p>
- */
-public final class SemanticDeduplicator {
-
-    private static final Logger log = LoggerFactory.getLogger(SemanticDeduplicator.class);
-
-    private final float deduplicationRadius;
-
-    /**
-     * Creates a deduplicator.
-     *
-     * @param deduplicationRadius L2 distance threshold for considering two memories
-     *                           as duplicates (default: 0.05)
-     */
-    public SemanticDeduplicator(float deduplicationRadius) {
-        this.deduplicationRadius = deduplicationRadius;
-    }
-
-    /**
-     * Creates a deduplicator with default radius (0.05).
-     */
-    public SemanticDeduplicator() {
-        this(0.05f);
-    }
-
-    /**
-     * Checks if a new vector is a near-duplicate of any existing record in the segment.
-     * Uses uncalibrated identity quantization.
-     *
-     * @param newVector     the new memory's vector
-     * @param segment       existing records segment
-     * @param recordCount   number of existing records
-     * @param layout        cognitive record layout
-     * @return the index of the nearest duplicate (if within radius), or empty
-     */
-    public Optional<Integer> findDuplicate(float[] newVector, MemorySegment segment,
-                                            int recordCount, CognitiveRecordLayout layout) {
-        return findDuplicate(newVector, segment, recordCount, layout, 0L, null, null);
-    }
-
-    /**
-     * Checks if a new vector is a near-duplicate of any existing record in the segment.
-     * Uses uncalibrated identity quantization with a base offset.
-     *
-     * @param newVector     the new memory's vector
-     * @param segment       existing records segment
-     * @param recordCount   number of existing records
-     * @param layout        cognitive record layout
-     * @param baseOffset    byte offset where records begin (e.g., metadata header size)
-     * @return the index of the nearest duplicate (if within radius), or empty
-     */
-    public Optional<Integer> findDuplicate(float[] newVector, MemorySegment segment,
-                                            int recordCount, CognitiveRecordLayout layout,
-                                            long baseOffset) {
-        return findDuplicate(newVector, segment, recordCount, layout, baseOffset, null, null);
-    }
-
-    /**
-     * Checks if a new vector is a near-duplicate of any existing record in the segment
-     * using calibrated {@link SimilarityFunction#computeQuantizedFromSegment} distance.
-     *
-     * <p>When {@code mins} and {@code scales} are provided (from
-     * {@link com.spectrayan.spector.core.quantization.ScalarQuantizer}), the distance
-     * uses proper per-dimension affine dequantization. When null, falls back to
-     * identity transform.</p>
-     *
-     * @param newVector     the new memory's vector
-     * @param segment       existing records segment
-     * @param recordCount   number of existing records
-     * @param layout        cognitive record layout
-     * @param baseOffset    byte offset where records begin (e.g., metadata header size)
-     * @param mins          per-dimension minimum values from ScalarQuantizer calibration (null = identity)
-     * @param scales        per-dimension scale values from ScalarQuantizer calibration (null = identity)
-     * @return the index of the nearest duplicate (if within radius), or empty
-     */
-    public Optional<Integer> findDuplicate(float[] newVector, MemorySegment segment,
-                                            int recordCount, CognitiveRecordLayout layout,
-                                            long baseOffset, float[] mins, float[] scales) {
-        float minDistance = Float.MAX_VALUE;
-        int minIndex = -1;
-
-        int stride = layout.stride();
-        int dims = newVector.length;
-
-        // Resolve calibration: use identity transform if not calibrated
-        float[] effectiveMins = mins != null ? mins : IdentityCalibration.mins(dims);
-        float[] effectiveScales = scales != null ? scales : IdentityCalibration.scales(dims);
-
-        for (int i = 0; i < recordCount; i++) {
-            long offset = baseOffset + (long) i * stride;
-
-            // Skip tombstoned records
-            byte flags = segment.get(SynapticHeaderConstants.LAYOUT_FLAGS,
-                    offset + SynapticHeaderConstants.OFFSET_FLAGS);
-            if (SynapticHeaderConstants.isTombstoned(flags)) continue;
-
-            // Compute calibrated L2 distance via SimilarityFunction
-            float dist = SimilarityFunction.EUCLIDEAN.computeQuantizedFromSegment(
-                    newVector, segment, layout.vectorOffset(offset),
-                    effectiveMins, effectiveScales, layout.quantizedVecBytes());
-
-            if (dist < minDistance) {
-                minDistance = dist;
-                minIndex = i;
-            }
-        }
-
-        if (minIndex >= 0 && minDistance <= deduplicationRadius) {
-            log.debug("Deduplication: found near-duplicate at index {} (L2={})",
-                    minIndex, minDistance);
-            return Optional.of(minIndex);
-        }
-
-        return Optional.empty();
-    }
-
-    /**
-     * Merges a new header's metadata into an existing record (retroactive interference).
-     *
-     * <p>Updates: timestamp (refresh), importance (max), synaptic tags (OR).</p>
-     */
-    public void merge(MemorySegment segment, long offset, CognitiveRecordLayout layout,
-                       CognitiveHeader newHeader) {
-        // Refresh timestamp to current time
-        layout.writeTimestamp(segment, offset, newHeader.timestampMs());
-
-        // Bump importance: max(old, new)
-        float existingImportance = layout.readImportance(segment, offset);
-        float mergedImportance = Math.max(existingImportance, newHeader.importance());
-        layout.writeImportance(segment, offset, mergedImportance);
-
-        // OR synaptic tags
-        layout.mergeSynapticTags(segment, offset, newHeader.synapticTags());
-
-        log.debug("Merged memory at offset {}: importance {} → {}", offset,
-                existingImportance, mergedImportance);
-    }
-
-}
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/metamemory/MemoryInsight.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/metamemory/MemoryInsight.java
deleted file mode 100644
index e444a18..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/metamemory/MemoryInsight.java
+++ /dev/null
@@ -1,74 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.metamemory;
-
-/**
- * Immutable result of a memory introspection query.
- *
- * <p>Contains aggregated statistics about the agent's knowledge on a topic,
- * including confidence, gaps, staleness, and recall frequency.</p>
- *
- * @param query            the introspection query
- * @param totalMemories    number of memories matching the query
- * @param avgImportance    average importance across matching memories
- * @param avgValence       average valence (positive = good outcomes)
- * @param avgAgeDays       average age in days
- * @param confidence       confidence score (0.0–1.0, based on memory count + reinforcement)
- * @param gaps             related topics with zero memories (knowledge gaps)
- * @param staleness        staleness score (0.0–1.0, based on average age vs. freshness)
- * @param recallsPerDay    average recall frequency per day
- * @param recommendation   human-readable recommendation for the agent
- */
-public record MemoryInsight(
-        String query,
-        int totalMemories,
-        float avgImportance,
-        float avgValence,
-        float avgAgeDays,
-        float confidence,
-        String[] gaps,
-        float staleness,
-        float recallsPerDay,
-        String recommendation
-) {
-
-    /**
-     * Returns true if the agent has meaningful knowledge about this topic.
-     */
-    public boolean isKnown() {
-        return totalMemories > 0 && confidence > 0.3f;
-    }
-
-    /**
-     * Returns true if the knowledge is stale and may need refreshing.
-     */
-    public boolean isStale() {
-        return staleness > 0.7f;
-    }
-
-    /**
-     * Returns true if there are significant knowledge gaps.
-     */
-    public boolean hasGaps() {
-        return gaps != null && gaps.length > 0;
-    }
-
-    /**
-     * Empty insight — no knowledge found.
-     */
-    public static MemoryInsight empty(String query) {
-        return new MemoryInsight(query, 0, 0f, 0f, 0f, 0f,
-                new String[0], 1.0f, 0f,
-                "No memories found for '" + query + "'. Consider asking the user.");
-    }
-}
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/metamemory/MemoryIntrospector.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/metamemory/MemoryIntrospector.java
deleted file mode 100644
index 319b229..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/metamemory/MemoryIntrospector.java
+++ /dev/null
@@ -1,210 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.metamemory;
-
-import com.spectrayan.spector.memory.CognitiveResult;
-import com.spectrayan.spector.memory.hebbian.CoActivationTracker;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.util.LinkedHashSet;
-import java.util.List;
-import java.util.Set;
-
-/**
- * Memory introspection engine — lets the agent reason about what it knows.
- *
- * <h3>Biological Analog: Metacognition / Metamemory</h3>
- * <p>Knowledge about your own memory capabilities. You <em>know</em> you're bad at
- * remembering names but good at faces. This self-awareness lets you compensate —
- * you write names down because you know you'll forget.</p>
- *
- * <h3>Capabilities</h3>
- * <ul>
- *   <li><b>Confidence:</b> How well does the agent know a topic? (based on count + reinforcement)</li>
- *   <li><b>Gaps:</b> What related topics have zero memories? (via Hebbian co-activation cross-reference)</li>
- *   <li><b>Staleness:</b> How old is the knowledge? (may be outdated)</li>
- *   <li><b>Recall frequency:</b> How often is this knowledge used?</li>
- *   <li><b>Recommendation:</b> Actionable advice for the agent</li>
- * </ul>
- *
- * <h3>Gap Detection</h3>
- * <p>Uses {@link CoActivationTracker} to find topics that frequently co-occur with
- * the queried tags but have zero memories in the current result set. These are
- * "knowledge holes" — related domains where the agent lacks information.</p>
- *
- * <h3>Value</h3>
- * <p>Instead of hallucinating, the agent can say: "I don't have strong memories
- * about Kubernetes RBAC — let me ask you about that."</p>
- */
-public final class MemoryIntrospector {
-
-    private static final Logger log = LoggerFactory.getLogger(MemoryIntrospector.class);
-
-    /** Maximum number of gaps to report. */
-    private static final int MAX_GAPS = 10;
-
-    /** Maximum number of co-activated tags to consider per result tag. */
-    private static final int CO_ACTIVATION_DEPTH = 5;
-
-    private final CoActivationTracker coActivationTracker;
-
-    /**
-     * Creates a memory introspector with Hebbian co-activation support for gap detection.
-     *
-     * @param coActivationTracker the tracker recording tag co-occurrence data
-     */
-    public MemoryIntrospector(CoActivationTracker coActivationTracker) {
-        this.coActivationTracker = coActivationTracker;
-    }
-
-    /**
-     * Creates a memory introspector without co-activation support (gaps will be empty).
-     */
-    public MemoryIntrospector() {
-        this(null);
-    }
-
-    /**
-     * Analyzes a set of recall results to produce a metamemory insight.
-     *
-     * <p>Call this with the results from a broad recall query about a topic.</p>
-     *
-     * @param query   the topic being introspected
-     * @param results recall results for the topic
-     * @return aggregated insight about the agent's knowledge
-     */
-    public MemoryInsight analyze(String query, List<CognitiveResult> results) {
-        if (results == null || results.isEmpty()) {
-            return MemoryInsight.empty(query);
-        }
-
-        int count = results.size();
-
-        // Average importance
-        float sumImportance = 0f;
-        float sumValence = 0f;
-        float sumAgeDays = 0f;
-        float sumRecallCount = 0f;
-        int reinforcedCount = 0;
-
-        for (CognitiveResult r : results) {
-            sumImportance += r.importance();
-            sumValence += r.valence();
-            sumAgeDays += r.ageDays();
-            sumRecallCount += r.recallCount();
-            if (r.recallCount() > 0) reinforcedCount++;
-        }
-
-        float avgImportance = sumImportance / count;
-        float avgValence = sumValence / count;
-        float avgAgeDays = sumAgeDays / count;
-        float avgRecalls = sumRecallCount / count;
-
-        // Confidence: based on memory count, reinforcement ratio, and importance
-        float countFactor = Math.min(1.0f, count / 20.0f); // saturates at 20 memories
-        float reinforcementFactor = count > 0 ? (float) reinforcedCount / count : 0f;
-        float importanceFactor = Math.min(1.0f, avgImportance / 5.0f);
-        float confidence = (countFactor * 0.4f + reinforcementFactor * 0.3f + importanceFactor * 0.3f);
-
-        // Staleness: based on average age
-        float staleness;
-        if (avgAgeDays < 1) staleness = 0.0f;
-        else if (avgAgeDays < 7) staleness = 0.2f;
-        else if (avgAgeDays < 30) staleness = 0.5f;
-        else if (avgAgeDays < 90) staleness = 0.7f;
-        else staleness = 0.9f;
-
-        // Approximate recalls per day
-        float recallsPerDay = avgAgeDays > 0 ? avgRecalls / avgAgeDays : avgRecalls;
-
-        // Recommendation
-        String recommendation = buildRecommendation(query, confidence, staleness, count);
-
-        // Gap detection via Hebbian co-activation cross-reference
-        String[] gaps = detectGaps(results);
-
-        MemoryInsight insight = new MemoryInsight(query, count, avgImportance, avgValence,
-                avgAgeDays, confidence, gaps, staleness, recallsPerDay, recommendation);
-
-        log.debug("Introspection for '{}': confidence={}, staleness={}, count={}, gaps={}",
-                query, confidence, staleness, count, gaps.length);
-
-        return insight;
-    }
-
-    /**
-     * Detects knowledge gaps by cross-referencing tags in the result set with
-     * Hebbian co-activation data.
-     *
-     * <p>For each tag present in the results, queries the co-activation tracker for
-     * related tags. Tags that are strongly co-activated but absent from the result set
-     * are identified as gaps — topics the agent should know about but doesn't.</p>
-     *
-     * @param results the recall results to analyze
-     * @return array of gap topic names (empty if no co-activation data available)
-     */
-    private String[] detectGaps(List<CognitiveResult> results) {
-        if (coActivationTracker == null || coActivationTracker.pairCount() == 0) {
-            return new String[0];
-        }
-
-        // Collect all tags present in the result set
-        Set<String> presentTags = new LinkedHashSet<>();
-        for (CognitiveResult r : results) {
-            if (r.synapticTags() != null) {
-                for (String tag : r.synapticTags()) {
-                    presentTags.add(tag);
-                }
-            }
-        }
-
-        if (presentTags.isEmpty()) {
-            return new String[0];
-        }
-
-        // Find co-activated tags that are NOT in the present set → these are gaps
-        Set<String> gaps = new LinkedHashSet<>();
-        for (String tag : presentTags) {
-            List<String> associated = coActivationTracker.getAssociatedTags(tag, CO_ACTIVATION_DEPTH);
-            for (String candidate : associated) {
-                if (!presentTags.contains(candidate)) {
-                    gaps.add(candidate);
-                    if (gaps.size() >= MAX_GAPS) break;
-                }
-            }
-            if (gaps.size() >= MAX_GAPS) break;
-        }
-
-        return gaps.toArray(String[]::new);
-    }
-
-    private String buildRecommendation(String query, float confidence,
-                                        float staleness, int count) {
-        if (count == 0) {
-            return "No memories found for '" + query + "'. Consider asking the user.";
-        }
-        if (confidence < 0.3f) {
-            return "Low confidence on '" + query + "'. Knowledge is sparse — consider researching.";
-        }
-        if (staleness > 0.7f) {
-            return "Knowledge about '" + query + "' may be outdated (avg age > 30 days). Consider refreshing.";
-        }
-        if (confidence > 0.7f && staleness < 0.3f) {
-            return "High confidence on '" + query + "'. Recent and well-reinforced knowledge.";
-        }
-        return "Moderate confidence on '" + query + "'. " + count + " memories found.";
-    }
-}
-
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/middleware/ImplicitRecallProxy.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/middleware/ImplicitRecallProxy.java
deleted file mode 100644
index 153c30c..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/middleware/ImplicitRecallProxy.java
+++ /dev/null
@@ -1,142 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.middleware;
-
-import com.spectrayan.spector.memory.CognitiveResult;
-import com.spectrayan.spector.memory.RecallOptions;
-import com.spectrayan.spector.memory.SpectorMemory;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.util.List;
-
-/**
- * Implicit recall proxy — enriches LLM prompts with relevant memories.
- *
- * <h3>The Problem</h3>
- * <p>Standard MCP is tool-call-only — the LLM decides when to call tools.
- * For implicit recall (automatically injecting memories before the LLM
- * sees the prompt), we need a middleware layer.</p>
- *
- * <h3>Architecture</h3>
- * <p>This class sits between the user prompt and the LLM. For each incoming
- * prompt, it:</p>
- * <ol>
- *   <li>Calls {@link SpectorMemory#recall} with the prompt text</li>
- *   <li>Formats top-K memories as a system message prefix</li>
- *   <li>Returns the enriched prompt for the caller to forward to the LLM</li>
- * </ol>
- *
- * <h3>Usage</h3>
- * <pre>{@code
- *   var proxy = new ImplicitRecallProxy(memory);
- *   String enrichedSystemMessage = proxy.enrichPrompt(userMessage, systemMessage);
- *   // Forward enrichedSystemMessage + userMessage to LLM
- * }</pre>
- *
- * <p>This is optional middleware — not part of the MCP server. Deploy it
- * as an HTTP proxy, middleware layer, or direct integration in your agent.</p>
- */
-public final class ImplicitRecallProxy {
-
-    private static final Logger log = LoggerFactory.getLogger(ImplicitRecallProxy.class);
-
-    private static final String MEMORY_HEADER = "\n\n--- Agent Memory Context ---\n";
-    private static final String MEMORY_FOOTER = "\n--- End Memory Context ---\n\n";
-
-    private final SpectorMemory memory;
-    private final int defaultTopK;
-    private final float minImportance;
-
-    /**
-     * Creates a proxy with default settings.
-     *
-     * @param memory the cognitive memory instance
-     */
-    public ImplicitRecallProxy(SpectorMemory memory) {
-        this(memory, 5, 0.1f);
-    }
-
-    /**
-     * Creates a proxy with custom settings.
-     *
-     * @param memory        the cognitive memory instance
-     * @param defaultTopK   number of memories to inject
-     * @param minImportance minimum importance threshold for injection
-     */
-    public ImplicitRecallProxy(SpectorMemory memory, int defaultTopK, float minImportance) {
-        this.memory = memory;
-        this.defaultTopK = defaultTopK;
-        this.minImportance = minImportance;
-    }
-
-    /**
-     * Enriches a system message with relevant memories based on the user's prompt.
-     *
-     * @param userMessage   the user's prompt (used for recall query)
-     * @param systemMessage the existing system message (memories are appended)
-     * @return enriched system message with memory context
-     */
-    public String enrichPrompt(String userMessage, String systemMessage) {
-        if (userMessage == null || userMessage.isBlank()) return systemMessage;
-
-        List<CognitiveResult> results = memory.recall(userMessage,
-                RecallOptions.builder()
-                        .topK(defaultTopK)
-                        .minImportance(minImportance)
-                        .build());
-
-        if (results.isEmpty()) {
-            log.debug("No memories found for implicit recall: '{}'",
-                    userMessage.substring(0, Math.min(50, userMessage.length())));
-            return systemMessage;
-        }
-
-        var sb = new StringBuilder(systemMessage != null ? systemMessage : "");
-        sb.append(MEMORY_HEADER);
-
-        for (int i = 0; i < results.size(); i++) {
-            CognitiveResult r = results.get(i);
-            sb.append(i + 1).append(". ");
-            sb.append("[").append(r.memoryType()).append("]");
-            sb.append(" (confidence=").append(String.format("%.2f", r.ltpAdjustedDecay()));
-            sb.append(", source=").append(r.source()).append(") ");
-            sb.append(r.text()).append("\n");
-        }
-
-        sb.append(MEMORY_FOOTER);
-
-        log.debug("Implicit recall injected {} memories for '{}'",
-                results.size(), userMessage.substring(0, Math.min(50, userMessage.length())));
-
-        return sb.toString();
-    }
-
-    /**
-     * Enriches a prompt without an existing system message.
-     */
-    public String enrichPrompt(String userMessage) {
-        return enrichPrompt(userMessage, "");
-    }
-
-    /**
-     * Checks if any memories would be recalled for a given prompt.
-     * Useful for deciding whether to inject memory context.
-     */
-    public boolean hasRelevantMemories(String userMessage) {
-        if (userMessage == null || userMessage.isBlank()) return false;
-        return !memory.recall(userMessage,
-                RecallOptions.builder().topK(1).minImportance(minImportance).build()).isEmpty();
-    }
-}
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/neurodivergent/HyperfocusState.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/neurodivergent/HyperfocusState.java
deleted file mode 100644
index 7ad65f4..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/neurodivergent/HyperfocusState.java
+++ /dev/null
@@ -1,178 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.neurodivergent;
-
-import com.spectrayan.spector.memory.synapse.SynapticTagEncoder;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-/**
- * Manages hyperfocus state — zero-decay, strict tag gating, TTL with agent self-extension.
- *
- * <h3>Biological Analog: Monotropism &amp; Hyperfocus</h3>
- * <p>Monotropism is the tendency of neurodivergent minds to focus their attention on a
- * small number of interests with absolute, unrelenting depth. When in "Hyperfocus,"
- * the brain experiences <strong>Time Blindness</strong> — hours feel like minutes,
- * and the brain ignores all outside stimuli.</p>
- *
- * <h3>Effect on Scoring</h3>
- * <ul>
- *   <li>Phase 2: Strict tag equality gate — only memories matching ALL focus tags pass</li>
- *   <li>Phase 4: Decay clamped to 1.0 — time ceases to exist for focused-topic memories</li>
- *   <li>Phase 6: Post-score {@code hyperfocusBoost} multiplier applied</li>
- *   <li>Scoring weights: α=1.0, β=0.0 (pure similarity, no importance×decay)</li>
- * </ul>
- *
- * <h3>TTL &amp; Self-Extension</h3>
- * <p>Hyperfocus activates with a configurable TTL (default: 30 minutes). The agent
- * can self-extend via {@link #extend(long)} when deeply engaged. When the TTL
- * expires, the mask returns {@code 0L} and scoring reverts to normal.</p>
- *
- * <h3>Thread Safety</h3>
- * <p>Uses {@code volatile} fields for lock-free reads from the scoring hot loop.
- * Write operations (activate/extend/deactivate) are not synchronized — intended
- * for single-agent usage. Multi-agent setups should use external coordination.</p>
- */
-public final class HyperfocusState {
-
-    private static final Logger log = LoggerFactory.getLogger(HyperfocusState.class);
-
-    /** Default TTL: 30 minutes. */
-    public static final long DEFAULT_TTL_MS = 30 * 60 * 1000L;
-
-    private volatile long hyperfocusMask = 0L;
-    private volatile long expiresAtMs = 0L;
-    private final long defaultTtlMs;
-
-    /**
-     * Creates a hyperfocus state with a configurable default TTL.
-     *
-     * @param defaultTtlMs default time-to-live in milliseconds
-     */
-    public HyperfocusState(long defaultTtlMs) {
-        this.defaultTtlMs = defaultTtlMs;
-    }
-
-    /**
-     * Creates a hyperfocus state with the default TTL (30 minutes).
-     */
-    public HyperfocusState() {
-        this(DEFAULT_TTL_MS);
-    }
-
-    /**
-     * Activates hyperfocus on the given topic tags with a custom TTL.
-     *
-     * @param mask  Bloom filter mask encoding the focus topic tags
-     * @param ttlMs time-to-live in milliseconds for this hyperfocus session
-     */
-    public void activate(long mask, long ttlMs) {
-        this.hyperfocusMask = mask;
-        this.expiresAtMs = System.currentTimeMillis() + ttlMs;
-        log.info("Hyperfocus activated: mask=0x{}, TTL={}ms", Long.toHexString(mask), ttlMs);
-    }
-
-    /**
-     * Activates hyperfocus with the default TTL.
-     *
-     * @param mask Bloom filter mask encoding the focus topic tags
-     */
-    public void activate(long mask) {
-        activate(mask, defaultTtlMs);
-    }
-
-    /**
-     * Activates hyperfocus from string tags with a custom TTL.
-     *
-     * @param ttlMs time-to-live in milliseconds
-     * @param tags  focus topic tags to encode into a Bloom filter mask
-     */
-    public void activate(long ttlMs, String... tags) {
-        activate(SynapticTagEncoder.encode(tags), ttlMs);
-    }
-
-    /**
-     * Activates hyperfocus from string tags with the default TTL.
-     *
-     * @param tags focus topic tags to encode into a Bloom filter mask
-     */
-    public void activateFromTags(String... tags) {
-        activate(SynapticTagEncoder.encode(tags), defaultTtlMs);
-    }
-
-    /**
-     * Agent self-extends the current hyperfocus session.
-     *
-     * <p>Only effective if hyperfocus is currently active. Adds the specified
-     * duration to the current expiration time.</p>
-     *
-     * @param additionalMs additional time in milliseconds
-     */
-    public void extend(long additionalMs) {
-        if (isActive()) {
-            this.expiresAtMs += additionalMs;
-            log.info("Hyperfocus extended by {}ms, new expiry in {}ms",
-                     additionalMs, expiresAtMs - System.currentTimeMillis());
-        }
-    }
-
-    /**
-     * Extends hyperfocus by the default TTL duration.
-     */
-    public void extend() {
-        extend(defaultTtlMs);
-    }
-
-    /**
-     * Returns whether hyperfocus is currently active (mask != 0 and TTL not expired).
-     */
-    public boolean isActive() {
-        return hyperfocusMask != 0L && System.currentTimeMillis() < expiresAtMs;
-    }
-
-    /**
-     * Returns the current hyperfocus mask, or {@code 0L} if expired or inactive.
-     *
-     * <p>Called from the scoring hot loop — must be fast (volatile read).</p>
-     */
-    public long mask() {
-        return isActive() ? hyperfocusMask : 0L;
-    }
-
-    /**
-     * Returns the remaining time in milliseconds, or 0 if inactive.
-     */
-    public long remainingMs() {
-        if (!isActive()) return 0L;
-        return Math.max(0L, expiresAtMs - System.currentTimeMillis());
-    }
-
-    /**
-     * Deactivates hyperfocus immediately.
-     */
-    public void deactivate() {
-        long oldMask = this.hyperfocusMask;
-        this.hyperfocusMask = 0L;
-        this.expiresAtMs = 0L;
-        if (oldMask != 0L) {
-            log.info("Hyperfocus deactivated (was mask=0x{})", Long.toHexString(oldMask));
-        }
-    }
-
-    /**
-     * Returns the configured default TTL in milliseconds.
-     */
-    public long defaultTtlMs() {
-        return defaultTtlMs;
-    }
-}
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/neurodivergent/IcnuWeights.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/neurodivergent/IcnuWeights.java
deleted file mode 100644
index f933519..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/neurodivergent/IcnuWeights.java
+++ /dev/null
@@ -1,176 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.neurodivergent;
-
-/**
- * Configurable fusion weights for the ICNU importance formula with sigmoid gating.
- *
- * <h3>Formula (Sigmoid-Gated)</h3>
- * <pre>
- *   stimulus = w_I·(I×N) + w_C·C + w_U·U
- *   gated    = σ(k · (stimulus - θ))
- *   importance = clamp(MIN + gated × (MAX - MIN), 0.05, 10.0)
- * </pre>
- *
- * <p>The sigmoid gate creates a <b>hard threshold</b>: stimuli below θ produce
- * near-zero importance, while stimuli above θ quickly saturate. This prevents
- * low-relevance memories from accumulating in the store.</p>
- *
- * <h3>Biological Analog: Dopaminergic Gating</h3>
- * <p>In ADHD neurobiology, the dopamine system requires both interest AND novelty
- * to fire simultaneously. The multiplicative I×N interaction models this —
- * something interesting but familiar (low N) or novel but boring (low I) won't
- * cross the dopamine threshold. This is the engine of hyperfocus: only
- * sufficiently stimulating inputs get through.</p>
- *
- * <h3>Weight Invariant</h3>
- * <p>Weights are normalized to sum to 1.0 on construction. The stimulus function
- * uses the I×N multiplicative interaction (biologically correct) rather than
- * additive I + N (which allows low-stimulus pass-through).</p>
- *
- * @param interest   weight for LLM-provided interest signal
- * @param challenge  weight for LLM-provided challenge signal
- * @param novelty    weight for Spector-native novelty signal
- * @param urgency    weight for LLM-provided urgency signal
- * @param threshold  sigmoid threshold θ — stimuli below this produce near-zero importance
- * @param steepness  sigmoid steepness k — higher = sharper cutoff at threshold
- */
-public record IcnuWeights(float interest, float challenge, float novelty, float urgency,
-                           float threshold, float steepness) {
-
-    /** Minimum fused importance (prevents memories from being completely invisible). */
-    private static final float MIN_IMPORTANCE = 0.05f;
-
-    /** Maximum fused importance (caps extreme spikes). */
-    private static final float MAX_IMPORTANCE = 10.0f;
-
-    /** Default sigmoid threshold — stimuli below 0.2 are nearly invisible. */
-    private static final float DEFAULT_THRESHOLD = 0.2f;
-
-    /** Default sigmoid steepness — moderate cutoff sharpness. */
-    private static final float DEFAULT_STEEPNESS = 8.0f;
-
-    /**
-     * Default: novelty-dominant, interest is strongest LLM signal.
-     * Sigmoid threshold=0.2, steepness=8 (moderate gating).
-     *
-     * <p>Rationale:</p>
-     * <ul>
-     *   <li><b>Novelty (0.4)</b>: Strongest — objectively measurable, model-agnostic, impossible to game</li>
-     *   <li><b>Interest (0.3)</b>: Second — the LLM knows what it's working on</li>
-     *   <li><b>Urgency (0.2)</b>: Third — temporal priority matters but is often over-reported</li>
-     *   <li><b>Challenge (0.1)</b>: Lowest — hardest for the LLM to assess honestly</li>
-     * </ul>
-     */
-    public static final IcnuWeights DEFAULT = new IcnuWeights(0.30f, 0.10f, 0.40f, 0.20f,
-            DEFAULT_THRESHOLD, DEFAULT_STEEPNESS);
-
-    /**
-     * Novelty-only mode — used when no LLM hints are provided (backward compatible).
-     */
-    public static final IcnuWeights NOVELTY_ONLY = new IcnuWeights(0f, 0f, 1.0f, 0f,
-            DEFAULT_THRESHOLD, DEFAULT_STEEPNESS);
-
-    /**
-     * Linear mode — no sigmoid gating (backward compatible with pre-sigmoid behavior).
-     * Uses steepness=0 to disable the sigmoid, falling back to linear fusion.
-     */
-    public static final IcnuWeights LINEAR = new IcnuWeights(0.30f, 0.10f, 0.40f, 0.20f,
-            0f, 0f);
-
-    /**
-     * Backward-compatible constructor — uses default threshold and steepness.
-     */
-    public IcnuWeights(float interest, float challenge, float novelty, float urgency) {
-        this(interest, challenge, novelty, urgency, DEFAULT_THRESHOLD, DEFAULT_STEEPNESS);
-    }
-
-    /**
-     * Compact constructor — normalizes weights to sum to 1.0.
-     */
-    public IcnuWeights {
-        float sum = interest + challenge + novelty + urgency;
-        if (sum > 0f && Math.abs(sum - 1.0f) > 0.001f) {
-            interest /= sum;
-            challenge /= sum;
-            novelty /= sum;
-            urgency /= sum;
-        }
-    }
-
-    /**
-     * Computes the fused importance score from ICNU signals using sigmoid gating.
-     *
-     * <h3>Sigmoid Mode (steepness &gt; 0)</h3>
-     * <pre>
-     *   stimulus = w_I·(I×N) + w_C·C + w_U·U
-     *   gated    = 1 / (1 + exp(-k · (stimulus - θ)))
-     *   result   = MIN + gated × (MAX - MIN)
-     * </pre>
-     *
-     * <p>The I×N multiplicative interaction is biologically correct: in ADHD,
-     * interest AND novelty must both be high for dopamine release. If something
-     * is interesting but familiar (low N), or novel but boring (low I), it
-     * doesn't cross the threshold.</p>
-     *
-     * <h3>Linear Mode (steepness = 0)</h3>
-     * <p>Falls back to the original linear fusion for backward compatibility.</p>
-     *
-     * @param interestVal   LLM-provided interest (0.0–1.0)
-     * @param challengeVal  LLM-provided challenge (0.0–1.0)
-     * @param noveltyNorm   Spector-computed novelty, normalized to 0.0–1.0
-     * @param urgencyVal    LLM-provided urgency (0.0–1.0)
-     * @return fused importance clamped to [0.05, 10.0]
-     */
-    public float fuse(float interestVal, float challengeVal,
-                       float noveltyNorm, float urgencyVal) {
-        if (steepness <= 0f) {
-            // Linear fallback (pre-sigmoid behavior)
-            float raw = interest * interestVal
-                       + challenge * challengeVal
-                       + novelty * noveltyNorm
-                       + urgency * urgencyVal;
-            float scaled = MIN_IMPORTANCE + raw * (MAX_IMPORTANCE - MIN_IMPORTANCE);
-            return Math.clamp(scaled, MIN_IMPORTANCE, MAX_IMPORTANCE);
-        }
-
-        // Sigmoid-gated fusion with I×N multiplicative interaction
-        // Interest and novelty must BOTH be high (dopaminergic gating)
-        float stimulus = interest * (interestVal * noveltyNorm)
-                       + challenge * challengeVal
-                       + urgency * urgencyVal;
-
-        // Sigmoid: σ(k · (stimulus - θ))
-        float gated = 1.0f / (1.0f + (float) Math.exp(-steepness * (stimulus - threshold)));
-
-        // Scale to importance range
-        float scaled = MIN_IMPORTANCE + gated * (MAX_IMPORTANCE - MIN_IMPORTANCE);
-        return Math.clamp(scaled, MIN_IMPORTANCE, MAX_IMPORTANCE);
-    }
-
-    /**
-     * Fuses importance using {@link IngestionHints} and a normalized novelty score.
-     *
-     * <p>If hints are empty, falls back to novelty-only weighting.</p>
-     *
-     * @param hints       LLM-provided hints (may be {@link IngestionHints#NONE})
-     * @param noveltyNorm normalized novelty score (0.0–1.0)
-     * @return fused importance
-     */
-    public float fuse(IngestionHints hints, float noveltyNorm) {
-        if (hints == null || hints.isEmpty()) {
-            return NOVELTY_ONLY.fuse(0f, 0f, noveltyNorm, 0f);
-        }
-        return fuse(hints.interest(), hints.challenge(), noveltyNorm, hints.urgency());
-    }
-}
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/neurodivergent/IngestionHints.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/neurodivergent/IngestionHints.java
deleted file mode 100644
index 2d665cd..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/neurodivergent/IngestionHints.java
+++ /dev/null
@@ -1,116 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.neurodivergent;
-
-/**
- * Optional LLM-provided cognitive hints for ingestion-time importance tuning.
- *
- * <h3>Biological Analog: ICNU (Interest-Challenge-Novelty-Urgency)</h3>
- * <p>The ADHD brain processes motivation not by priority or rules, but by
- * <strong>Interest, Challenge, Novelty, and Urgency</strong>. These hints allow
- * the LLM to provide the subjective signals (I, C, U) while Spector computes
- * the objective signal (N = novelty via L2 distance) natively.</p>
- *
- * <h3>Valence &amp; Arousal</h3>
- * <p>Optionally, the LLM can provide emotional valence (negative↔positive)
- * and arousal (calm→intense). If not provided, both default to 0 (neutral).
- * When valence is provided but arousal is not, arousal is automatically derived
- * from the absolute value of valence at ingestion time.</p>
- *
- * <h3>Usage</h3>
- * <p>Provided as part of the {@code remember()} call:</p>
- * <pre>{@code
- *   memory.remember("mem-123", "The deadlock was caused by...",
- *       MemoryType.EPISODIC, MemorySource.OBSERVED,
- *       new IngestionHints(0.8f, 0.6f, 0.3f),  // I=0.8, C=0.6, U=0.3
- *       "database", "deadlock");
- *
- *   // With emotional context:
- *   memory.remember("mem-456", "Critical production outage!",
- *       MemoryType.EPISODIC, MemorySource.OBSERVED,
- *       new IngestionHints(1.0f, 0.9f, 1.0f, (byte) -100, (byte) 200),
- *       "incident", "outage");
- * }</pre>
- *
- * <h3>Clamping</h3>
- * <p>ICNU values are clamped to {@code [0.0, 1.0]} on construction to prevent
- * gaming via out-of-range values. Valence is signed byte (-128 to 127).
- * Arousal is unsigned byte (0 to 255, stored as signed Java byte).</p>
- *
- * @param interest  how relevant this memory is to the agent's current task (0.0–1.0)
- * @param challenge how complex or difficult the problem is (0.0–1.0)
- * @param urgency   how time-critical this information is (0.0–1.0)
- * @param valence   emotional valence: -128 (extremely negative) to +127 (extremely positive), 0 = neutral
- * @param arousal   emotional intensity: 0 (calm) to 255 (extreme), stored as unsigned byte. 0 = neutral
- */
-public record IngestionHints(float interest, float challenge, float urgency,
-                              byte valence, byte arousal) {
-
-    /**
-     * Compact constructor — clamps ICNU values to [0.0, 1.0].
-     */
-    public IngestionHints {
-        interest = Math.clamp(interest, 0f, 1f);
-        challenge = Math.clamp(challenge, 0f, 1f);
-        urgency = Math.clamp(urgency, 0f, 1f);
-    }
-
-    /**
-     * ICNU-only constructor — no emotional context (valence=0, arousal=0).
-     */
-    public IngestionHints(float interest, float challenge, float urgency) {
-        this(interest, challenge, urgency, (byte) 0, (byte) 0);
-    }
-
-    /** Empty hints — triggers novelty-only importance computation. */
-    public static final IngestionHints NONE = new IngestionHints(0f, 0f, 0f);
-
-    /**
-     * Returns true if no hints were actually provided.
-     * When empty, the ingestion pipeline falls back to novelty-only importance.
-     */
-    public boolean isEmpty() {
-        return interest == 0f && challenge == 0f && urgency == 0f;
-    }
-
-    /**
-     * Returns true if valence or arousal have been set.
-     */
-    public boolean hasEmotionalContext() {
-        return valence != 0 || arousal != 0;
-    }
-
-    /**
-     * Derives arousal from valence if arousal was not explicitly set.
-     *
-     * <p>Biological basis: emotional intensity (arousal) correlates with
-     * the absolute magnitude of valence. A memory that's extremely negative
-     * (-100) or extremely positive (+100) is equally arousing.</p>
-     *
-     * <p>The mapping: {@code arousal = |valence| * 2}, clamped to [0, 255].</p>
-     *
-     * @return the effective arousal byte (unsigned 0-255)
-     */
-    public byte effectiveArousal() {
-        if (Byte.toUnsignedInt(arousal) > 0) {
-            return arousal;  // explicitly set, use as-is
-        }
-        if (valence == 0) {
-            return 0;  // neutral valence → neutral arousal
-        }
-        // Derive from |valence|: range [-128, 127] → |val| = [0, 128] → ×2 = [0, 256] → clamp
-        int absValence = Math.abs((int) valence);
-        int derived = Math.min(255, absValence * 2);
-        return (byte) derived;
-    }
-}
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/neurodivergent/LateralEvaluator.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/neurodivergent/LateralEvaluator.java
deleted file mode 100644
index e9b85bc..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/neurodivergent/LateralEvaluator.java
+++ /dev/null
@@ -1,220 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.neurodivergent;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.concurrent.atomic.AtomicInteger;
-import java.util.concurrent.atomic.AtomicReference;
-
-/**
- * Lateral retrieval evaluation engine — measures utility, suppression, and
- * hallucination rates for neurodivergent lateral/orthogonal retrieval.
- *
- * <h3>Biological Analog: Reduced Latent Inhibition Feedback</h3>
- * <p>The ADHD brain's reduced latent inhibition produces lateral associations
- * (cross-domain leaps). Some are brilliant insights; others are noise. This
- * evaluator tracks which lateral results the agent actually uses vs rejects,
- * providing the feedback loop to auto-tune lateral retrieval aggressiveness.</p>
- *
- * <h3>Metrics</h3>
- * <ul>
- *   <li><b>LUR (Lateral Utility Rate)</b>: reinforced / returned — "are lateral results useful?"</li>
- *   <li><b>LSR (Lateral Suppression Rate)</b>: suppressed / returned — "are lateral results rejected?"</li>
- *   <li><b>LHI (Lateral Hallucination Index)</b>: (1-LUR) × LSR — composite safety metric</li>
- * </ul>
- *
- * <h3>Auto-Tuning</h3>
- * <p>Every {@link #evaluationWindow} lateral results, the evaluator checks LUR:</p>
- * <ul>
- *   <li>LUR &lt; 0.05 → auto-disable lateral mode + WARN log</li>
- *   <li>LUR &lt; 0.10 → tighten distance threshold by 10%</li>
- *   <li>LUR &gt; 0.10 → keep current thresholds</li>
- * </ul>
- *
- * <h3>Thread Safety</h3>
- * <p>Fully concurrent via {@link AtomicInteger} counters.</p>
- */
-public final class LateralEvaluator {
-
-    private static final Logger log = LoggerFactory.getLogger(LateralEvaluator.class);
-
-    private final AtomicInteger lateralReturned = new AtomicInteger();
-    private final AtomicInteger lateralReinforced = new AtomicInteger();
-    private final AtomicInteger lateralSuppressed = new AtomicInteger();
-
-    /** Whether lateral mode is currently enabled (can be auto-disabled). */
-    private final AtomicBoolean lateralEnabled = new AtomicBoolean(true);
-
-    /** Current lateral distance threshold (can be auto-tightened). */
-    private final AtomicReference<Float> lateralDistanceThreshold;
-
-    /** Number of lateral results per evaluation window. */
-    private final int evaluationWindow;
-
-    /** LUR threshold below which lateral mode is auto-disabled. */
-    private static final float AUTO_DISABLE_LUR = 0.05f;
-
-    /** LUR threshold below which the distance threshold is tightened. */
-    private static final float TIGHTEN_LUR = 0.10f;
-
-    /** Factor by which to tighten the distance threshold. */
-    private static final float TIGHTEN_FACTOR = 1.1f;
-
-    /**
-     * Creates a lateral evaluator.
-     *
-     * @param initialDistanceThreshold starting lateral distance threshold (e.g., 1.2)
-     * @param evaluationWindow         number of lateral results per evaluation cycle (default: 100)
-     */
-    public LateralEvaluator(float initialDistanceThreshold, int evaluationWindow) {
-        this.lateralDistanceThreshold = new AtomicReference<>(initialDistanceThreshold);
-        this.evaluationWindow = evaluationWindow;
-    }
-
-    /**
-     * Creates a lateral evaluator with default evaluation window (100).
-     */
-    public LateralEvaluator(float initialDistanceThreshold) {
-        this(initialDistanceThreshold, 100);
-    }
-
-    /**
-     * Creates a lateral evaluator with all defaults (threshold=1.2, window=100).
-     */
-    public LateralEvaluator() {
-        this(1.2f, 100);
-    }
-
-    /**
-     * Records that a lateral result was returned to the agent.
-     * Called by the recall pipeline when a result has {@code retrievalMode == LATERAL}.
-     */
-    public void recordLateralReturn() {
-        lateralReturned.incrementAndGet();
-    }
-
-    /**
-     * Records that the agent reinforced a lateral result (found it useful).
-     * Called by {@code SpectorMemory.reinforce()} when the reinforced memory
-     * was originally retrieved via lateral mode.
-     */
-    public void recordLateralReinforcement() {
-        lateralReinforced.incrementAndGet();
-        checkAndTune();
-    }
-
-    /**
-     * Records that the agent suppressed a lateral result (rejected it as noise).
-     * Called by {@code SpectorMemory.suppress()} when the suppressed memory
-     * was originally retrieved via lateral mode.
-     */
-    public void recordLateralSuppression() {
-        lateralSuppressed.incrementAndGet();
-        checkAndTune();
-    }
-
-    /**
-     * Checks if the evaluation window is complete and auto-tunes if needed.
-     */
-    private void checkAndTune() {
-        int returned = lateralReturned.get();
-        if (returned < evaluationWindow) return;
-
-        float lur = (float) lateralReinforced.get() / returned;
-        float lsr = (float) lateralSuppressed.get() / returned;
-        float lhi = (1.0f - lur) * lsr;
-
-        if (lur < AUTO_DISABLE_LUR) {
-            log.warn("Lateral auto-disable: LUR={}, LSR={}, LHI={} over {} results — " +
-                     "lateral retrieval producing noise", lur, lsr, lhi, returned);
-            lateralEnabled.set(false);
-        } else if (lur < TIGHTEN_LUR) {
-            float oldThreshold = lateralDistanceThreshold.get();
-            float newThreshold = oldThreshold * TIGHTEN_FACTOR;
-            lateralDistanceThreshold.set(newThreshold);
-            log.info("Lateral threshold tightened: LUR={}, threshold {} → {}",
-                     lur, oldThreshold, newThreshold);
-        } else {
-            log.debug("Lateral evaluation: LUR={}, LSR={}, LHI={} — healthy",
-                      lur, lsr, lhi);
-        }
-
-        // Reset window
-        lateralReturned.set(0);
-        lateralReinforced.set(0);
-        lateralSuppressed.set(0);
-    }
-
-    /**
-     * Returns whether lateral mode is currently enabled.
-     * Auto-disabled when LUR drops below 5%.
-     */
-    public boolean isLateralEnabled() {
-        return lateralEnabled.get();
-    }
-
-    /**
-     * Re-enables lateral mode (after auto-disable, or for manual override).
-     */
-    public void enableLateral() {
-        lateralEnabled.set(true);
-        log.info("Lateral mode re-enabled manually");
-    }
-
-    /**
-     * Returns the current (possibly auto-tuned) lateral distance threshold.
-     */
-    public float currentDistanceThreshold() {
-        return lateralDistanceThreshold.get();
-    }
-
-    /**
-     * Returns a snapshot of the current lateral evaluation metrics.
-     */
-    public LateralMetrics metrics() {
-        int returned = lateralReturned.get();
-        if (returned == 0) return LateralMetrics.EMPTY;
-
-        float lur = (float) lateralReinforced.get() / returned;
-        float lsr = (float) lateralSuppressed.get() / returned;
-        float lhi = (1.0f - lur) * lsr;
-        return new LateralMetrics(lur, lsr, lhi, returned);
-    }
-
-    /**
-     * Resets all counters and re-enables lateral mode.
-     */
-    public void reset() {
-        lateralReturned.set(0);
-        lateralReinforced.set(0);
-        lateralSuppressed.set(0);
-        lateralEnabled.set(true);
-    }
-
-    /**
-     * Snapshot of lateral evaluation metrics.
-     *
-     * @param utilityRate        fraction of lateral results reinforced by the agent
-     * @param suppressionRate    fraction of lateral results suppressed by the agent
-     * @param hallucinationIndex composite safety metric: (1-LUR) × LSR
-     * @param sampleSize         number of lateral results in this evaluation window
-     */
-    public record LateralMetrics(float utilityRate, float suppressionRate,
-                                  float hallucinationIndex, int sampleSize) {
-        /** Empty metrics — no lateral results have been returned yet. */
-        public static final LateralMetrics EMPTY = new LateralMetrics(0f, 0f, 0f, 0);
-    }
-}
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/neurodivergent/package-info.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/neurodivergent/package-info.java
deleted file mode 100644
index 1f62bb8..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/neurodivergent/package-info.java
+++ /dev/null
@@ -1,39 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-/**
- * Neurodivergent cognitive profile support — configurable mechanics for
- * divergent thinking, hyperfocus, and systematizing behavior in AI agents.
- *
- * <h3>Overview</h3>
- * <p>This package implements four biologically-inspired cognitive mechanics:</p>
- * <ol>
- *   <li><b>Hyperfocus</b> ({@link com.spectrayan.spector.memory.neurodivergent.HyperfocusState})
- *       — zero time decay, strict tag gating, TTL with agent self-extension</li>
- *   <li><b>ICNU Fusion</b> ({@link com.spectrayan.spector.memory.neurodivergent.IcnuWeights},
- *       {@link com.spectrayan.spector.memory.neurodivergent.IngestionHints})
- *       — Interest/Challenge/Novelty/Urgency importance computation</li>
- *   <li><b>Lateral Evaluation</b> ({@link com.spectrayan.spector.memory.neurodivergent.LateralEvaluator})
- *       — tracks utility, suppression, and hallucination rates for orthogonal retrieval</li>
- *   <li><b>Lossless Consolidation</b> — pin bit toggle during REM sleep (in ReflectDaemon)</li>
- * </ol>
- *
- * <h3>Design Philosophy</h3>
- * <p>Neurodivergence is not a deficit — it is an alternative optimization strategy.
- * Neurotypical brains optimize for energy efficiency and routine predictability.
- * Neurodivergent brains optimize for lateral synthesis, deep systematizing,
- * novelty-seeking, and hyperfocus — the exact cognitive profile required for
- * groundbreaking discovery and out-of-the-box engineering.</p>
- *
- * @see com.spectrayan.spector.memory.CognitiveProfile
- */
-package com.spectrayan.spector.memory.neurodivergent;
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/package-info.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/package-info.java
deleted file mode 100644
index 3cb040f..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/package-info.java
+++ /dev/null
@@ -1,42 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-/**
- * Spector Memory — Biologically-Inspired Cognitive Memory for Autonomous AI Agents.
- *
- * <p>16 neuroscience mechanisms running natively on Java Panama — from dopamine-driven
- * surprise detection to hippocampal sleep consolidation — with zero-GC, SIMD-accelerated
- * off-heap storage.</p>
- *
- * <h3>Biological Package Structure</h3>
- * <ul>
- *   <li>{@code cortex/} — Memory tiers (Working, Episodic, Semantic, Procedural) + source monitoring</li>
- *   <li>{@code synapse/} — 32-byte header layout, fused SIMD scoring, Bloom filter tags, bucket decay</li>
- *   <li>{@code dopamine/} — Adaptive surprise detection (z-score importance assignment)</li>
- *   <li>{@code amygdala/} — Emotional valence and outcome-driven reinforcement (V2)</li>
- *   <li>{@code hippocampus/} — REM/Deep Sleep consolidation daemon</li>
- *   <li>{@code hebbian/} — Spreading activation and co-occurrence tracking (V2)</li>
- *   <li>{@code interference/} — Semantic deduplication with merge-on-ingest</li>
- *   <li>{@code inhibition/} — Session-level recall suppression (V2)</li>
- *   <li>{@code habituation/} — Anti-filter-bubble result diversity (V3)</li>
- *   <li>{@code prospective/} — Time-triggered future recall (V3)</li>
- *   <li>{@code metamemory/} — Memory introspection and self-awareness (V2)</li>
- *   <li>{@code sync/} — WAL-based CloudSync for distributed memory (V2)</li>
- * </ul>
- *
- * <h3>Entry Point</h3>
- * <p>Use {@link com.spectrayan.spector.memory.SpectorMemory#builder()} to construct
- * a memory instance with your {@link com.spectrayan.spector.embed.EmbeddingProvider}.</p>
- *
- * @see com.spectrayan.spector.memory.SpectorMemory
- */
-package com.spectrayan.spector.memory;
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/pipeline/CognitiveIngestionTarget.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/pipeline/CognitiveIngestionTarget.java
deleted file mode 100644
index 44c6fb7..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/pipeline/CognitiveIngestionTarget.java
+++ /dev/null
@@ -1,377 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.pipeline;
-
-import com.spectrayan.spector.core.quantization.ScalarQuantizer;
-import com.spectrayan.spector.index.VectorIndex;
-import com.spectrayan.spector.ingestion.IngestionTarget;
-import com.spectrayan.spector.memory.MemoryType;
-import com.spectrayan.spector.memory.cortex.MemorySource;
-import com.spectrayan.spector.memory.cortex.TierRouter;
-import com.spectrayan.spector.memory.cortex.WorkingMemoryStore;
-import com.spectrayan.spector.memory.dopamine.FlashbulbPolicy;
-import com.spectrayan.spector.memory.dopamine.SurpriseDetector;
-import com.spectrayan.spector.memory.graph.EntityExtractor;
-import com.spectrayan.spector.memory.graph.EntityGraph;
-import com.spectrayan.spector.memory.graph.EntityRelation;
-import com.spectrayan.spector.memory.graph.ExtractedEntity;
-import com.spectrayan.spector.memory.hebbian.HebbianGraph;
-import com.spectrayan.spector.memory.index.MemoryIndex;
-import com.spectrayan.spector.memory.index.MemoryIndex.MemoryLocation;
-import com.spectrayan.spector.memory.neurodivergent.IcnuWeights;
-import com.spectrayan.spector.memory.neurodivergent.IngestionHints;
-import com.spectrayan.spector.memory.sync.MemoryWal;
-import com.spectrayan.spector.memory.synapse.CognitiveRecordLayout.CognitiveHeader;
-import com.spectrayan.spector.memory.synapse.SynapticHeaderConstants;
-import com.spectrayan.spector.memory.synapse.SynapticTagEncoder;
-import com.spectrayan.spector.memory.temporal.TemporalChain;
-import com.spectrayan.spector.storage.VectorStore;
-
-import com.spectrayan.spector.memory.error.SpectorEntityGraphException;
-import com.spectrayan.spector.memory.error.SpectorHebbianException;
-import com.spectrayan.spector.memory.error.SpectorTemporalChainException;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.util.List;
-import java.util.concurrent.atomic.AtomicInteger;
-
-/**
- * Cognitive memory implementation of {@link IngestionTarget}.
- *
- * <p>Receives pre-embedded chunks from the unified {@link com.spectrayan.spector.ingestion.IngestionPipeline}
- * and performs the cognitive processing pipeline (steps 2–9):</p>
- *
- * <pre>
- *   Step  1b: Auto-extract synaptic tags (via pluggable {@link TagExtractor})
- *   Step  2: Encode synaptic tags → 64-bit Bloom filter
- *   Step  3: Compute surprise → auto-set importance (Dopamine engine)
- *   Step 3b: ICNU fusion — blend LLM hints (I/C/U) with native novelty (N)
- *   Step  4: Flashbulb check — extreme surprise gets full fidelity
- *   Step  5: Quantize vector to INT8 via calibrated ScalarQuantizer
- *   Step  6: Build cognitive header
- *   Step  7: Route to tier store and write
- *   Step 7b: Add to HNSW index (SEMANTIC type only)
- *   Step  8: Register in ID index
- *   Step  9: WAL append
- *   Step 9b: Hebbian edge strengthening (co-ingestion within session)
- *   Step 9c: Temporal chain linking (session-local sequence)
- *   Step 9d: Entity extraction and graph population
- * </pre>
- *
- * <h3>Two Entry Points</h3>
- * <ul>
- *   <li>{@link #ingest(String, String, float[])} — from unified pipeline (bulk, auto-extracts tags)</li>
- *   <li>{@link #ingestCognitive} — from {@code SpectorMemory.remember()} (full cognitive params)</li>
- * </ul>
- *
- * <h3>Thread Safety</h3>
- * <p>Stateless except for the subsystems it references (all thread-safe).
- * Multiple Virtual Threads can call {@link #ingest} concurrently.</p>
- */
-public final class CognitiveIngestionTarget implements IngestionTarget {
-
-    private static final Logger log = LoggerFactory.getLogger(CognitiveIngestionTarget.class);
-
-    private final ScalarQuantizer quantizer;
-    private final SurpriseDetector surpriseDetector;
-    private final FlashbulbPolicy flashbulbPolicy;
-    private final TierRouter tierRouter;
-    private final MemoryIndex index;
-    private final MemoryWal wal;
-    private final WorkingMemoryStore workingStore;  // nullable
-    private final IcnuWeights icnuWeights;
-    private final VectorIndex semanticIndex;  // nullable — shared HNSW for semantic recall
-    private final VectorStore vectorStore;    // nullable — engine's off-heap vector storage
-    private final TagExtractor tagExtractor;
-    private final boolean normalizeAtIngest;
-
-    // ── Graph components (all nullable — graceful degradation) ──
-    private final HebbianGraph hebbianGraph;
-    private final TemporalChain temporalChain;
-    private final EntityExtractor entityExtractor;
-    private final EntityGraph entityGraph;
-
-    // ── Session tracking for Hebbian co-ingestion and temporal chains ──
-    private final AtomicInteger lastIngestedMemoryIdx = new AtomicInteger(-1);
-    private volatile int currentSessionId = 0;
-
-    public CognitiveIngestionTarget(ScalarQuantizer quantizer,
-                                     SurpriseDetector surpriseDetector,
-                                     FlashbulbPolicy flashbulbPolicy,
-                                     TierRouter tierRouter,
-                                     MemoryIndex index,
-                                     MemoryWal wal,
-                                     WorkingMemoryStore workingStore,
-                                     IcnuWeights icnuWeights,
-                                     VectorIndex semanticIndex,
-                                     VectorStore vectorStore,
-                                     TagExtractor tagExtractor,
-                                     boolean normalizeAtIngest,
-                                     HebbianGraph hebbianGraph,
-                                     TemporalChain temporalChain,
-                                     EntityExtractor entityExtractor,
-                                     EntityGraph entityGraph) {
-        this.quantizer = quantizer;
-        this.surpriseDetector = surpriseDetector;
-        this.flashbulbPolicy = flashbulbPolicy;
-        this.tierRouter = tierRouter;
-        this.index = index;
-        this.wal = wal;
-        this.workingStore = workingStore;
-        this.icnuWeights = icnuWeights != null ? icnuWeights : IcnuWeights.DEFAULT;
-        this.semanticIndex = semanticIndex;
-        this.vectorStore = vectorStore;
-        this.tagExtractor = tagExtractor != null ? tagExtractor : new ContentTagExtractor();
-        this.normalizeAtIngest = normalizeAtIngest;
-        this.hebbianGraph = hebbianGraph;
-        this.temporalChain = temporalChain;
-        this.entityExtractor = entityExtractor;
-        this.entityGraph = entityGraph;
-    }
-
-    /**
-     * Legacy constructor — defaults normalizeAtIngest to {@code true}, no graph components.
-     */
-    public CognitiveIngestionTarget(ScalarQuantizer quantizer,
-                                     SurpriseDetector surpriseDetector,
-                                     FlashbulbPolicy flashbulbPolicy,
-                                     TierRouter tierRouter,
-                                     MemoryIndex index,
-                                     MemoryWal wal,
-                                     WorkingMemoryStore workingStore,
-                                     IcnuWeights icnuWeights,
-                                     VectorIndex semanticIndex,
-                                     VectorStore vectorStore,
-                                     TagExtractor tagExtractor) {
-        this(quantizer, surpriseDetector, flashbulbPolicy, tierRouter,
-                index, wal, workingStore, icnuWeights, semanticIndex,
-                vectorStore, tagExtractor, true,
-                null, null, null, null);
-    }
-
-    // ═══════════════════════════════════════════════════════════════
-    // IngestionTarget — from unified pipeline (bulk ingestion)
-    // ═══════════════════════════════════════════════════════════════
-
-    /**
-     * Ingests a pre-embedded chunk using SEMANTIC defaults.
-     *
-     * <p>Called by the unified IngestionPipeline during bulk file ingestion.
-     * Auto-extracts synaptic tags via the configured {@link TagExtractor},
-     * uses {@code MemoryType.SEMANTIC} and {@code MemorySource.OBSERVED}.</p>
-     */
-    @Override
-    public void ingest(String id, String text, float[] vector) {
-        // Step 1b: Auto-extract synaptic tags from document ID and content
-        String[] tags = tagExtractor.extract(id, text);
-        ingestCognitive(id, text, vector, MemoryType.SEMANTIC,
-                tags, MemorySource.OBSERVED, null);
-    }
-
-    // ═══════════════════════════════════════════════════════════════
-    // Full cognitive entry point — from SpectorMemory.remember()
-    // ═══════════════════════════════════════════════════════════════
-
-    /**
-     * Full cognitive ingestion with all parameters.
-     *
-     * <p>Called by {@code SpectorMemory.remember()} with type, tags, source,
-     * and optional ICNU hints from LLM assessment.</p>
-     *
-     * @param id     unique memory identifier
-     * @param text   the memory content
-     * @param vector pre-computed embedding vector
-     * @param type   cognitive memory tier
-     * @param tags   synaptic tag strings
-     * @param source provenance source
-     * @param hints  optional LLM-provided ICNU hints (null = novelty-only)
-     */
-    public void ingestCognitive(String id, String text, float[] vector,
-                                 MemoryType type, String[] tags,
-                                 MemorySource source, IngestionHints hints) {
-        // Step 2: Encode synaptic tags
-        long synapticTags = SynapticTagEncoder.encode(tags);
-
-        // Step 1c: L2-normalize vector (required for Parabolic RBF lateral scoring)
-        if (normalizeAtIngest) {
-            vector = l2Normalize(vector);
-        }
-
-        // Step 5 (early): Quantize vector to INT8 — needed for WM distance scan
-        byte[] quantized = quantizer.encode(vector);
-
-        // Step 3: Compute surprise → auto-set importance (Dopamine engine)
-        float nearestDist;
-        if (workingStore != null && workingStore.count() > 0) {
-            nearestDist = workingStore.nearestDistance(
-                    vector, quantizer.mins(), quantizer.scales());
-        } else {
-            nearestDist = computeL2Norm(vector);
-        }
-
-        float importance;
-        // Step 3b: ICNU fusion — blend LLM hints with native novelty
-        if (hints != null && !hints.isEmpty()) {
-            float rawNoveltyImportance = surpriseDetector.computeImportance(nearestDist);
-            float noveltyNorm = Math.clamp(rawNoveltyImportance / 10.0f, 0f, 1f);
-            importance = icnuWeights.fuse(hints, noveltyNorm);
-
-            // Gaming detection logging
-            if (hints.interest() == 1.0f && hints.challenge() == 1.0f
-                    && hints.urgency() == 1.0f) {
-                log.warn("ICNU anomaly: all-max hints for '{}' (I=1.0, C=1.0, U=1.0) — possible gaming", id);
-            }
-
-            log.debug("ICNU: id={}, I={}, C={}, N={}, U={}, fused={}",
-                    id, hints.interest(), hints.challenge(), noveltyNorm,
-                    hints.urgency(), importance);
-        } else {
-            importance = surpriseDetector.computeImportance(nearestDist);
-        }
-
-        // Step 4: Flashbulb check — extreme surprise gets full fidelity
-        double zScore = surpriseDetector.stats().zScore(nearestDist);
-        var flashbulb = flashbulbPolicy.evaluate(zScore);
-        byte flags = SynapticHeaderConstants.withMemoryType((byte) 0, type.ordinal());
-        if (flashbulb.isFlashbulb()) {
-            importance = flashbulb.importance();
-            flags = (byte) (flags | SynapticHeaderConstants.FLAG_PINNED);
-        }
-
-        // Step 6: Build cognitive header (with emotional context from hints)
-        float l2Norm = computeL2Norm(vector);
-        byte valence = (hints != null) ? hints.valence() : (byte) 0;
-        byte arousal = (hints != null) ? hints.effectiveArousal() : (byte) 0;
-        CognitiveHeader header = new CognitiveHeader(
-                System.currentTimeMillis(), synapticTags, l2Norm, importance,
-                0, (short) 0, valence, flags, arousal, 1.0f);
-
-        // Step 7: Route to tier store and write
-        long offset = tierRouter.write(type, header, quantized);
-
-        // Step 7b: Add to shared HNSW index for semantic recall.
-        // The HNSW is store-backed — must populate the engine's VectorStore first
-        // so the HNSW can read vectors during graph construction and persistence.
-        int storeIndex = -1;
-        if (type == MemoryType.SEMANTIC && semanticIndex != null
-                && !semanticIndex.isReadOnly()) {
-            // Put vector in engine's VectorStore (returns the store index)
-            if (vectorStore != null) {
-                storeIndex = vectorStore.put(id, vector);
-            } else {
-                storeIndex = tierRouter.semantic().size() - 1;
-            }
-            semanticIndex.add(id, storeIndex, vector);
-        }
-
-        // Step 8: Register in ID index
-        index.register(id, new MemoryLocation(type, offset, storeIndex), text, source, tags);
-
-        // Step 9: WAL append
-        wal.appendRemember(id, quantized);
-
-        // Step 9b: Hebbian edge strengthening (co-ingestion within session)
-        int memoryIdx = index.size() - 1; // approximate index of this memory
-        if (hebbianGraph != null) {
-            try {
-                // Check session boundary
-                if (hebbianGraph.isNewSession()) {
-                    currentSessionId++;
-                    lastIngestedMemoryIdx.set(-1);
-                }
-
-                int lastIdx = lastIngestedMemoryIdx.getAndSet(memoryIdx);
-                if (lastIdx >= 0 && lastIdx != memoryIdx) {
-                    hebbianGraph.strengthen(memoryIdx, lastIdx, 1.0f);
-                }
-            } catch (RuntimeException e) {
-                SpectorHebbianException ex = new SpectorHebbianException("edge strengthening", e);
-                log.warn(ex.getMessage());
-            }
-        }
-
-        // Step 9c: Temporal chain linking (session-local sequence)
-        if (temporalChain != null) {
-            try {
-                int lastIdx = lastIngestedMemoryIdx.get() == memoryIdx
-                        ? -1 : lastIngestedMemoryIdx.get();
-                // Use the previous memory index from the same session
-                if (lastIdx >= 0) {
-                    temporalChain.link(memoryIdx, lastIdx, currentSessionId);
-                }
-            } catch (RuntimeException e) {
-                SpectorTemporalChainException ex = new SpectorTemporalChainException("linking", e);
-                log.warn(ex.getMessage());
-            }
-        }
-
-        // Step 9d: Entity extraction and graph population
-        if (entityExtractor != null && entityGraph != null && entityExtractor.isAvailable()) {
-            try {
-                List<ExtractedEntity> entities = entityExtractor.extract(id, text);
-                for (ExtractedEntity entity : entities) {
-                    int eid = entityGraph.addEntity(entity.name(), entity.type());
-                    if (eid >= 0) {
-                        entityGraph.linkEntityToMemory(eid, memoryIdx);
-
-                        // Add relations
-                        for (EntityRelation rel : entity.relations()) {
-                            int targetEid = entityGraph.findEntity(rel.targetEntityName());
-                            if (targetEid < 0) {
-                                // Target not yet in graph — add it as OTHER
-                                targetEid = entityGraph.addEntity(
-                                        rel.targetEntityName(),
-                                        com.spectrayan.spector.memory.graph.EntityType.OTHER);
-                            }
-                            if (targetEid >= 0) {
-                                entityGraph.addRelation(eid, targetEid, rel.relationType());
-                            }
-                        }
-                    }
-                }
-            } catch (RuntimeException e) {
-                SpectorEntityGraphException ex = new SpectorEntityGraphException("extraction", e);
-                log.warn(ex.getMessage());
-            }
-        }
-
-        log.debug("Ingested '{}' as {} (importance={}, {} tags, hnswIdx={}, source={})",
-                id, type, importance, tags.length, storeIndex, source);
-    }
-
-    // ═══════════════════════════════════════════════════════════════
-
-    private static float computeL2Norm(float[] vector) {
-        float sum = 0f;
-        for (float v : vector) sum += v * v;
-        return (float) Math.sqrt(sum);
-    }
-
-    /**
-     * Returns a new L2-normalized copy of the vector.
-     * Required for Parabolic RBF scoring to work correctly
-     * (L2²=2.0 only equals orthogonality when ‖u‖ = ‖v‖ = 1).
-     */
-    private static float[] l2Normalize(float[] vector) {
-        float norm = computeL2Norm(vector);
-        if (norm == 0f || Math.abs(norm - 1.0f) < 1e-6f) return vector; // already normalized or zero
-        float[] normalized = new float[vector.length];
-        float invNorm = 1.0f / norm;
-        for (int i = 0; i < vector.length; i++) {
-            normalized[i] = vector[i] * invNorm;
-        }
-        return normalized;
-    }
-}
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/pipeline/ContentTagExtractor.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/pipeline/ContentTagExtractor.java
deleted file mode 100644
index dc6fe36..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/pipeline/ContentTagExtractor.java
+++ /dev/null
@@ -1,139 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.pipeline;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.LinkedHashSet;
-import java.util.List;
-import java.util.Locale;
-import java.util.Set;
-import java.util.regex.Pattern;
-
-/**
- * Default tag extractor: derives synaptic tags from document path and content.
- *
- * <h3>Extraction Strategy</h3>
- * <ol>
- *   <li><b>Path-based tags</b>: Splits the document ID by path separators,
- *       dots, hyphens, and underscores. Each segment longer than 2 characters
- *       (and not a stop word) becomes a tag.</li>
- *   <li><b>Content-based tags</b>: Extracts significant words from the first
- *       N characters of the text. Words must be longer than 4 characters,
- *       not a stop word, and appear at least once. Top words by length are
- *       selected (longer words are typically more specific).</li>
- * </ol>
- *
- * <p>Total tags per record are capped at {@link #MAX_TAGS} (default: 10)
- * to keep the Bloom filter FPR under 0.2% (per analysis doc §19).</p>
- *
- * @see TagExtractor
- */
-public final class ContentTagExtractor implements TagExtractor {
-
-    /** Maximum tags per record (Bloom filter sweet spot). */
-    private static final int MAX_TAGS = 10;
-
-    /** Maximum content prefix to scan for keyword extraction. */
-    private static final int CONTENT_SCAN_CHARS = 500;
-
-    /** Maximum content-derived tags (path tags get priority). */
-    private static final int MAX_CONTENT_TAGS = 5;
-
-    private static final Pattern SPLIT_PATTERN = Pattern.compile("[/\\\\._\\-\\s]+");
-    private static final Pattern ALPHA_ONLY = Pattern.compile("[^a-z0-9]");
-
-    /** Common English stop words to exclude from tags. */
-    private static final Set<String> STOP_WORDS = Set.of(
-            "the", "and", "for", "are", "but", "not", "you", "all",
-            "can", "had", "her", "was", "one", "our", "out", "has",
-            "his", "how", "its", "may", "new", "now", "old", "see",
-            "way", "who", "did", "get", "let", "say", "she", "too",
-            "use", "with", "that", "this", "have", "from", "they",
-            "been", "said", "each", "which", "their", "will", "other",
-            "about", "many", "then", "them", "these", "some", "would",
-            "make", "like", "into", "could", "time", "very", "when",
-            "come", "made", "after", "back", "only", "just", "being",
-            "over", "also", "than", "much", "down", "should", "were",
-            "what", "your", "more", "there", "first", "where", "those",
-            "still", "here", "through", "while", "before", "between",
-            "under", "never", "every", "because", "another",
-            // File-related stop words
-            "txt", "file", "doc", "docs", "test", "tests", "src", "main",
-            "java", "class", "chunk", "part"
-    );
-
-    @Override
-    public String[] extract(String id, String text) {
-        Set<String> tags = new LinkedHashSet<>(); // preserve insertion order, deduplicate
-
-        // Phase 1: Path-based tags from document ID
-        extractPathTags(id, tags);
-
-        // Phase 2: Content-based significant words
-        if (tags.size() < MAX_TAGS && text != null && !text.isBlank()) {
-            extractContentTags(text, tags);
-        }
-
-        // Cap at MAX_TAGS
-        return tags.stream().limit(MAX_TAGS).toArray(String[]::new);
-    }
-
-    /**
-     * Extracts tags from document ID path segments.
-     * E.g., "stories/auth/login-flow.txt" → ["stories", "auth", "login", "flow"]
-     */
-    private void extractPathTags(String id, Set<String> tags) {
-        if (id == null) return;
-
-        String[] parts = SPLIT_PATTERN.split(id);
-        for (String part : parts) {
-            String clean = ALPHA_ONLY.matcher(part.toLowerCase(Locale.ROOT)).replaceAll("");
-            if (clean.length() > 2 && !STOP_WORDS.contains(clean)) {
-                tags.add(clean);
-            }
-        }
-    }
-
-    /**
-     * Extracts significant keywords from the beginning of the text content.
-     * Selects longer words first (typically more specific/meaningful).
-     */
-    private void extractContentTags(String text, Set<String> tags) {
-        String prefix = text.length() > CONTENT_SCAN_CHARS
-                ? text.substring(0, CONTENT_SCAN_CHARS) : text;
-
-        String[] words = SPLIT_PATTERN.split(prefix.toLowerCase(Locale.ROOT));
-        List<String> candidates = new ArrayList<>();
-
-        for (String word : words) {
-            String clean = ALPHA_ONLY.matcher(word).replaceAll("");
-            if (clean.length() > 4 && !STOP_WORDS.contains(clean) && !tags.contains(clean)) {
-                candidates.add(clean);
-            }
-        }
-
-        // Sort by length descending — longer words are more specific
-        candidates.sort((a, b) -> Integer.compare(b.length(), a.length()));
-
-        // Deduplicate and take top N
-        int added = 0;
-        Set<String> seen = new LinkedHashSet<>();
-        for (String c : candidates) {
-            if (seen.add(c) && tags.add(c)) {
-                added++;
-                if (added >= MAX_CONTENT_TAGS) break;
-            }
-        }
-    }
-}
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/pipeline/HebbianCoActivationListener.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/pipeline/HebbianCoActivationListener.java
deleted file mode 100644
index 9dc489c..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/pipeline/HebbianCoActivationListener.java
+++ /dev/null
@@ -1,97 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.pipeline;
-
-import com.spectrayan.spector.memory.CognitiveResult;
-import com.spectrayan.spector.memory.hebbian.CoActivationTracker;
-
-import java.util.ArrayList;
-import java.util.List;
-
-/**
- * Hebbian co-activation + STDP listener — records both undirected co-occurrence
- * and directed temporal associations from recall results.
- *
- * <h3>Biological Analog: Hebbian Learning + STDP</h3>
- * <p>"Cells that fire together wire together." When multiple memories are recalled
- * together, their synaptic tags form co-activation pairs. Over time, recalling
- * one tag automatically surfaces associated tags — spreading activation.</p>
- *
- * <h3>STDP Extension</h3>
- * <p>Additionally, recall results are treated as a <em>temporal sequence</em>
- * ordered by their cognitive score. The highest-scoring memory is treated as
- * "activated first" (strongest response), and lower-scoring memories as
- * "activated later." This creates directional STDP edges: high-score tags
- * <b>predict</b> lower-score tags.</p>
- *
- * <h3>Design Pattern: Observer</h3>
- * <p>Previously hardcoded in SpectorMemory.recall() Step 8, now a standalone
- * listener registered with {@link RecallPipeline#addListener}.</p>
- */
-public final class HebbianCoActivationListener implements RecallListener {
-
-    private final CoActivationTracker tracker;
-
-    public HebbianCoActivationListener(CoActivationTracker tracker) {
-        this.tracker = tracker;
-    }
-
-    @Override
-    public void onRecallComplete(List<CognitiveResult> results) {
-        if (results.size() < 2) return;
-
-        // ── Phase 1: Undirected co-activation (original Hebbian) ──
-        String[] resultTags = results.stream()
-                .flatMap(r -> r.synapticTags() != null
-                        ? java.util.Arrays.stream(r.synapticTags())
-                        : java.util.stream.Stream.<String>empty())
-                .distinct()
-                .limit(10)
-                .toArray(String[]::new);
-
-        if (resultTags.length >= 2) {
-            tracker.recordCoActivation(resultTags);
-        }
-
-        // ── Phase 2: STDP sequential activation (directed) ──
-        // Results are already sorted by score (highest first).
-        // Treat the result order as temporal activation order:
-        //   result[0].tags  →  result[1].tags  →  result[2].tags  ...
-        // This creates causal associations: "java" in a high-score result
-        // predicts "gc" in a lower-score result.
-        long nowMs = System.currentTimeMillis();
-        List<String> orderedTags = new ArrayList<>();
-        List<Long> timestamps = new ArrayList<>();
-
-        // Create a synthetic temporal sequence from result score ordering
-        // Each result is spaced 1 second apart for STDP exponential window
-        for (int i = 0; i < Math.min(results.size(), 5); i++) {
-            CognitiveResult r = results.get(i);
-            if (r.synapticTags() == null) continue;
-
-            // Pick the first tag from each result as the representative
-            for (String tag : r.synapticTags()) {
-                if (!orderedTags.contains(tag)) {
-                    orderedTags.add(tag);
-                    timestamps.add(nowMs + i * 1000L);  // 1 second spacing
-                    if (orderedTags.size() >= 8) break;
-                }
-            }
-            if (orderedTags.size() >= 8) break;
-        }
-
-        if (orderedTags.size() >= 2) {
-            tracker.recordSequentialActivations(orderedTags, timestamps);
-        }
-    }
-}
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/pipeline/LlmTagExtractor.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/pipeline/LlmTagExtractor.java
deleted file mode 100644
index d9500dc..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/pipeline/LlmTagExtractor.java
+++ /dev/null
@@ -1,129 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.pipeline;
-
-import com.spectrayan.spector.embed.TextGenerationProvider;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.util.Arrays;
-import java.util.Locale;
-
-/**
- * LLM-powered tag extractor that uses a {@link TextGenerationProvider}
- * to extract semantic tags from document content.
- *
- * <h3>How It Works</h3>
- * <p>Sends a structured prompt to the LLM asking it to identify 5–10
- * contextual tags from the text. The LLM returns comma-separated tags
- * which are parsed into the synaptic tag array.</p>
- *
- * <h3>Fallback</h3>
- * <p>If the LLM is unavailable or returns an unparseable response,
- * falls back to {@link ContentTagExtractor} for basic keyword extraction.</p>
- *
- * <h3>Performance Note</h3>
- * <p>LLM inference adds ~500ms–2s per chunk. Use this extractor for
- * high-value ingestion (e.g., user-provided documents) where tag quality
- * justifies the latency. For bulk ingestion of thousands of files,
- * {@link ContentTagExtractor} is recommended.</p>
- *
- * @see TagExtractor
- * @see TextGenerationProvider
- */
-public final class LlmTagExtractor implements TagExtractor {
-
-    private static final Logger log = LoggerFactory.getLogger(LlmTagExtractor.class);
-
-    private static final int MAX_TAGS = 10;
-    private static final int MAX_CONTENT_FOR_PROMPT = 1000;
-
-    private static final String PROMPT_TEMPLATE = """
-            Extract 5 to 10 contextual tags from the following text.
-            Tags should be single lowercase words or short phrases that describe \
-            the key topics, themes, entities, or categories in the text.
-            Return ONLY a comma-separated list of tags, nothing else.
-            
-            Text:
-            %s
-            
-            Tags:""";
-
-    private final TextGenerationProvider generator;
-    private final TagExtractor fallback;
-
-    /**
-     * Creates an LLM tag extractor with the default content-based fallback.
-     *
-     * @param generator the text generation provider (e.g., Ollama)
-     */
-    public LlmTagExtractor(TextGenerationProvider generator) {
-        this(generator, new ContentTagExtractor());
-    }
-
-    /**
-     * Creates an LLM tag extractor with a custom fallback.
-     *
-     * @param generator the text generation provider
-     * @param fallback  fallback extractor for when LLM is unavailable
-     */
-    public LlmTagExtractor(TextGenerationProvider generator, TagExtractor fallback) {
-        this.generator = generator;
-        this.fallback = fallback;
-    }
-
-    @Override
-    public String[] extract(String id, String text) {
-        if (generator == null || !generator.isAvailable()) {
-            return fallback.extract(id, text);
-        }
-
-        try {
-            String content = text != null && text.length() > MAX_CONTENT_FOR_PROMPT
-                    ? text.substring(0, MAX_CONTENT_FOR_PROMPT) : text;
-
-            String prompt = String.format(PROMPT_TEMPLATE, content != null ? content : id);
-            String response = generator.generate(prompt);
-
-            if (response == null || response.isBlank()) {
-                log.debug("LLM returned empty tags for '{}', falling back", id);
-                return fallback.extract(id, text);
-            }
-
-            // Parse comma-separated tags
-            String[] tags = Arrays.stream(response.split("[,;\\n]"))
-                    .map(String::trim)
-                    .map(s -> s.toLowerCase(Locale.ROOT))
-                    .map(s -> s.replaceAll("[^a-z0-9\\-_ ]", ""))
-                    .filter(s -> !s.isBlank() && s.length() > 1)
-                    .distinct()
-                    .limit(MAX_TAGS)
-                    .toArray(String[]::new);
-
-            if (tags.length == 0) {
-                log.debug("LLM tags parsed to empty for '{}', falling back", id);
-                return fallback.extract(id, text);
-            }
-
-            log.debug("LLM extracted {} tags for '{}': {}", tags.length, id,
-                    String.join(", ", tags));
-            return tags;
-
-        } catch (Exception e) {
-            log.warn("LLM tag extraction failed for '{}': {}, falling back",
-                    id, e.getMessage());
-            return fallback.extract(id, text);
-        }
-    }
-}
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/pipeline/LtpReconsolidationListener.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/pipeline/LtpReconsolidationListener.java
deleted file mode 100644
index 410b121..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/pipeline/LtpReconsolidationListener.java
+++ /dev/null
@@ -1,65 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.pipeline;
-
-import com.spectrayan.spector.memory.CognitiveResult;
-import com.spectrayan.spector.memory.cortex.TierRouter;
-import com.spectrayan.spector.memory.index.MemoryIndex;
-import com.spectrayan.spector.memory.index.MemoryIndex.MemoryLocation;
-import com.spectrayan.spector.memory.sync.MemoryWal;
-import com.spectrayan.spector.memory.sync.WalEvent;
-import com.spectrayan.spector.memory.synapse.CognitiveRecordLayout;
-
-import java.lang.foreign.MemorySegment;
-import java.util.List;
-
-/**
- * LTP Reconsolidation listener — increments recall_count on returned memories.
- *
- * <h3>Biological Analog: Long-Term Potentiation (LTP)</h3>
- * <p>Each time a memory is successfully recalled, its synaptic strength increases.
- * In Spector's model, this manifests as incrementing {@code recall_count},
- * which in turn reduces the decay rate via
- * {@link com.spectrayan.spector.memory.synapse.DecayStrategy#adjustForReconsolidation}.</p>
- *
- * <h3>Design Pattern: Observer</h3>
- * <p>Previously hardcoded in SpectorMemory.recall() Step 7, now a standalone
- * listener registered with {@link RecallPipeline#addListener}.</p>
- */
-public final class LtpReconsolidationListener implements RecallListener {
-
-    private final MemoryIndex index;
-    private final TierRouter tierRouter;
-    private final MemoryWal wal;
-
-    public LtpReconsolidationListener(MemoryIndex index, TierRouter tierRouter, MemoryWal wal) {
-        this.index = index;
-        this.tierRouter = tierRouter;
-        this.wal = wal;
-    }
-
-    @Override
-    public void onRecallComplete(List<CognitiveResult> results) {
-        for (CognitiveResult r : results) {
-            MemoryLocation loc = index.locate(r.id());
-            if (loc != null) {
-                // Log recall hit for analytics only — recall_count is now managed
-                // exclusively by reinforce() to prevent inflation from passive retrieval.
-                // Previously this incremented recall_count for ALL returned results,
-                // making too many memories "immortal" via reconsolidation.
-                wal.append(WalEvent.EventType.RECALL_HIT,
-                        index.findIdByOffset(loc.type(), loc.offset()), null);
-            }
-        }
-    }
-}
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/pipeline/RecallListener.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/pipeline/RecallListener.java
deleted file mode 100644
index cdef65f..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/pipeline/RecallListener.java
+++ /dev/null
@@ -1,44 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.pipeline;
-
-import com.spectrayan.spector.memory.CognitiveResult;
-
-import java.util.List;
-
-/**
- * Observer interface for post-recall hooks.
- *
- * <h3>Design Pattern: Observer</h3>
- * <p>Instead of hardcoding post-recall behavior (LTP reconsolidation, Hebbian
- * co-activation recording, analytics, etc.) directly in the recall pipeline,
- * these are implemented as listeners. This is OCP-compliant — new post-recall
- * behaviors can be added without modifying the pipeline.</p>
- *
- * <h3>Built-in Listeners</h3>
- * <ul>
- *   <li>{@link LtpReconsolidationListener} — increments recall_count for returned memories</li>
- *   <li>{@link HebbianCoActivationListener} — records tag co-occurrence in the
- *       {@link com.spectrayan.spector.memory.hebbian.CoActivationTracker}</li>
- * </ul>
- */
-@FunctionalInterface
-public interface RecallListener {
-
-    /**
-     * Called after each successful recall with the final ranked results.
-     *
-     * @param results the final recall results (post-filtering, post-habituation)
-     */
-    void onRecallComplete(List<CognitiveResult> results);
-}
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/pipeline/RecallPipeline.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/pipeline/RecallPipeline.java
deleted file mode 100644
index 9666df1..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/pipeline/RecallPipeline.java
+++ /dev/null
@@ -1,766 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.pipeline;
-
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-import com.spectrayan.spector.commons.error.ErrorCode;
-
-import com.spectrayan.spector.memory.error.SpectorEntityGraphException;
-import com.spectrayan.spector.memory.error.SpectorHebbianException;
-import com.spectrayan.spector.memory.error.SpectorTemporalChainException;
-
-import com.spectrayan.spector.commons.concurrent.ConcurrentTasks;
-import com.spectrayan.spector.commons.concurrent.ConcurrentExecutionException;
-import com.spectrayan.spector.embed.EmbeddingProvider;
-import com.spectrayan.spector.memory.CognitiveResult;
-import com.spectrayan.spector.memory.CognitiveResult.RetrievalMode;
-import com.spectrayan.spector.memory.MemoryType;
-import com.spectrayan.spector.memory.RecallOptions;
-import com.spectrayan.spector.memory.cortex.EpisodicMemoryStore.EpisodicPartition;
-import com.spectrayan.spector.memory.cortex.MemorySource;
-import com.spectrayan.spector.memory.cortex.SemanticRecallStrategy;
-import com.spectrayan.spector.memory.cortex.TierRouter;
-import com.spectrayan.spector.memory.habituation.HabituationPenalty;
-import com.spectrayan.spector.memory.index.MemoryIndex;
-import com.spectrayan.spector.memory.inhibition.SuppressionSet;
-import com.spectrayan.spector.memory.prospective.ProspectiveScheduler;
-import com.spectrayan.spector.memory.prospective.Reminder;
-import com.spectrayan.spector.memory.sync.MemoryWal;
-import com.spectrayan.spector.memory.synapse.CognitiveRecordLayout;
-import com.spectrayan.spector.memory.synapse.CognitiveRecordLayout.CognitiveHeader;
-import com.spectrayan.spector.memory.synapse.CognitiveScorer;
-import com.spectrayan.spector.memory.synapse.CognitiveScorer.ScoredRecord;
-import com.spectrayan.spector.memory.synapse.DecayStrategy;
-import com.spectrayan.spector.memory.synapse.SynapticHeaderConstants;
-import com.spectrayan.spector.memory.synapse.SynapticTagEncoder;
-import com.spectrayan.spector.memory.hebbian.CoActivationTracker;
-import com.spectrayan.spector.memory.hebbian.HebbianGraph;
-import com.spectrayan.spector.memory.graph.EntityExtractor;
-import com.spectrayan.spector.memory.graph.EntityGraph;
-import com.spectrayan.spector.memory.graph.ExtractedEntity;
-import com.spectrayan.spector.memory.temporal.TemporalChain;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.lang.foreign.MemorySegment;
-import java.util.ArrayList;
-import java.util.Comparator;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
-import java.util.Objects;
-import java.util.concurrent.Callable;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.LinkedHashMap;
-import java.util.Map;
-
-import static com.spectrayan.spector.memory.cortex.EpisodicMemoryStore.EpisodicPartition.METADATA_HEADER_BYTES;
-
-/**
- * 8-step recall pipeline for cognitive memory retrieval.
- *
- * <h3>Pipeline Steps</h3>
- * <pre>
- *   Step 1: Embed query text
- *   Step 2: Collect due prospective reminders
- *   Step 3: Score across each tier store (parallel via ConcurrentTasks)
- *   Step 4: Filter suppressed memories (inhibition)
- *   Step 5: Apply habituation penalty (anti-filter-bubble)
- *   Step 6: Sort by score descending, limit to topK
- *   Step 7: Fire async post-recall listeners (LTP + Hebbian)
- * </pre>
- *
- * <h3>Performance: Parallel Tier Scanning</h3>
- * <p>Step 3 fans out tier scans as parallel tasks via
- * {@link ConcurrentTasks#forkJoinAll}. Each scan operates on a disjoint
- * off-heap {@link MemorySegment} — zero contention. With 4 tiers + N episodic
- * partitions, recall latency = max(tier_latency) instead of sum(tier_latencies).</p>
- *
- * <h3>Performance: Async Post-Recall Hooks</h3>
- * <p>Steps 7–8 (LTP reconsolidation, Hebbian co-activation) fire on Virtual Threads
- * so the caller doesn't block on post-recall bookkeeping.</p>
- *
- * <h3>Design Patterns</h3>
- * <ul>
- *   <li><b>Template Method</b>: Pipeline skeleton is fixed; scoring delegated to
- *       {@link CognitiveScorer}</li>
- *   <li><b>Observer</b>: Post-recall hooks via {@link RecallListener}</li>
- * </ul>
- */
-public final class RecallPipeline {
-
-    private static final Logger log = LoggerFactory.getLogger(RecallPipeline.class);
-
-    private final EmbeddingProvider embeddingProvider;
-    private final TierRouter tierRouter;
-    private final MemoryIndex index;
-    private final SuppressionSet suppressionSet;
-    private final HabituationPenalty habituationPenalty;
-    private final ProspectiveScheduler prospectiveScheduler;
-    private final MemoryWal wal;
-    private final float[] calibrationMins;
-    private final float[] calibrationScales;
-    private final SemanticRecallStrategy semanticRecallStrategy; // nullable
-    private final CoActivationTracker coActivationTracker; // nullable — for STDP causal boost
-
-    /** STDP causal boost weight applied to predictive strength. */
-    private static final float CAUSAL_BOOST_WEIGHT = 0.3f;
-
-    private final List<RecallListener> listeners = new ArrayList<>();
-
-    // ── 3-Layer Cognitive Graph (all nullable) ──
-    private final HebbianGraph hebbianGraph;
-    private final TemporalChain temporalChain;
-    private final EntityGraph entityGraph;
-    private final EntityExtractor entityExtractor;
-
-    // ── Neurodivergent: Lateral feedback tracking ──
-    // Maps memoryId → RetrievalMode for the most recent recall.
-    // Used by SpectorMemory.reinforce()/suppress() to feed LateralEvaluator.
-    // Entries expire implicitly via size cap (oldest evicted at 2000).
-    private final ConcurrentHashMap<String, RetrievalMode> recentRetrievalModes
-            = new ConcurrentHashMap<>();
-    private static final int RETRIEVAL_MODE_CACHE_MAX = 2000;
-    private RecallOptions lastRecallOptions; // for detecting hyperfocus mode
-
-    // ── Semantic Satiation: Anti-looping LRU cache ──
-    // Bounded LRU of last N result IDs. Any result that appears in this
-    // hot cache gets a 0.5× penalty, breaking exact-query loops.
-    private static final int SATIATION_CACHE_SIZE = 10;
-    private static final float SATIATION_PENALTY = 0.5f;
-    private final LinkedHashMap<String, Long> satiationCache =
-            new LinkedHashMap<>(16, 0.75f, true) {
-                @Override
-                protected boolean removeEldestEntry(Map.Entry<String, Long> eldest) {
-                    return size() > SATIATION_CACHE_SIZE;
-                }
-            };
-
-    /**
-     * Creates a recall pipeline with all required subsystems.
-     */
-    public RecallPipeline(EmbeddingProvider embeddingProvider,
-                           TierRouter tierRouter,
-                           MemoryIndex index,
-                           SuppressionSet suppressionSet,
-                           HabituationPenalty habituationPenalty,
-                           ProspectiveScheduler prospectiveScheduler,
-                           MemoryWal wal,
-                           float[] calibrationMins,
-                           float[] calibrationScales) {
-        this(embeddingProvider, tierRouter, index, suppressionSet, habituationPenalty,
-                prospectiveScheduler, wal, calibrationMins, calibrationScales, null, null);
-    }
-
-    /**
-     * Creates a recall pipeline with optional fused semantic recall.
-     *
-     * @param semanticRecallStrategy nullable — when provided, semantic recall uses
-     *                                HNSW vector search fused with cognitive scoring
-     */
-    public RecallPipeline(EmbeddingProvider embeddingProvider,
-                           TierRouter tierRouter,
-                           MemoryIndex index,
-                           SuppressionSet suppressionSet,
-                           HabituationPenalty habituationPenalty,
-                           ProspectiveScheduler prospectiveScheduler,
-                           MemoryWal wal,
-                           float[] calibrationMins,
-                           float[] calibrationScales,
-                           SemanticRecallStrategy semanticRecallStrategy) {
-        this(embeddingProvider, tierRouter, index, suppressionSet, habituationPenalty,
-                prospectiveScheduler, wal, calibrationMins, calibrationScales,
-                semanticRecallStrategy, null);
-    }
-
-    /**
-     * Creates a recall pipeline with optional fused semantic recall and STDP.
-     *
-     * @param semanticRecallStrategy nullable — when provided, semantic recall uses
-     *                                HNSW vector search fused with cognitive scoring
-     * @param coActivationTracker    nullable — when provided, STDP causal boost is applied
-     */
-    public RecallPipeline(EmbeddingProvider embeddingProvider,
-                           TierRouter tierRouter,
-                           MemoryIndex index,
-                           SuppressionSet suppressionSet,
-                           HabituationPenalty habituationPenalty,
-                           ProspectiveScheduler prospectiveScheduler,
-                           MemoryWal wal,
-                           float[] calibrationMins,
-                           float[] calibrationScales,
-                           SemanticRecallStrategy semanticRecallStrategy,
-                           CoActivationTracker coActivationTracker) {
-        this(embeddingProvider, tierRouter, index, suppressionSet, habituationPenalty,
-                prospectiveScheduler, wal, calibrationMins, calibrationScales,
-                semanticRecallStrategy, coActivationTracker,
-                null, null, null, null);
-    }
-
-    /**
-     * Creates a recall pipeline with optional fused semantic recall, STDP, and 3-Layer Cognitive Graph.
-     */
-    public RecallPipeline(EmbeddingProvider embeddingProvider,
-                           TierRouter tierRouter,
-                           MemoryIndex index,
-                           SuppressionSet suppressionSet,
-                           HabituationPenalty habituationPenalty,
-                           ProspectiveScheduler prospectiveScheduler,
-                           MemoryWal wal,
-                           float[] calibrationMins,
-                           float[] calibrationScales,
-                           SemanticRecallStrategy semanticRecallStrategy,
-                           CoActivationTracker coActivationTracker,
-                           HebbianGraph hebbianGraph,
-                           TemporalChain temporalChain,
-                           EntityGraph entityGraph,
-                           EntityExtractor entityExtractor) {
-        this.embeddingProvider = embeddingProvider;
-        this.tierRouter = tierRouter;
-        this.index = index;
-        this.suppressionSet = suppressionSet;
-        this.habituationPenalty = habituationPenalty;
-        this.prospectiveScheduler = prospectiveScheduler;
-        this.wal = wal;
-        this.calibrationMins = calibrationMins;
-        this.calibrationScales = calibrationScales;
-        this.semanticRecallStrategy = semanticRecallStrategy;
-        this.coActivationTracker = coActivationTracker;
-        this.hebbianGraph = hebbianGraph;
-        this.temporalChain = temporalChain;
-        this.entityGraph = entityGraph;
-        this.entityExtractor = entityExtractor;
-    }
-
-    /**
-     * Registers a post-recall listener (Observer pattern).
-     *
-     * @param listener called after each successful recall with the final results
-     */
-    public void addListener(RecallListener listener) {
-        if (listener == null) { throw new SpectorValidationException(ErrorCode.ARGUMENT_NULL, "listener"); } listeners.add(listener);
-    }
-
-    /**
-     * Executes the full recall pipeline with parallel tier scanning.
-     *
-     * @param queryText the query text (will be embedded)
-     * @param options   recall configuration
-     * @return ranked list of cognitive results
-     */
-    public List<CognitiveResult> recall(String queryText, RecallOptions options) {
-        if (queryText == null) { throw new SpectorValidationException(ErrorCode.ARGUMENT_NULL, "queryText"); }
-        if (options == null) options = RecallOptions.DEFAULT;
-
-        log.debug("Recall query: '{}', topK={}", queryText, options.topK());
-        this.lastRecallOptions = options; // for RetrievalMode detection in headerToResult
-
-        // Step 1: Embed query
-        float[] queryVector = embeddingProvider.embed(queryText).vector();
-
-        long nowMs = System.currentTimeMillis();
-        List<CognitiveResult> allResults = new ArrayList<>();
-
-        // Step 2: Collect due prospective reminders
-        List<Reminder> dueReminders = prospectiveScheduler.collectDue();
-        for (Reminder r : dueReminders) {
-            allResults.add(new CognitiveResult(
-                    r.id(), r.text(), 10.0f, 10.0f, 0f,
-                    (short) 0, (byte) 0, MemoryType.WORKING, MemorySource.PROCEDURAL,
-                    new String[]{"prospective"}, 1.0f, 1.0f));
-        }
-
-        // Step 3: Parallel tier scanning via ConcurrentTasks.forkJoinAll
-        MemoryType[] targetTypes = options.memoryTypes();
-        List<Callable<List<CognitiveResult>>> scanTasks = buildScanTasks(
-                queryVector, options, nowMs, targetTypes);
-
-        if (!scanTasks.isEmpty()) {
-            try {
-                List<List<CognitiveResult>> tierResults = ConcurrentTasks.forkJoinAll(scanTasks);
-                for (List<CognitiveResult> tier : tierResults) {
-                    allResults.addAll(tier);
-                }
-            } catch (ConcurrentExecutionException e) {
-                log.error("Parallel tier scan failed: {}", e.getMessage(), e);
-                // Fallback: sequential scan
-                allResults.addAll(sequentialScan(queryVector, options, nowMs, targetTypes));
-            } catch (InterruptedException e) {
-                Thread.currentThread().interrupt();
-                log.warn("Recall interrupted during parallel scan");
-                return allResults;
-            }
-        }
-
-        // Step 4: Filter suppressed memories (inhibition)
-        allResults.removeIf(r -> suppressionSet.isSuppressed(r.id()));
-
-        // Step 5: Apply habituation penalty + inhibition of return + semantic satiation
-        for (int i = 0; i < allResults.size(); i++) {
-            CognitiveResult r = allResults.get(i);
-            float habPenalty = habituationPenalty.recordAndComputePenalty(r.id());
-            float iorPenalty = habituationPenalty.computeInhibitionOfReturn(r.id(), nowMs);
-            float combinedPenalty = Math.min(habPenalty, iorPenalty); // stronger suppression wins
-
-            // Semantic Satiation: 0.5× penalty for results in the hot LRU cache
-            if (satiationCache.containsKey(r.id())) {
-                combinedPenalty *= SATIATION_PENALTY;
-            }
-
-            if (combinedPenalty < 1.0f) {
-                allResults.set(i, new CognitiveResult(
-                        r.id(), r.text(), r.score() * combinedPenalty, r.importance(), r.ageDays(),
-                        r.recallCount(), r.valence(), r.memoryType(), r.source(),
-                        r.synapticTags(), r.decayFactor(), r.ltpAdjustedDecay()));
-            }
-        }
-
-        // Step 5b: STDP causal boost — cross-boost results whose tags are causally linked
-        // For each result, check if earlier results' tags predict its tags (via STDP edges).
-        // This promotes memories that form causal chains.
-        if (coActivationTracker != null && allResults.size() >= 2) {
-            // Use tags from the first few results as "context tags" to boost subsequent results
-            List<String> contextTags = allResults.stream()
-                    .limit(3)
-                    .filter(r -> r.synapticTags() != null)
-                    .flatMap(r -> java.util.Arrays.stream(r.synapticTags()))
-                    .distinct()
-                    .toList();
-
-            if (!contextTags.isEmpty()) {
-                for (int i = 0; i < allResults.size(); i++) {
-                    CognitiveResult r = allResults.get(i);
-                    if (r.synapticTags() == null || r.synapticTags().length == 0) continue;
-
-                    float predictive = coActivationTracker.getPredictiveStrength(
-                            contextTags, r.synapticTags());
-                    if (predictive > 0) {
-                        float boostedScore = r.score() * (1.0f + predictive * CAUSAL_BOOST_WEIGHT);
-                        allResults.set(i, new CognitiveResult(
-                                r.id(), r.text(), boostedScore, r.importance(), r.ageDays(),
-                                r.recallCount(), r.valence(), r.memoryType(), r.source(),
-                                r.synapticTags(), r.decayFactor(), r.ltpAdjustedDecay()));
-                    }
-                }
-            }
-        }
-
-        // Step 5c: Hebbian spreading activation — follow memory-to-memory associations
-        if (hebbianGraph != null && !allResults.isEmpty()) {
-            try {
-                Set<String> existingIds = new HashSet<>();
-                for (CognitiveResult r : allResults) {
-                    if (r.id() != null) existingIds.add(r.id());
-                }
-
-                // Use top 3 results as seeds for spreading activation
-                int seeds = Math.min(3, allResults.size());
-                for (int s = 0; s < seeds; s++) {
-                    CognitiveResult seed = allResults.get(s);
-                    // Find the memory index for this result
-                    MemoryIndex.MemoryLocation loc = index.locate(seed.id());
-                    if (loc == null) continue;
-
-                    int memIdx = (int) (loc.offset() / 164); // approximate index from offset
-                    var activated = hebbianGraph.activateNeighbors(memIdx, 2);
-                    for (var edge : activated) {
-                        // Find the memory at this graph index
-                        String neighborId = findMemoryByApproximateIndex(edge.neighborIndex());
-                        if (neighborId != null && !existingIds.contains(neighborId)) {
-                            existingIds.add(neighborId);
-                            String text = index.text(neighborId);
-                            MemorySource source = index.source(neighborId);
-                            String[] tags = index.tags(neighborId);
-                            float graphScore = seed.score() * edge.weight() * 0.3f; // attenuated
-                            allResults.add(new CognitiveResult(
-                                    neighborId, text, graphScore, seed.importance(), 0f,
-                                    (short) 0, (byte) 0, seed.memoryType(), source,
-                                    tags, 1.0f, 1.0f));
-                        }
-                    }
-                }
-            } catch (RuntimeException e) {
-                SpectorHebbianException ex = new SpectorHebbianException("spreading activation", e);
-                log.debug(ex.getMessage());
-            }
-        }
-
-        // Step 5d: Temporal chain extension — follow session-linked sequences
-        if (temporalChain != null && !allResults.isEmpty()) {
-            try {
-                Set<String> existingIds = new HashSet<>();
-                for (CognitiveResult r : allResults) {
-                    if (r.id() != null) existingIds.add(r.id());
-                }
-
-                int seeds = Math.min(3, allResults.size());
-                for (int s = 0; s < seeds; s++) {
-                    CognitiveResult seed = allResults.get(s);
-                    MemoryIndex.MemoryLocation loc = index.locate(seed.id());
-                    if (loc == null) continue;
-
-                    int memIdx = (int) (loc.offset() / 164);
-                    // Follow forward and backward
-                    for (int chainIdx : temporalChain.followForward(memIdx, 3)) {
-                        addChainResult(chainIdx, seed, existingIds, allResults, 0.8f);
-                    }
-                    for (int chainIdx : temporalChain.followBackward(memIdx, 3)) {
-                        addChainResult(chainIdx, seed, existingIds, allResults, 0.7f);
-                    }
-                }
-            } catch (RuntimeException e) {
-                SpectorTemporalChainException ex = new SpectorTemporalChainException("chain extension", e);
-                log.debug(ex.getMessage());
-            }
-        }
-
-        // Step 5e: Entity graph traversal — multi-hop knowledge discovery
-        if (entityGraph != null && entityExtractor != null
-                && entityExtractor.isAvailable() && !allResults.isEmpty()) {
-            Set<String> existingIds = new HashSet<>();
-            for (CognitiveResult r : allResults) {
-                if (r.id() != null) existingIds.add(r.id());
-            }
-
-            // Extract entities from the query
-            try {
-                var queryEntities = entityExtractor.extract("query", queryText);
-                for (var entity : queryEntities) {
-                    int entityId = entityGraph.findEntity(entity.name());
-                    if (entityId < 0) continue;
-
-                    // Collect memories reachable within 2 hops
-                    Set<Integer> reachableMemories = entityGraph.collectMemories(
-                            entityId, null, 2);
-                    for (int memIdx : reachableMemories) {
-                        String memId = findMemoryByApproximateIndex(memIdx);
-                        if (memId != null && !existingIds.contains(memId)) {
-                            existingIds.add(memId);
-                            String text = index.text(memId);
-                            MemorySource source = index.source(memId);
-                            String[] tags = index.tags(memId);
-                            float entityScore = allResults.getFirst().score() * 0.25f;
-                            allResults.add(new CognitiveResult(
-                                    memId, text, entityScore, 0.5f, 0f,
-                                    (short) 0, (byte) 0, MemoryType.SEMANTIC, source,
-                                    tags, 1.0f, 1.0f));
-                        }
-                    }
-                }
-            } catch (RuntimeException e) {
-                SpectorEntityGraphException ex = new SpectorEntityGraphException("graph traversal", e);
-                log.debug(ex.getMessage());
-            }
-        }
-
-        // Step 6: Sort by score descending, limit to topK
-        allResults.sort(Comparator.comparing(CognitiveResult::score).reversed());
-        if (allResults.size() > options.topK()) {
-            allResults = new ArrayList<>(allResults.subList(0, options.topK()));
-        }
-
-        // Step 7: Fire async post-recall listeners (LTP reconsolidation + Hebbian)
-        if (!listeners.isEmpty()) {
-            final List<CognitiveResult> finalResults = allResults;
-            for (RecallListener listener : listeners) {
-                Thread.startVirtualThread(() -> {
-                    try {
-                        listener.onRecallComplete(finalResults);
-                    } catch (Exception e) {
-                        log.error("Post-recall listener failed: {}", e.getMessage(), e);
-                    }
-                });
-            }
-        }
-
-        // Step 8: Record recall timestamps for Inhibition of Return
-        long recallTs = System.currentTimeMillis();
-        for (CognitiveResult r : allResults) {
-            habituationPenalty.recordRecall(r.id(), recallTs);
-        }
-
-        log.debug("Recall returned {} results for '{}'", allResults.size(), queryText);
-
-        // Cache retrieval modes for lateral feedback (reinforce/suppress)
-        if (recentRetrievalModes.size() > RETRIEVAL_MODE_CACHE_MAX) {
-            recentRetrievalModes.clear(); // simple eviction — reset when full
-        }
-        for (CognitiveResult r : allResults) {
-            if (r.id() != null) {
-                recentRetrievalModes.put(r.id(), r.retrievalMode());
-            }
-        }
-
-        // Update semantic satiation LRU cache with returned result IDs
-        long nowForSatiation = System.currentTimeMillis();
-        for (CognitiveResult r : allResults) {
-            if (r.id() != null) {
-                satiationCache.put(r.id(), nowForSatiation);
-            }
-        }
-
-        return allResults;
-    }
-
-    // ══════════════════════════════════════════════════════════════
-    // PARALLEL SCANNING — builds Callable tasks for each tier/partition
-    // ══════════════════════════════════════════════════════════════
-
-    private List<Callable<List<CognitiveResult>>> buildScanTasks(
-            float[] queryVector, RecallOptions options, long nowMs, MemoryType[] targetTypes) {
-        List<Callable<List<CognitiveResult>>> tasks = new ArrayList<>();
-
-        // Working Memory scan
-        if (TierRouter.shouldScan(MemoryType.WORKING, targetTypes)
-                && tierRouter.working().size() > 0) {
-            tasks.add(() -> scoreStoreToList(
-                    tierRouter.working().segment(), tierRouter.working().size(),
-                    tierRouter.working().layout(), queryVector, options, nowMs,
-                    MemoryType.WORKING, 0L));
-        }
-
-        // Episodic Memory — one task per partition (disjoint segments → zero contention)
-        if (TierRouter.shouldScan(MemoryType.EPISODIC, targetTypes)) {
-            for (EpisodicPartition partition : tierRouter.episodic().partitions()) {
-                if (partition.count() > 0) {
-                    tasks.add(() -> scoreStoreToList(
-                            partition.segment(), partition.count(),
-                            partition.layout(), queryVector, options, nowMs,
-                            MemoryType.EPISODIC, METADATA_HEADER_BYTES));
-                }
-            }
-        }
-
-        // Semantic Memory — fused HNSW+cognitive if strategy available, else header slab
-        if (TierRouter.shouldScan(MemoryType.SEMANTIC, targetTypes)
-                && tierRouter.semantic().size() > 0) {
-            if (semanticRecallStrategy != null && semanticRecallStrategy.isAvailable()) {
-                // Fused pipeline: HNSW search → cognitive re-ranking
-                tasks.add(() -> semanticRecallStrategy.recall(queryVector, options, nowMs));
-            } else {
-                // Fallback: header-only slab scan (with tag/valence filters)
-                tasks.add(() -> scoreHeaderSlabToList(
-                        tierRouter.semantic().headerSlab(), tierRouter.semantic().size(),
-                        tierRouter.semantic().layout(), queryVector, options, nowMs));
-            }
-        }
-
-        // Procedural Memory scan
-        if (TierRouter.shouldScan(MemoryType.PROCEDURAL, targetTypes)
-                && tierRouter.procedural().size() > 0) {
-            tasks.add(() -> scoreStoreToList(
-                    tierRouter.procedural().segment(), tierRouter.procedural().size(),
-                    tierRouter.procedural().layout(), queryVector, options, nowMs,
-                    MemoryType.PROCEDURAL, 0L));
-        }
-
-        return tasks;
-    }
-
-    /**
-     * Fallback sequential scan (used if parallel scan fails).
-     */
-    private List<CognitiveResult> sequentialScan(float[] queryVector, RecallOptions options,
-                                                   long nowMs, MemoryType[] targetTypes) {
-        List<CognitiveResult> results = new ArrayList<>();
-        if (TierRouter.shouldScan(MemoryType.WORKING, targetTypes)
-                && tierRouter.working().size() > 0) {
-            results.addAll(scoreStoreToList(tierRouter.working().segment(),
-                    tierRouter.working().size(), tierRouter.working().layout(),
-                    queryVector, options, nowMs, MemoryType.WORKING, 0L));
-        }
-        if (TierRouter.shouldScan(MemoryType.EPISODIC, targetTypes)) {
-            for (EpisodicPartition p : tierRouter.episodic().partitions()) {
-                if (p.count() > 0) {
-                    results.addAll(scoreStoreToList(p.segment(), p.count(), p.layout(),
-                            queryVector, options, nowMs, MemoryType.EPISODIC, METADATA_HEADER_BYTES));
-                }
-            }
-        }
-        if (TierRouter.shouldScan(MemoryType.SEMANTIC, targetTypes)
-                && tierRouter.semantic().size() > 0) {
-            if (semanticRecallStrategy != null && semanticRecallStrategy.isAvailable()) {
-                results.addAll(semanticRecallStrategy.recall(queryVector, options, nowMs));
-            } else {
-                results.addAll(scoreHeaderSlabToList(tierRouter.semantic().headerSlab(),
-                        tierRouter.semantic().size(), tierRouter.semantic().layout(),
-                        queryVector, options, nowMs));
-            }
-        }
-        if (TierRouter.shouldScan(MemoryType.PROCEDURAL, targetTypes)
-                && tierRouter.procedural().size() > 0) {
-            results.addAll(scoreStoreToList(tierRouter.procedural().segment(),
-                    tierRouter.procedural().size(), tierRouter.procedural().layout(),
-                    queryVector, options, nowMs, MemoryType.PROCEDURAL, 0L));
-        }
-        return results;
-    }
-
-    // ══════════════════════════════════════════════════════════════
-    // SCORING HELPERS — return lists (for parallel composition)
-    // ══════════════════════════════════════════════════════════════
-
-    private List<CognitiveResult> scoreStoreToList(MemorySegment segment, int recordCount,
-                                                     CognitiveRecordLayout layout, float[] queryVector,
-                                                     RecallOptions options, long nowMs, MemoryType type,
-                                                     long baseOffset) {
-        List<ScoredRecord> scored = CognitiveScorer.score(
-                segment, recordCount, layout, queryVector, options, nowMs, baseOffset,
-                calibrationMins, calibrationScales);
-
-        List<CognitiveResult> results = new ArrayList<>(scored.size());
-        for (ScoredRecord sr : scored) {
-            // P8: Header already captured during scoring — no off-heap re-read
-            results.add(headerToResult(sr, sr.header(), type));
-        }
-        return results;
-    }
-
-    private List<CognitiveResult> scoreHeaderSlabToList(MemorySegment headerSlab, int recordCount,
-                                                          CognitiveRecordLayout layout, float[] queryVector,
-                                                          RecallOptions options, long nowMs) {
-        long queryTagMask = options.synapticTagMask();
-        byte minValence = options.minValence();
-        byte maxValence = options.maxValence();
-        float tagRelevanceBoost = options.tagRelevanceBoost();
-
-        List<CognitiveResult> results = new ArrayList<>();
-        for (int i = 0; i < recordCount; i++) {
-            long offset = (long) i * layout.headerLayout().headerBytes();
-            CognitiveHeader header = layout.readHeader(headerSlab, offset);
-
-            byte flags = header.flags();
-            if (SynapticHeaderConstants.isTombstoned(flags)) continue;
-
-            // Phase 2: Synaptic tag gating (was missing for semantic tier)
-            if (queryTagMask != 0) {
-                if ((header.synapticTags() & queryTagMask) == 0) continue; // zero overlap → skip
-            }
-
-            // Phase 3: Valence filter (was missing for semantic tier)
-            byte valence = header.valence();
-            if (valence < minValence || valence > maxValence) continue;
-
-            float importance = header.importance();
-            if (importance < options.minImportance()) continue;
-
-            long timestamp = header.timestampMs();
-            int recallCount = header.recallCount();
-            int rawBucket = DecayStrategy.ageToBucket(timestamp, nowMs);
-            int adjusted = DecayStrategy.adjustForReconsolidation(rawBucket, recallCount);
-            float decay = DecayStrategy.decay(adjusted);
-
-            // Score with weighted tag relevance boost (consistent with CognitiveScorer)
-            float baseScore = options.beta() * importance * decay;
-            float tagOverlap = SynapticTagEncoder.overlapRatio(header.synapticTags(), queryTagMask);
-            float score = baseScore * (1.0f + tagOverlap * tagRelevanceBoost);
-
-            results.add(headerToResult(new ScoredRecord(offset, score, i, header), header, MemoryType.SEMANTIC));
-        }
-        return results;
-    }
-
-    private CognitiveResult headerToResult(ScoredRecord sr, CognitiveHeader header, MemoryType type) {
-        String id = index.findIdByOffset(type, sr.offset());  // O(1) via reverse index
-        String text = id != null ? index.text(id) : "";
-        MemorySource source = id != null ? index.source(id) : MemorySource.OBSERVED;
-        String[] tags = id != null ? index.tags(id) : new String[0];
-
-        long nowMs = System.currentTimeMillis();
-        float ageDays = (nowMs - header.timestampMs()) / (1000f * 60f * 60f * 24f);
-
-        int rawBucket = DecayStrategy.ageToBucket(header.timestampMs(), nowMs);
-        int adjusted = DecayStrategy.adjustForReconsolidation(rawBucket, header.recallCount());
-        float rawDecay = DecayStrategy.decay(rawBucket);
-        float ltpDecay = DecayStrategy.decay(adjusted);
-
-        // Determine retrieval mode from scorer metadata
-        RetrievalMode mode;
-        if (sr.lateral()) {
-            mode = RetrievalMode.LATERAL;
-        } else if (lastRecallOptions != null && lastRecallOptions.hyperfocusMask() != 0) {
-            mode = RetrievalMode.HYPERFOCUS;
-        } else {
-            mode = RetrievalMode.STANDARD;
-        }
-
-        return new CognitiveResult(
-                id != null ? id : "unknown-" + sr.index(),
-                text, sr.score(), header.importance(), ageDays,
-                header.recallCount(), header.valence(), type, source,
-                tags, rawDecay, ltpDecay, mode
-        );
-    }
-
-    /**
-     * Returns whether the given memory was returned as a lateral result
-     * in a recent recall.
-     *
-     * @param memoryId the memory ID to check
-     * @return true if the memory was a lateral result, false otherwise
-     */
-    public boolean wasLateral(String memoryId) {
-        RetrievalMode mode = recentRetrievalModes.get(memoryId);
-        return mode == RetrievalMode.LATERAL;
-    }
-
-    /**
-     * Returns the retrieval mode for a recently recalled memory.
-     *
-     * @param memoryId the memory ID to check
-     * @return the retrieval mode, or null if not in cache
-     */
-    public RetrievalMode retrievalModeOf(String memoryId) {
-        return recentRetrievalModes.get(memoryId);
-    }
-
-    // ── Graph helper methods ──
-
-    /**
-     * Finds a memory ID by approximate index. Uses the reverse index
-     * to search across all tiers.
-     */
-    private String findMemoryByApproximateIndex(int approxIdx) {
-        // Try each tier's typical record size to reverse-map
-        for (MemoryType type : MemoryType.values()) {
-            var layout = tierRouter.layoutFor(type);
-            if (layout == null) continue;
-            long offset = (long) approxIdx * layout.stride();
-            String id = index.findIdByOffset(type, offset);
-            if (id != null) return id;
-        }
-        return null;
-    }
-
-    /**
-     * Adds a temporal chain result to the result set if not already present.
-     */
-    private void addChainResult(int chainIdx, CognitiveResult seed,
-                                 Set<String> existingIds,
-                                 List<CognitiveResult> allResults,
-                                 float attenuation) {
-        String chainId = findMemoryByApproximateIndex(chainIdx);
-        if (chainId != null && !existingIds.contains(chainId)) {
-            existingIds.add(chainId);
-            String text = index.text(chainId);
-            MemorySource source = index.source(chainId);
-            String[] tags = index.tags(chainId);
-            float chainScore = seed.score() * attenuation * 0.2f;
-            allResults.add(new CognitiveResult(
-                    chainId, text, chainScore, seed.importance(), 0f,
-                    (short) 0, (byte) 0, seed.memoryType(), source,
-                    tags, 1.0f, 1.0f));
-        }
-    }
-}
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/pipeline/TagExtractor.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/pipeline/TagExtractor.java
deleted file mode 100644
index 29190ee..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/pipeline/TagExtractor.java
+++ /dev/null
@@ -1,57 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.pipeline;
-
-/**
- * Pluggable strategy for extracting synaptic tags from document content.
- *
- * <h3>Biological Analog: Synaptic Tagging</h3>
- * <p>In the Synaptic Tagging and Capture (STC) hypothesis, synapses are
- * "tagged" during learning to mark them for later consolidation. The
- * {@code TagExtractor} determines which contextual markers are assigned
- * to each memory, enabling the 64-bit Bloom filter pre-filtering that
- * eliminates ~95% of irrelevant memories in 1 CPU cycle each.</p>
- *
- * <h3>Implementations</h3>
- * <ul>
- *   <li>{@link ContentTagExtractor} — default: extracts tags from document
- *       path segments and significant content words</li>
- *   <li>{@code LlmTagExtractor} (spector-embed-ollama) — uses LLM to
- *       extract semantic tags via prompt</li>
- * </ul>
- *
- * @see CognitiveIngestionTarget
- * @see com.spectrayan.spector.memory.synapse.SynapticTagEncoder
- */
-@FunctionalInterface
-public interface TagExtractor {
-
-    /**
-     * Extracts synaptic tags from a document's identity and content.
-     *
-     * <p>The returned tags are hashed into a 64-bit Bloom filter via
-     * {@link com.spectrayan.spector.memory.synapse.SynapticTagEncoder}.
-     * Per the analysis doc §19, optimal performance is 5–10 tags per record
-     * (FPR &lt; 0.2%). Up to 50 tags is acceptable (FPR ~12%).</p>
-     *
-     * @param id   the document or chunk ID (may contain path segments)
-     * @param text the text content of the chunk
-     * @return array of tag strings (may be empty, must not be null)
-     */
-    String[] extract(String id, String text);
-
-    /**
-     * A no-op extractor that returns empty tags (disables Bloom filter gating).
-     */
-    TagExtractor NONE = (id, text) -> new String[0];
-}
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/prospective/ProspectiveScheduler.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/prospective/ProspectiveScheduler.java
deleted file mode 100644
index 34523d8..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/prospective/ProspectiveScheduler.java
+++ /dev/null
@@ -1,128 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.prospective;
-
-import com.spectrayan.spector.memory.synapse.SynapticTagEncoder;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.time.Duration;
-import java.time.Instant;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.concurrent.ConcurrentLinkedQueue;
-import java.util.concurrent.atomic.AtomicLong;
-
-/**
- * Time-triggered memory injection scheduler.
- *
- * <h3>Biological Analog: Prospective Memory</h3>
- * <p>Remembering to do something <em>in the future</em>. The hippocampus encodes
- * time-triggered retrieval cues — "pick up milk on the way home" is not recalled
- * until you approach the store.</p>
- *
- * <h3>Design</h3>
- * <p>The agent schedules a reminder via {@link #schedule}. A background check
- * (triggered during {@code recall()}) scans for due reminders and injects them
- * into the result set, regardless of query similarity.</p>
- *
- * <h3>Thread Safety</h3>
- * <p>Uses {@link ConcurrentLinkedQueue} for lock-free enqueue/dequeue.</p>
- */
-public final class ProspectiveScheduler {
-
-    private static final Logger log = LoggerFactory.getLogger(ProspectiveScheduler.class);
-
-    private final ConcurrentLinkedQueue<Reminder> reminders = new ConcurrentLinkedQueue<>();
-    private final AtomicLong idCounter = new AtomicLong(0);
-
-    /**
-     * Schedules a reminder to surface at a future time.
-     *
-     * @param text     the reminder text
-     * @param triggerAt when to surface the reminder
-     * @param tags     contextual tags for the reminder
-     * @return the created reminder
-     */
-    public Reminder schedule(String text, Instant triggerAt, String... tags) {
-        long synapticTags = SynapticTagEncoder.encode(tags);
-        Reminder reminder = new Reminder(
-                "prospective-" + idCounter.incrementAndGet(),
-                text,
-                triggerAt,
-                synapticTags,
-                Instant.now()
-        );
-
-        reminders.offer(reminder);
-        log.info("Prospective memory scheduled: '{}' at {}", text, triggerAt);
-        return reminder;
-    }
-
-    /**
-     * Convenience: schedule a reminder relative to now.
-     *
-     * @param text    the reminder text
-     * @param delay   duration from now
-     * @param tags    contextual tags
-     * @return the created reminder
-     */
-    public Reminder scheduleAfter(String text, Duration delay, String... tags) {
-        return schedule(text, Instant.now().plus(delay), tags);
-    }
-
-    /**
-     * Collects and removes all due reminders.
-     *
-     * <p>Called during each {@code recall()} to inject prospective memories
-     * into the result set.</p>
-     *
-     * @return list of due reminders (removed from the queue)
-     */
-    public List<Reminder> collectDue() {
-        return collectDueAt(Instant.now());
-    }
-
-    /**
-     * Collects reminders due at a specific time (for testing).
-     */
-    public List<Reminder> collectDueAt(Instant now) {
-        List<Reminder> due = new ArrayList<>();
-        reminders.removeIf(r -> {
-            if (r.isDueAt(now)) {
-                due.add(r);
-                log.info("Prospective memory triggered: '{}'", r.text());
-                return true;
-            }
-            return false;
-        });
-        return due;
-    }
-
-    /**
-     * Returns the number of pending reminders.
-     */
-    public int pendingCount() {
-        return reminders.size();
-    }
-
-    /**
-     * Cancels all pending reminders.
-     */
-    public void cancelAll() {
-        int count = reminders.size();
-        reminders.clear();
-        log.debug("Cancelled {} pending prospective memories", count);
-    }
-}
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/prospective/Reminder.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/prospective/Reminder.java
deleted file mode 100644
index 0c8cd5c..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/prospective/Reminder.java
+++ /dev/null
@@ -1,47 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.prospective;
-
-import java.time.Instant;
-
-/**
- * A scheduled memory reminder — surfaces at a future time regardless of query similarity.
- *
- * @param id          unique reminder identifier
- * @param text        the reminder text
- * @param triggerAt   when to surface this reminder
- * @param synapticTags Bloom filter tags for contextual association
- * @param created     when the reminder was created
- */
-public record Reminder(
-        String id,
-        String text,
-        Instant triggerAt,
-        long synapticTags,
-        Instant created
-) {
-
-    /**
-     * Returns true if this reminder is due (trigger time has passed).
-     */
-    public boolean isDue() {
-        return Instant.now().isAfter(triggerAt);
-    }
-
-    /**
-     * Returns true if this reminder is due at the specified time.
-     */
-    public boolean isDueAt(Instant now) {
-        return now.isAfter(triggerAt);
-    }
-}
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/synapse/CognitiveRecordLayout.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/synapse/CognitiveRecordLayout.java
deleted file mode 100644
index 46df562..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/synapse/CognitiveRecordLayout.java
+++ /dev/null
@@ -1,314 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.synapse;
-
-import com.spectrayan.spector.core.quantization.ScalarQuantizer;
-import com.spectrayan.spector.memory.MemoryType;
-
-import java.lang.foreign.MemorySegment;
-import java.lang.foreign.ValueLayout;
-
-import static com.spectrayan.spector.memory.synapse.SynapticHeaderConstants.*;
-
-/**
- * Read/write operations for cognitive memory records.
- *
- * <p>A cognitive record = versioned synaptic header + quantized vector payload.
- * The header size depends on the {@link HeaderLayout} version (32B/48B/64B).
- * This layout does <em>not</em> extend or modify the existing {@code VectorStoreLayout}
- * in {@code spector-storage}. It is a new, independent layout specific to
- * {@code spector-memory}.</p>
- *
- * <h3>Biological Analog: The Synaptic Tag</h3>
- * <p>In neuroscience, synapses are "tagged" during learning (Frey &amp; Morris, 1997)
- * to mark them for later consolidation. The synaptic header is the digital
- * equivalent — a lightweight marker enabling microsecond-latency routing,
- * filtering, and scoring without touching the heavy vector payload.</p>
- *
- * <h3>Polymorphic Header Layout</h3>
- * <p>The {@link HeaderLayout} sealed interface provides version-aware access
- * to header fields. V1 (32B) stores only core fields. V2 (48B) adds arousal
- * and storage strength. V3 (64B) adds a full cache-line-sized future buffer.
- * Extended fields return safe defaults when read via older layouts.</p>
- *
- * @param quantizedVecBytes number of bytes for the quantized vector payload
- * @param headerLayout      the versioned header layout to use for read/write
- *
- * @see HeaderLayout
- * @see HeaderLayoutV1
- * @see HeaderLayoutV2
- * @see HeaderLayoutV3
- */
-public record CognitiveRecordLayout(int quantizedVecBytes, HeaderLayout headerLayout) {
-
-    /**
-     * Backward-compatible constructor — defaults to V3 (64B) layout.
-     *
-     * @param quantizedVecBytes bytes per quantized vector payload
-     */
-    public CognitiveRecordLayout(int quantizedVecBytes) {
-        this(quantizedVecBytes, HeaderLayout.defaultLayout());
-    }
-
-    /**
-     * Total bytes per record (header + payload).
-     */
-    public int stride() {
-        return headerLayout.headerBytes() + quantizedVecBytes;
-    }
-
-    /**
-     * Offset where the quantized vector payload begins within a record.
-     */
-    public long vectorOffset(long recordOffset) {
-        return recordOffset + headerLayout.headerBytes();
-    }
-
-    // ── Write operations (delegate to HeaderLayout) ──
-
-    /**
-     * Writes a complete cognitive header to the given segment at the specified record offset.
-     */
-    public void writeHeader(MemorySegment segment, long offset, CognitiveHeader header) {
-        headerLayout.writeHeader(segment, offset, header);
-    }
-
-    /**
-     * Reads a complete cognitive header from the given segment at the specified record offset.
-     */
-    public CognitiveHeader readHeader(MemorySegment segment, long offset) {
-        return headerLayout.readHeader(segment, offset);
-    }
-
-    // ── Field-level accessors (delegate to HeaderLayout) ──
-
-    /** Reads the flags byte at the given record offset. */
-    public byte readFlags(MemorySegment segment, long offset) {
-        return headerLayout.readFlags(segment, offset);
-    }
-
-    /** Reads the synaptic tags (Bloom filter) at the given record offset. */
-    public long readSynapticTags(MemorySegment segment, long offset) {
-        return headerLayout.readSynapticTags(segment, offset);
-    }
-
-    /** Reads the valence byte at the given record offset. */
-    public byte readValence(MemorySegment segment, long offset) {
-        return headerLayout.readValence(segment, offset);
-    }
-
-    /** Reads the timestamp at the given record offset. */
-    public long readTimestamp(MemorySegment segment, long offset) {
-        return headerLayout.readTimestamp(segment, offset);
-    }
-
-    /** Reads the importance at the given record offset. */
-    public float readImportance(MemorySegment segment, long offset) {
-        return headerLayout.readImportance(segment, offset);
-    }
-
-    /** Reads the recall count at the given record offset. */
-    public int readRecallCount(MemorySegment segment, long offset) {
-        return headerLayout.readRecallCount(segment, offset);
-    }
-
-    /** Reads the arousal byte (unsigned 0-255). Returns 0 on V1 layouts. */
-    public byte readArousal(MemorySegment segment, long offset) {
-        return headerLayout.readArousal(segment, offset);
-    }
-
-    /** Reads the storage strength. Returns 1.0f on V1 layouts. */
-    public float readStorageStrength(MemorySegment segment, long offset) {
-        return headerLayout.readStorageStrength(segment, offset);
-    }
-
-    /**
-     * Increments the recall count (reconsolidation / LTP reinforcement).
-     *
-     * <h3>Semantic Note</h3>
-     * <p>As of the recall_count inflation fix, this is only called from
-     * {@code SpectorMemory.reinforce()}, meaning recall_count represents
-     * "times the agent explicitly found this useful" — not "times it appeared
-     * in search results." This produces more meaningful LTP adjustment.</p>
-     *
-     * <h3>Thread Safety</h3>
-     * <p>Uses a thread-safe atomic getAndAdd operation via {@link java.lang.invoke.VarHandle}.
-     * This guarantees atomicity and zero race conditions under heavy concurrent
-     * reinforcement workloads on modern multicore CPUs.</p>
-     *
-     * @return the previous recall count value
-     */
-    public int incrementRecallCount(MemorySegment segment, long offset) {
-        return headerLayout.incrementRecallCount(segment, offset);
-    }
-
-    /** Sets the tombstone flag (logical deletion / pruning by Deep Sleep). */
-    public void tombstone(MemorySegment segment, long offset) {
-        headerLayout.markTombstoned(segment, offset);
-    }
-
-    /** Sets the consolidated flag (memory has been reflected into Semantic tier). */
-    public void markConsolidated(MemorySegment segment, long offset) {
-        headerLayout.markConsolidated(segment, offset);
-    }
-
-    /**
-     * Sets the pinned flag (memory is exempt from decay and pruning).
-     *
-     * <p>Used by neurodivergent lossless consolidation (SYSTEMATIZER profile)
-     * to pin source episodes during REM sleep, preserving encyclopedic detail
-     * alongside the synthesized semantic fact.</p>
-     */
-    public void pin(MemorySegment segment, long offset) {
-        headerLayout.markPinned(segment, offset);
-    }
-
-    /**
-     * Sets the resolved flag (Zeigarnik Effect — marks a task/issue as done).
-     *
-     * <p>Once resolved, the memory succumbs to normal time-decay and gradually
-     * fades from active recall. Call {@link #markUnresolved} if the issue resurfaces.</p>
-     */
-    public void markResolved(MemorySegment segment, long offset) {
-        headerLayout.markResolved(segment, offset);
-    }
-
-    /**
-     * Clears the resolved flag (Zeigarnik Effect — re-opens a task/issue).
-     *
-     * <p>The memory re-enters the Zeigarnik loop: it resists decay and floats
-     * to the top of recall until explicitly resolved again.</p>
-     */
-    public void markUnresolved(MemorySegment segment, long offset) {
-        headerLayout.markUnresolved(segment, offset);
-    }
-
-    /** Updates the importance field. */
-    public void writeImportance(MemorySegment segment, long offset, float importance) {
-        headerLayout.writeImportance(segment, offset, importance);
-    }
-
-    /** Updates the timestamp field. */
-    public void writeTimestamp(MemorySegment segment, long offset, long timestampMs) {
-        headerLayout.writeTimestamp(segment, offset, timestampMs);
-    }
-
-    /** Merges synaptic tags by ORing the existing tags with new ones. */
-    public void mergeSynapticTags(MemorySegment segment, long offset, long additionalTags) {
-        headerLayout.mergeSynapticTags(segment, offset, additionalTags);
-    }
-
-    /** Writes the arousal byte. No-op on V1 layouts. */
-    public void writeArousal(MemorySegment segment, long offset, byte arousal) {
-        headerLayout.writeArousal(segment, offset, arousal);
-    }
-
-    /** Writes the storage strength. No-op on V1 layouts. */
-    public void writeStorageStrength(MemorySegment segment, long offset, float strength) {
-        headerLayout.writeStorageStrength(segment, offset, strength);
-    }
-
-    /**
-     * Writes a pre-quantized vector payload to the segment at the record's vector offset.
-     *
-     * @param segment      off-heap memory segment
-     * @param recordOffset byte offset of the record start
-     * @param quantizedVec pre-quantized byte array (e.g., from ScalarQuantizer.encode())
-     */
-    public void writeQuantizedVector(MemorySegment segment, long recordOffset, byte[] quantizedVec) {
-        MemorySegment.copy(MemorySegment.ofArray(quantizedVec), ValueLayout.JAVA_BYTE, 0,
-                segment, ValueLayout.JAVA_BYTE, vectorOffset(recordOffset), quantizedVec.length);
-    }
-
-    /**
-     * Quantizes a float32 vector using a calibrated {@link ScalarQuantizer} and writes
-     * the result directly to the segment at the record's vector offset.
-     *
-     * @param segment      off-heap memory segment
-     * @param recordOffset byte offset of the record start
-     * @param vector       float32 vector to quantize
-     * @param quantizer    calibrated ScalarQuantizer
-     */
-    public void writeQuantizedVector(MemorySegment segment, long recordOffset,
-                                      float[] vector, ScalarQuantizer quantizer) {
-        byte[] quantized = quantizer.encode(vector);
-        writeQuantizedVector(segment, recordOffset, quantized);
-    }
-
-    /**
-     * Immutable record holding all header fields across all layout versions.
-     *
-     * <p>V1-only code can use the 8-arg constructor; the extended fields
-     * default to {@code arousal=0} and {@code storageStrength=1.0f}.</p>
-     *
-     * @param timestampMs     when the memory was formed (epoch millis)
-     * @param synapticTags    64-bit Bloom filter of contextual markers
-     * @param exactNorm       L2 norm for SIMD distance computation
-     * @param importance      base importance (set by Prediction Error engine)
-     * @param recallCount     LTP reinforcement counter
-     * @param centroidId      IVF partition routing ID
-     * @param valence         signed emotion/reward (-128 to +127)
-     * @param flags           bit field (tombstone, type, consolidated, pinned, resolved)
-     * @param arousal         emotional intensity (unsigned 0-255, V2+)
-     * @param storageStrength Two-Factor Memory storage strength (V2+, default 1.0f)
-     */
-    public record CognitiveHeader(
-            long timestampMs,
-            long synapticTags,
-            float exactNorm,
-            float importance,
-            int recallCount,
-            short centroidId,
-            byte valence,
-            byte flags,
-            // ── Extended fields (V2+) ──
-            byte arousal,
-            float storageStrength
-    ) {
-        /**
-         * V1-compatible constructor — defaults for extended fields.
-         *
-         * <p>Provides backward compatibility for code that constructs headers
-         * without arousal or storage strength fields.</p>
-         */
-        public CognitiveHeader(long timestampMs, long synapticTags, float exactNorm,
-                                float importance, int recallCount, short centroidId,
-                                byte valence, byte flags) {
-            this(timestampMs, synapticTags, exactNorm, importance,
-                 recallCount, centroidId, valence, flags,
-                 (byte) 0, 1.0f);
-        }
-
-        /**
-         * Creates a new header for initial ingestion with default recall count and valence.
-         */
-        public static CognitiveHeader create(long timestampMs, long synapticTags, float exactNorm,
-                                              float importance, short centroidId, MemoryType memoryType) {
-            byte flags = SynapticHeaderConstants.withMemoryType((byte) 0, memoryType.ordinal());
-            return new CognitiveHeader(timestampMs, synapticTags, exactNorm, importance,
-                    0, centroidId, (byte) 0, flags);
-        }
-
-        /**
-         * Creates a new header with arousal for V2+ ingestion.
-         */
-        public static CognitiveHeader createWithArousal(long timestampMs, long synapticTags,
-                                                          float exactNorm, float importance,
-                                                          short centroidId, MemoryType memoryType,
-                                                          byte valence, byte arousal) {
-            byte flags = SynapticHeaderConstants.withMemoryType((byte) 0, memoryType.ordinal());
-            return new CognitiveHeader(timestampMs, synapticTags, exactNorm, importance,
-                    0, centroidId, valence, flags, arousal, 1.0f);
-        }
-    }
-}
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/synapse/CognitiveScorer.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/synapse/CognitiveScorer.java
deleted file mode 100644
index 757d4cf..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/synapse/CognitiveScorer.java
+++ /dev/null
@@ -1,344 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.synapse;
-
-import com.spectrayan.spector.core.similarity.SimilarityFunction;
-import com.spectrayan.spector.memory.RecallOptions;
-import com.spectrayan.spector.memory.synapse.CognitiveRecordLayout.CognitiveHeader;
-
-
-import java.lang.foreign.MemorySegment;
-import java.util.ArrayList;
-import java.util.Comparator;
-import java.util.List;
-import java.util.PriorityQueue;
-
-import static com.spectrayan.spector.memory.synapse.SynapticHeaderConstants.*;
-
-/**
- * Fused SIMD cognitive scoring loop — the heart of Spector Memory's performance.
- *
- * <h3>6-Phase Pipeline</h3>
- * <pre>
- *   Phase 1: Tombstone check          (~1 cycle)   — skip deleted records
- *   Phase 2: Synaptic tag gating      (~1 cycle)   — Bloom filter pre-screen
- *   Phase 3: Valence filter           (~2 cycles)  — skip outside valence range
- *   Phase 4: Temporal/importance pre-screen         — skip stale, low-importance
- *   Phase 5: Vector distance          (~200 cycles) — calibrated INT8 L2 distance
- *   Phase 6: Fused cognitive score    (~7 cycles)   — α·similarity + β·importance·decay
- * </pre>
- *
- * <h3>Biological Analog: Sensory Gating + Fused Retrieval</h3>
- * <p>The brain doesn't consider every memory for every retrieval. It gates early —
- * suppressing irrelevant memories before the expensive associative search begins.
- * This scorer replicates that: phases 1–4 eliminate 99% of records before the
- * expensive vector distance computation in phase 5.</p>
- *
- * <h3>Distance Computation</h3>
- * <p>Phase 5 delegates to {@link SimilarityFunction#computeQuantizedFromSegment},
- * the same zero-copy off-heap SIMD kernel used by {@code spector-storage} and
- * {@code spector-index}. When calibration parameters ({@code mins[]}/{@code scales[]})
- * are provided (from {@link com.spectrayan.spector.core.quantization.ScalarQuantizer}),
- * the distance computation uses proper per-dimension affine dequantization.
- * In uncalibrated mode, identity transform ({@code min=0, scale=1/255}) is used.</p>
- *
- * <h3>Performance</h3>
- * <p>With 1M episodic memories and 1% tag match rate:
- * Phases 1-4 eliminate 990K records in ~1ms → Phase 5 computes distance on ~10K
- * → Total ~2ms (vs ~200ms without gating).</p>
- */
-public final class CognitiveScorer {
-
-    private CognitiveScorer() {}
-
-    /**
-     * Represents a scored record for the priority queue.
-     *
-     * <p>Carries the full {@link CognitiveHeader} to avoid a second off-heap read
-     * during result assembly (P8 performance optimization).</p>
-     *
-     * @param lateral true if this record came from the lateral retrieval heap
-     */
-    public record ScoredRecord(long offset, float score, int index, CognitiveHeader header, boolean lateral)
-            implements Comparable<ScoredRecord> {
-
-        /** Standard (non-lateral) constructor for backward compatibility. */
-        public ScoredRecord(long offset, float score, int index, CognitiveHeader header) {
-            this(offset, score, index, header, false);
-        }
-
-        @Override
-        public int compareTo(ScoredRecord other) {
-            return Float.compare(this.score, other.score); // min-heap for top-K
-        }
-    }
-
-    /**
-     * Scans a memory segment and returns the top-K scored records.
-     * Uses uncalibrated identity quantization (for backward compatibility and tests).
-     *
-     * @param segment       off-heap segment containing cognitive records
-     * @param recordCount   number of records in the segment
-     * @param layout        cognitive record layout
-     * @param queryVector   the query vector (float32)
-     * @param options       recall options (topK, filters, weights)
-     * @param nowMs         current time in epoch millis
-     * @return top-K scored records sorted by descending score
-     */
-    public static List<ScoredRecord> score(MemorySegment segment, int recordCount,
-                                            CognitiveRecordLayout layout,
-                                            float[] queryVector, RecallOptions options,
-                                            long nowMs) {
-        return score(segment, recordCount, layout, queryVector, options, nowMs, 0L, null, null);
-    }
-
-    /**
-     * Scans a memory segment and returns the top-K scored records.
-     * Uses uncalibrated identity quantization with a base offset.
-     *
-     * @param segment       off-heap segment containing cognitive records
-     * @param recordCount   number of records in the segment
-     * @param layout        cognitive record layout
-     * @param queryVector   the query vector (float32)
-     * @param options       recall options (topK, filters, weights)
-     * @param nowMs         current time in epoch millis
-     * @param baseOffset    byte offset where records begin (e.g., metadata header size for mmap partitions)
-     * @return top-K scored records sorted by descending score
-     */
-    public static List<ScoredRecord> score(MemorySegment segment, int recordCount,
-                                            CognitiveRecordLayout layout,
-                                            float[] queryVector, RecallOptions options,
-                                            long nowMs, long baseOffset) {
-        return score(segment, recordCount, layout, queryVector, options, nowMs, baseOffset, null, null);
-    }
-
-    /**
-     * Scans a memory segment and returns the top-K scored records using calibrated
-     * {@link SimilarityFunction#computeQuantizedFromSegment} for distance computation.
-     *
-     * <p>When {@code mins} and {@code scales} are provided (from
-     * {@link com.spectrayan.spector.core.quantization.ScalarQuantizer}), the distance
-     * uses proper per-dimension affine dequantization: {@code value = unsigned_byte * scale[i] + min[i]}.
-     * When null, falls back to identity transform for backward compatibility.</p>
-     *
-     * @param segment       off-heap segment containing cognitive records
-     * @param recordCount   number of records in the segment
-     * @param layout        cognitive record layout
-     * @param queryVector   the query vector (float32)
-     * @param options       recall options (topK, filters, weights)
-     * @param nowMs         current time in epoch millis
-     * @param baseOffset    byte offset where records begin (e.g., metadata header size for mmap partitions)
-     * @param mins          per-dimension minimum values from ScalarQuantizer calibration (null = identity)
-     * @param scales        per-dimension scale values from ScalarQuantizer calibration (null = identity)
-     * @return top-K scored records sorted by descending score
-     */
-    public static List<ScoredRecord> score(MemorySegment segment, int recordCount,
-                                            CognitiveRecordLayout layout,
-                                            float[] queryVector, RecallOptions options,
-                                            long nowMs, long baseOffset,
-                                            float[] mins, float[] scales) {
-        int topK = options.topK();
-        long queryTagMask = options.synapticTagMask();
-        float minImportance = options.minImportance();
-        byte minValence = options.minValence();
-        byte maxValence = options.maxValence();
-        float alpha = options.alpha();
-        float beta = options.beta();
-        float tagRelevanceBoost = options.tagRelevanceBoost();
-        float strictness = options.strictnessCoefficient();
-
-        // ── Valence Alignment (State-Dependent Recall) ──
-        boolean valenceAlign = options.enableValenceAlignment();
-        byte queryValence = options.queryValence();
-
-        // ── Neurodivergent: Hyperfocus parameters ──
-        long hyperfocusMask = options.hyperfocusMask();
-        float hyperfocusBoost = options.hyperfocusBoost();
-
-        // ── Neurodivergent: Lateral retrieval parameters ──
-        boolean lateralMode = options.lateralMode();
-        float lateralDistanceThreshold = options.lateralDistanceThreshold();
-        int lateralMaxResults = options.lateralMaxResults();
-        float lateralMinTagOverlap = options.lateralMinTagOverlap();
-
-        // Resolve calibration: use identity transform if not calibrated
-        int dims = queryVector.length;
-        float[] effectiveMins = mins != null ? mins : IdentityCalibration.mins(dims);
-        float[] effectiveScales = scales != null ? scales : IdentityCalibration.scales(dims);
-
-        // Min-heap for top-K tracking (standard results)
-        PriorityQueue<ScoredRecord> heap = new PriorityQueue<>(topK + 1);
-
-        // Lateral heap: separate collection for cross-domain candidates
-        PriorityQueue<ScoredRecord> lateralHeap = lateralMode
-                ? new PriorityQueue<>(lateralMaxResults + 1)
-                : null;
-
-        int stride = layout.stride();
-        boolean hasArousal = layout.headerLayout().headerBytes() > HEADER_BYTES; // V2+ has arousal
-
-        for (int i = 0; i < recordCount; i++) {
-            long offset = baseOffset + (long) i * stride;
-
-            // ── Phase 1: Tombstone check (~1 cycle) ──
-            byte flags = segment.get(LAYOUT_FLAGS, offset + OFFSET_FLAGS);
-            if (isTombstoned(flags)) continue;
-
-            // ── Phase 2: Synaptic tag gating (~1 cycle) ──
-            // Neurodivergent: Hyperfocus uses STRICT equality (all mask bits must match).
-            // Standard mode uses containment (any overlap passes).
-            long recordTags = 0;
-            if (hyperfocusMask != 0) {
-                // Hyperfocus: strict equality gate — reject anything that doesn't
-                // match ALL focus tags. This creates a "tunnel" that blocks off-topic noise.
-                recordTags = segment.get(LAYOUT_SYNAPTIC_TAGS, offset + OFFSET_SYNAPTIC_TAGS);
-                if ((recordTags & hyperfocusMask) != hyperfocusMask) continue;
-            } else if (queryTagMask != 0) {
-                // Standard: broadened containment — skip only on zero overlap
-                recordTags = segment.get(LAYOUT_SYNAPTIC_TAGS, offset + OFFSET_SYNAPTIC_TAGS);
-                if ((recordTags & queryTagMask) == 0) continue;
-            }
-
-            // ── Phase 3: Valence filter (~2 cycles) ──
-            byte valence = segment.get(LAYOUT_VALENCE, offset + OFFSET_VALENCE);
-            if (valence < minValence || valence > maxValence) continue;
-
-            // ── Phase 4: Temporal/importance pre-screen with reconsolidation ──
-            float importance = segment.get(LAYOUT_IMPORTANCE, offset + OFFSET_IMPORTANCE);
-            if (importance < minImportance) continue;
-
-            long timestamp = segment.get(LAYOUT_TIMESTAMP, offset + OFFSET_TIMESTAMP);
-            int recallCount = segment.get(LAYOUT_RECALL_COUNT, offset + OFFSET_RECALL_COUNT);
-            int rawBucket = DecayStrategy.ageToBucket(timestamp, nowMs);
-            int adjustedBucket = DecayStrategy.adjustForReconsolidation(rawBucket, recallCount);
-
-            // Neurodivergent: Hyperfocus — clamp decay to 1.0 (zero time effect)
-            // for memories that match the focus mask.
-            boolean focusMatch = hyperfocusMask != 0
-                    && (recordTags & hyperfocusMask) == hyperfocusMask;
-            if (focusMatch) {
-                adjustedBucket = 0; // time ceases to exist for this topic
-            }
-
-            // Zeigarnik Effect: unresolved memories resist time-decay.
-            // They act like a biological "itch" — always fresh until explicitly resolved.
-            if (!isResolved(flags) && !isPinned(flags)) {
-                adjustedBucket = 0;
-            }
-
-            // Arousal-modulated decay: emotionally intense memories resist forgetting.
-            // On V2+ layouts, read the arousal byte; on V1, arousal=0 (no effect).
-            byte arousal = hasArousal
-                    ? segment.get(LAYOUT_AROUSAL, offset + OFFSET_AROUSAL)
-                    : (byte) 0;
-
-            // Skip if too old AND low importance (pinned/unresolved memories are exempt)
-            if (adjustedBucket >= DecayStrategy.MAX_BUCKET
-                    && importance < 1.0f
-                    && !isPinned(flags)
-                    && isResolved(flags)) {
-                continue;
-            }
-
-            // ── Phase 5: Calibrated INT8 L2 distance via SimilarityFunction ──
-            float l2dist = SimilarityFunction.EUCLIDEAN.computeQuantizedFromSegment(
-                    queryVector, segment, layout.vectorOffset(offset),
-                    effectiveMins, effectiveScales, layout.quantizedVecBytes());
-
-            // ── Phase 6: Fused cognitive score with weighted tag relevance (~7 cycles) ──
-            float tagOverlap = SynapticTagEncoder.overlapRatio(recordTags, queryTagMask);
-
-            // Neurodivergent: Lateral retrieval — collect tag-matched but
-            // semantically distant candidates into a separate heap.
-            if (lateralMode && l2dist > lateralDistanceThreshold
-                    && tagOverlap >= lateralMinTagOverlap) {
-                // Parabolic RBF: peaks at orthogonality (L2²=2.0 for normalized vectors).
-                // Formula: 1.0 - 0.25 * (L2² - 2.0)²
-                // Falls to 0.0 for both identical (L2²=0) and opposite (L2²=4) vectors.
-                // Costs ~3 FMA cycles vs the old formula's division risk.
-                float l2sq = l2dist * l2dist;
-                float diff = l2sq - 2.0f;
-                float lateralSimilarity = Math.max(0f, 1.0f - 0.25f * diff * diff);
-                float decay = DecayStrategy.decay(adjustedBucket) * DecayStrategy.arousalModifier(arousal);
-                decay = Math.min(1.0f, decay);
-                float lateralScore = lateralSimilarity * tagOverlap * importance * decay;
-
-                // Build header for lateral candidate
-                long synapticTags = recordTags;
-                float exactNorm = segment.get(LAYOUT_EXACT_NORM, offset + OFFSET_EXACT_NORM);
-                short centroidId = segment.get(LAYOUT_CENTROID_ID, offset + OFFSET_CENTROID_ID);
-                CognitiveHeader header = new CognitiveHeader(
-                        timestamp, synapticTags, exactNorm, importance,
-                        recallCount, centroidId, valence, flags);
-
-                if (lateralHeap.size() < lateralMaxResults) {
-                    lateralHeap.offer(new ScoredRecord(offset, lateralScore, i, header, true));
-                } else if (lateralScore > lateralHeap.peek().score()) {
-                    lateralHeap.poll();
-                    lateralHeap.offer(new ScoredRecord(offset, lateralScore, i, header, true));
-                }
-                // Lateral candidates are NOT also added to the standard heap.
-                // They are blended post-loop.
-                continue;
-            }
-
-            // Standard scoring path — with configurable strictness coefficient.
-            // strictness=1.0 → standard curve: 1/(1+L2)
-            // strictness=10.0 → Heaviside cliff: near-matches stay high, vague matches plummet
-            float similarity = 1.0f / (1.0f + l2dist * strictness);
-            float decay = DecayStrategy.decay(adjustedBucket) * DecayStrategy.arousalModifier(arousal);
-            decay = Math.min(1.0f, decay);
-            float baseScore = alpha * similarity + beta * importance * decay;
-
-            // Valence alignment: state-dependent recall (mood-congruent memory)
-            if (valenceAlign) {
-                float valenceMultiplier = 1.0f - (Math.abs(queryValence - valence) / 255.0f);
-                baseScore *= valenceMultiplier;
-            }
-
-            // Weighted tag relevance: partial matches get proportional boost
-            float finalScore = baseScore * (1.0f + tagOverlap * tagRelevanceBoost);
-
-            // Neurodivergent: Hyperfocus — post-score boost for focus-matched memories
-            if (focusMatch && hyperfocusBoost != 1.0f) {
-                finalScore *= hyperfocusBoost;
-            }
-
-            // Build header from already-read fields + 2 remaining (avoids double-read)
-            long synapticTags = queryTagMask != 0 || hyperfocusMask != 0
-                    ? recordTags  // already read in Phase 2
-                    : 0;
-            float exactNorm = segment.get(LAYOUT_EXACT_NORM, offset + OFFSET_EXACT_NORM);
-            short centroidId = segment.get(LAYOUT_CENTROID_ID, offset + OFFSET_CENTROID_ID);
-            CognitiveHeader header = new CognitiveHeader(
-                    timestamp, synapticTags, exactNorm, importance,
-                    recallCount, centroidId, valence, flags);
-
-            // Insert into top-K min-heap
-            if (heap.size() < topK) {
-                heap.offer(new ScoredRecord(offset, finalScore, i, header));
-            } else if (finalScore > heap.peek().score()) {
-                heap.poll();
-                heap.offer(new ScoredRecord(offset, finalScore, i, header));
-            }
-        }
-
-        // Merge standard + lateral results
-        List<ScoredRecord> results = new ArrayList<>(heap);
-        if (lateralHeap != null && !lateralHeap.isEmpty()) {
-            results.addAll(lateralHeap);
-        }
-        results.sort(Comparator.comparing(ScoredRecord::score).reversed());
-        return results;
-    }
-}
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/synapse/DecayStrategy.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/synapse/DecayStrategy.java
deleted file mode 100644
index 668ce70..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/synapse/DecayStrategy.java
+++ /dev/null
@@ -1,193 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.synapse;
-
-/**
- * SIMD-friendly bucket-based temporal decay with reconsolidation and arousal modulation.
- *
- * <h3>Why Not {@code Math.exp()}?</h3>
- * <p>The naive exponential decay formula {@code e^(-λ·Age)} requires ~150 CPU cycles
- * per vector (scalar-only, no Java Vector API lane operation for exp). At 1M memories,
- * this adds 50–100ms of pure scalar overhead, destroying the SIMD advantage.</p>
- *
- * <h3>Solution: Precomputed Bucket Lookup</h3>
- * <p>Quantize time into 8 discrete buckets and precompute decay multipliers.
- * This turns the exponential into a single float multiply (~7 cycles).</p>
- *
- * <h3>Reconsolidation (LTP)</h3>
- * <p>The {@link #adjustForReconsolidation} method shifts the bucket index down
- * based on recall count, making frequently-recalled memories behave as if they
- * are younger — the biological equivalent of Long-Term Potentiation.</p>
- *
- * <h3>Arousal Modulation (Amygdala)</h3>
- * <p>Emotionally intense memories resist forgetting. The {@link #arousalModifier}
- * method uses a precomputed 4-entry lookup (from unsigned arousal byte) to slow
- * decay for high-arousal memories — up to 65% slower at extreme arousal.</p>
- */
-public final class DecayStrategy {
-
-    private DecayStrategy() {}
-
-    // ── Bucket boundaries (milliseconds) ──
-    private static final long HOUR_MS  = 3_600_000L;
-    private static final long DAY_MS   = 86_400_000L;
-    private static final long WEEK_MS  = 604_800_000L;
-    private static final long MONTH_MS = 2_592_000_000L; // ~30 days
-
-    /**
-     * Precomputed decay multipliers for each time bucket.
-     * Index 0 = freshest (1.0), index 7 = oldest (0.05).
-     */
-    public static final float[] DECAY_BUCKETS = {
-            1.00f,  // Bucket 0: 0–1 hours ago
-            0.95f,  // Bucket 1: 1–6 hours ago
-            0.85f,  // Bucket 2: 6–24 hours ago
-            0.70f,  // Bucket 3: 1–3 days ago
-            0.50f,  // Bucket 4: 3–7 days ago
-            0.30f,  // Bucket 5: 1–4 weeks ago
-            0.15f,  // Bucket 6: 1–3 months ago
-            0.05f   // Bucket 7: 3+ months ago
-    };
-
-    /** Maximum bucket index. */
-    public static final int MAX_BUCKET = DECAY_BUCKETS.length - 1;
-
-    /**
-     * Maps a timestamp to a decay bucket index (0–7).
-     *
-     * @param timestampMs memory creation time (epoch millis)
-     * @param nowMs       current time (epoch millis)
-     * @return bucket index (0 = freshest, 7 = oldest)
-     */
-    public static int ageToBucket(long timestampMs, long nowMs) {
-        long ageMs = nowMs - timestampMs;
-        if (ageMs < 0) return 0; // future timestamp (clock skew) → treat as fresh
-
-        if (ageMs < HOUR_MS)          return 0;  // < 1 hour
-        if (ageMs < 6 * HOUR_MS)      return 1;  // 1–6 hours
-        if (ageMs < DAY_MS)           return 2;  // 6–24 hours
-        if (ageMs < 3 * DAY_MS)       return 3;  // 1–3 days
-        if (ageMs < WEEK_MS)          return 4;  // 3–7 days
-        if (ageMs < 4 * WEEK_MS)      return 5;  // 1–4 weeks
-        if (ageMs < 3 * MONTH_MS)     return 6;  // 1–3 months
-        return MAX_BUCKET;                         // 3+ months
-    }
-
-    /**
-     * Adjusts the raw decay bucket for reconsolidation (Long-Term Potentiation)
-     * using exponential half-life doubling via bit-shift.
-     *
-     * <p>Each recall effectively halves the memory's perceived age by shifting
-     * the bucket index right. This mirrors biological spaced repetition where
-     * each successful retrieval doubles the memory's half-life.</p>
-     *
-     * <table>
-     *   <tr><th>Recall Count</th><th>Shift</th><th>Effect</th></tr>
-     *   <tr><td>0</td><td>0</td><td>No change</td></tr>
-     *   <tr><td>1</td><td>÷2</td><td>bucket 6 → 3</td></tr>
-     *   <tr><td>2</td><td>÷4</td><td>bucket 6 → 1</td></tr>
-     *   <tr><td>3</td><td>÷8</td><td>bucket 7 → 0</td></tr>
-     *   <tr><td>5+</td><td>÷32</td><td>effectively fresh</td></tr>
-     * </table>
-     *
-     * @param rawBucket   original bucket from {@link #ageToBucket}
-     * @param recallCount number of times this memory has been recalled
-     * @return adjusted bucket index (clamped to 0)
-     */
-    public static int adjustForReconsolidation(int rawBucket, int recallCount) {
-        int shift = Math.min(recallCount, 5);
-        return rawBucket >> shift;
-    }
-
-    /**
-     * Returns the decay multiplier for the given (possibly adjusted) bucket.
-     *
-     * @param bucket bucket index (0–7)
-     * @return decay multiplier (1.0 = no decay, 0.05 = heavy decay)
-     */
-    public static float decay(int bucket) {
-        return DECAY_BUCKETS[Math.min(bucket, MAX_BUCKET)];
-    }
-
-    /**
-     * Convenience: computes the full decay multiplier for a memory, including
-     * reconsolidation adjustment.
-     *
-     * @param timestampMs memory creation time
-     * @param nowMs       current time
-     * @param recallCount number of recalls
-     * @return decay multiplier
-     */
-    public static float computeDecay(long timestampMs, long nowMs, int recallCount) {
-        int rawBucket = ageToBucket(timestampMs, nowMs);
-        int adjusted = adjustForReconsolidation(rawBucket, recallCount);
-        return decay(adjusted);
-    }
-
-    // ══════════════════════════════════════════════════════════════
-    // AROUSAL MODULATION — Amygdala-driven decay resistance
-    // ══════════════════════════════════════════════════════════════
-
-    /**
-     * Precomputed arousal-based decay modifiers.
-     *
-     * <p>Higher arousal = slower decay. The arousal byte is unsigned (0-255),
-     * divided into 4 quartile buckets. The modifier is multiplied with the
-     * base decay to produce the final effective decay.</p>
-     *
-     * <p>At arousal=0 (neutral), the modifier is 1.0 — no effect.
-     * At arousal=255 (extreme), memories decay 65% slower.</p>
-     */
-    public static final float[] AROUSAL_DECAY_MODIFIERS = {
-            1.00f,  // arousal 0-63:    neutral     → no change
-            1.15f,  // arousal 64-127:  mild        → 15% slower decay
-            1.35f,  // arousal 128-191: moderate    → 35% slower decay
-            1.65f   // arousal 192-255: extreme     → 65% slower decay
-    };
-
-    /**
-     * Returns the decay modifier based on arousal intensity.
-     *
-     * <p>Uses an unsigned interpretation of the arousal byte.
-     * At arousal=0, returns 1.0 (no effect). At arousal=255,
-     * returns 1.65 (65% slower decay).</p>
-     *
-     * @param arousal unsigned arousal byte (0-255)
-     * @return decay modifier (≥ 1.0)
-     */
-    public static float arousalModifier(byte arousal) {
-        int unsigned = Byte.toUnsignedInt(arousal);
-        int bucket = Math.min(3, unsigned / 64);
-        return AROUSAL_DECAY_MODIFIERS[bucket];
-    }
-
-    /**
-     * Computes the full decay multiplier including arousal modulation.
-     *
-     * <p>The arousal modifier scales the base decay upward (toward 1.0),
-     * making emotionally intense memories resist forgetting. The result
-     * is clamped to [0.0, 1.0] to prevent inverted decay.</p>
-     *
-     * @param timestampMs memory creation time
-     * @param nowMs       current time
-     * @param recallCount number of recalls
-     * @param arousal     emotional intensity (unsigned byte 0-255)
-     * @return arousal-modulated decay multiplier
-     */
-    public static float computeDecayWithArousal(long timestampMs, long nowMs,
-                                                  int recallCount, byte arousal) {
-        float baseDecay = computeDecay(timestampMs, nowMs, recallCount);
-        float modifier = arousalModifier(arousal);
-        return Math.min(1.0f, baseDecay * modifier);
-    }
-}
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/synapse/HeaderLayout.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/synapse/HeaderLayout.java
deleted file mode 100644
index 7c19512..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/synapse/HeaderLayout.java
+++ /dev/null
@@ -1,206 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.synapse;
-
-import java.lang.foreign.MemorySegment;
-import java.lang.foreign.ValueLayout;
-
-import static com.spectrayan.spector.memory.synapse.SynapticHeaderConstants.*;
-
-/**
- * Polymorphic, versioned accessor for synaptic memory record headers.
- *
- * <h3>Design: Strategy Pattern with Sealed Interface</h3>
- * <p>The header format evolves across versions (V1=32B, V2=48B, V3=64B).
- * Instead of branching on version in every hot-path read, we construct the
- * correct {@code HeaderLayout} implementation <em>once</em> at store-open time
- * and inject it everywhere. The JIT devirtualizes the sealed hierarchy into
- * direct method calls — zero overhead vs. hardcoded constants.</p>
- *
- * <h3>On-Load Compatibility</h3>
- * <p>Extended fields (V2+) have default implementations that return safe defaults:
- * {@code arousal=0}, {@code storageStrength=1.0f}. This means a V1 layout can
- * serve all read requests without error — callers never need to check the version.</p>
- *
- * <h3>Versions</h3>
- * <ul>
- *   <li><b>V1 (32B)</b> — Legacy/lightweight. Core fields only.</li>
- *   <li><b>V2 (48B)</b> — Adds arousal + storage_strength for emotional modulation
- *       and Two-Factor Memory research.</li>
- *   <li><b>V3 (64B)</b> — Full cache-line aligned layout with 32 bytes of future
- *       buffer. Default for all new stores.</li>
- * </ul>
- *
- * @see HeaderLayoutV1
- * @see HeaderLayoutV2
- * @see HeaderLayoutV3
- * @see CognitiveRecordLayout
- */
-public sealed interface HeaderLayout
-        permits HeaderLayoutV1, HeaderLayoutV2, HeaderLayoutV3 {
-
-    // ── Layout metadata ──
-
-    /** Header size in bytes for this layout version. */
-    int headerBytes();
-
-    /** Layout version number (1, 2, or 3). */
-    int version();
-
-    // ── Core field reads (all versions) ──
-
-    /** Reads the timestamp (epoch millis) at the given record offset. */
-    long readTimestamp(MemorySegment seg, long off);
-
-    /** Reads the 64-bit Bloom filter of contextual synaptic tags. */
-    long readSynapticTags(MemorySegment seg, long off);
-
-    /** Reads the L2 norm of the original float32 vector. */
-    float readExactNorm(MemorySegment seg, long off);
-
-    /** Reads the base importance score. */
-    float readImportance(MemorySegment seg, long off);
-
-    /** Reads the LTP reinforcement counter. */
-    int readRecallCount(MemorySegment seg, long off);
-
-    /** Reads the IVF centroid routing ID. */
-    short readCentroidId(MemorySegment seg, long off);
-
-    /** Reads the signed valence byte (-128 to +127). */
-    byte readValence(MemorySegment seg, long off);
-
-    /** Reads the flags bitfield. */
-    byte readFlags(MemorySegment seg, long off);
-
-    // ── Extended field reads (V2+ — defaults for V1) ──
-
-    /**
-     * Reads the arousal byte (emotional intensity, unsigned 0-255).
-     *
-     * <p>Use {@code Byte.toUnsignedInt()} for arithmetic. Higher arousal
-     * modulates decay — emotionally intense memories resist forgetting.</p>
-     *
-     * @return arousal value, or {@code 0} if this layout version does not support it
-     */
-    default byte readArousal(MemorySegment seg, long off) { return 0; }
-
-    /**
-     * Reads the storage strength for Two-Factor Memory (Bjork &amp; Bjork).
-     *
-     * <p>Storage strength determines how resistant a memory is to decay.
-     * It increases most when retrieval occurs right before forgetting
-     * (the spacing effect).</p>
-     *
-     * @return storage strength, or {@code 1.0f} (standard decay) if unsupported
-     */
-    default float readStorageStrength(MemorySegment seg, long off) { return 1.0f; }
-
-    // ── Extended field writes (V2+ — no-ops for V1) ──
-
-    /** Writes the arousal byte. No-op on V1 layouts. */
-    default void writeArousal(MemorySegment seg, long off, byte arousal) { /* no-op */ }
-
-    /** Writes the storage strength. No-op on V1 layouts. */
-    default void writeStorageStrength(MemorySegment seg, long off, float strength) { /* no-op */ }
-
-    // ── Full header read/write ──
-
-    /** Reads all header fields into an immutable {@link CognitiveRecordLayout.CognitiveHeader}. */
-    CognitiveRecordLayout.CognitiveHeader readHeader(MemorySegment seg, long off);
-
-    /** Writes all header fields from a {@link CognitiveRecordLayout.CognitiveHeader}. */
-    void writeHeader(MemorySegment seg, long off, CognitiveRecordLayout.CognitiveHeader header);
-
-    // ── Mutation helpers (shared logic, version-aware offsets) ──
-
-    /** Updates the importance field. */
-    void writeImportance(MemorySegment seg, long off, float importance);
-
-    /** Updates the timestamp field. */
-    void writeTimestamp(MemorySegment seg, long off, long timestampMs);
-
-    /** Merges synaptic tags via bitwise OR. */
-    void mergeSynapticTags(MemorySegment seg, long off, long additionalTags);
-
-    /** Sets the tombstone flag (logical deletion). */
-    void markTombstoned(MemorySegment seg, long off);
-
-    /** Sets the consolidated flag (reflected from Episodic → Semantic). */
-    void markConsolidated(MemorySegment seg, long off);
-
-    /**
-     * Sets the pinned flag (exempt from decay and pruning).
-     * Used by neurodivergent lossless consolidation (SYSTEMATIZER profile).
-     */
-    void markPinned(MemorySegment seg, long off);
-
-    /**
-     * Sets the resolved flag (Zeigarnik Effect — task is done).
-     * The memory succumbs to normal time-decay.
-     */
-    void markResolved(MemorySegment seg, long off);
-
-    /**
-     * Clears the resolved flag (Zeigarnik Effect — task re-opened).
-     * The memory re-enters the Zeigarnik loop and resists decay.
-     */
-    void markUnresolved(MemorySegment seg, long off);
-
-    /**
-     * Atomically increments the recall count (LTP reinforcement).
-     *
-     * @return the previous recall count value
-     */
-    int incrementRecallCount(MemorySegment seg, long off);
-
-    // ── Factory methods ──
-
-    /**
-     * Returns the layout for the given version number.
-     *
-     * @param version 1, 2, or 3
-     * @return the corresponding layout instance (singleton)
-     * @throws IllegalArgumentException if version is unknown
-     */
-    static HeaderLayout forVersion(int version) {
-        return switch (version) {
-            case 1 -> HeaderLayoutV1.INSTANCE;
-            case 2 -> HeaderLayoutV2.INSTANCE;
-            case 3 -> HeaderLayoutV3.INSTANCE;
-            default -> throw new IllegalArgumentException(
-                    "Unknown header layout version: " + version + ". Supported: 1, 2, 3");
-        };
-    }
-
-    /** Default layout for all new stores (V3, 64 bytes). */
-    static HeaderLayout defaultLayout() {
-        return HeaderLayoutV3.INSTANCE;
-    }
-
-    /**
-     * Detects the layout version from a store's metadata segment.
-     *
-     * <p>Reads the {@code header_version} byte from the store metadata.
-     * If the byte is 0 or the metadata is too small, assumes V1 (legacy).</p>
-     *
-     * @param metadataVersion the version byte from the store metadata (0 = legacy)
-     * @return the corresponding layout
-     */
-    static HeaderLayout detect(int metadataVersion) {
-        if (metadataVersion <= 0 || metadataVersion > 3) {
-            return HeaderLayoutV1.INSTANCE; // legacy or unknown → V1
-        }
-        return forVersion(metadataVersion);
-    }
-}
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/synapse/HeaderLayoutV1.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/synapse/HeaderLayoutV1.java
deleted file mode 100644
index ab65fee..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/synapse/HeaderLayoutV1.java
+++ /dev/null
@@ -1,165 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.synapse;
-
-import java.lang.foreign.MemorySegment;
-import java.lang.foreign.ValueLayout;
-
-import static com.spectrayan.spector.memory.synapse.SynapticHeaderConstants.*;
-
-/**
- * Header layout V1 — the original 32-byte format (legacy/lightweight).
- *
- * <h3>Layout (32 bytes)</h3>
- * <pre>
- *   Offset  Size  Field
- *   ──────  ────  ────────────────
- *    0      8B    timestamp_ms
- *    8      8B    synaptic_tags
- *   16      4B    exact_norm
- *   20      4B    importance
- *   24      4B    recall_count
- *   28      2B    centroid_id
- *   30      1B    valence
- *   31      1B    flags
- * </pre>
- *
- * <p>Extended fields (arousal, storage_strength) return safe defaults:
- * {@code arousal=0}, {@code storageStrength=1.0f}. Writes to extended
- * fields are silently ignored (no-op).</p>
- *
- * <h3>Use Cases</h3>
- * <ul>
- *   <li>Reading legacy store files created before V2/V3</li>
- *   <li>Lightweight/edge deployments that don't need extended fields</li>
- * </ul>
- */
-public record HeaderLayoutV1() implements HeaderLayout {
-
-    /** Singleton instance. */
-    public static final HeaderLayoutV1 INSTANCE = new HeaderLayoutV1();
-
-    /** V1 header size: 32 bytes. */
-    public static final int HEADER_SIZE = 32;
-
-    @Override public int headerBytes() { return HEADER_SIZE; }
-    @Override public int version() { return 1; }
-
-    // ── Core field reads ──
-
-    @Override public long readTimestamp(MemorySegment seg, long off) {
-        return seg.get(LAYOUT_TIMESTAMP, off + OFFSET_TIMESTAMP);
-    }
-
-    @Override public long readSynapticTags(MemorySegment seg, long off) {
-        return seg.get(LAYOUT_SYNAPTIC_TAGS, off + OFFSET_SYNAPTIC_TAGS);
-    }
-
-    @Override public float readExactNorm(MemorySegment seg, long off) {
-        return seg.get(LAYOUT_EXACT_NORM, off + OFFSET_EXACT_NORM);
-    }
-
-    @Override public float readImportance(MemorySegment seg, long off) {
-        return seg.get(LAYOUT_IMPORTANCE, off + OFFSET_IMPORTANCE);
-    }
-
-    @Override public int readRecallCount(MemorySegment seg, long off) {
-        return seg.get(LAYOUT_RECALL_COUNT, off + OFFSET_RECALL_COUNT);
-    }
-
-    @Override public short readCentroidId(MemorySegment seg, long off) {
-        return seg.get(LAYOUT_CENTROID_ID, off + OFFSET_CENTROID_ID);
-    }
-
-    @Override public byte readValence(MemorySegment seg, long off) {
-        return seg.get(LAYOUT_VALENCE, off + OFFSET_VALENCE);
-    }
-
-    @Override public byte readFlags(MemorySegment seg, long off) {
-        return seg.get(LAYOUT_FLAGS, off + OFFSET_FLAGS);
-    }
-
-    // ── Full header read/write ──
-
-    @Override
-    public CognitiveRecordLayout.CognitiveHeader readHeader(MemorySegment seg, long off) {
-        return new CognitiveRecordLayout.CognitiveHeader(
-                readTimestamp(seg, off),
-                readSynapticTags(seg, off),
-                readExactNorm(seg, off),
-                readImportance(seg, off),
-                readRecallCount(seg, off),
-                readCentroidId(seg, off),
-                readValence(seg, off),
-                readFlags(seg, off),
-                (byte) 0,   // arousal default
-                1.0f        // storageStrength default
-        );
-    }
-
-    @Override
-    public void writeHeader(MemorySegment seg, long off, CognitiveRecordLayout.CognitiveHeader header) {
-        seg.set(LAYOUT_TIMESTAMP,     off + OFFSET_TIMESTAMP,     header.timestampMs());
-        seg.set(LAYOUT_SYNAPTIC_TAGS, off + OFFSET_SYNAPTIC_TAGS, header.synapticTags());
-        seg.set(LAYOUT_EXACT_NORM,    off + OFFSET_EXACT_NORM,    header.exactNorm());
-        seg.set(LAYOUT_IMPORTANCE,    off + OFFSET_IMPORTANCE,    header.importance());
-        seg.set(LAYOUT_RECALL_COUNT,  off + OFFSET_RECALL_COUNT,  header.recallCount());
-        seg.set(LAYOUT_CENTROID_ID,   off + OFFSET_CENTROID_ID,   header.centroidId());
-        seg.set(LAYOUT_VALENCE,       off + OFFSET_VALENCE,       header.valence());
-        seg.set(LAYOUT_FLAGS,         off + OFFSET_FLAGS,         header.flags());
-    }
-
-    // ── Mutation helpers ──
-
-    @Override public void writeImportance(MemorySegment seg, long off, float importance) {
-        seg.set(LAYOUT_IMPORTANCE, off + OFFSET_IMPORTANCE, importance);
-    }
-
-    @Override public void writeTimestamp(MemorySegment seg, long off, long timestampMs) {
-        seg.set(LAYOUT_TIMESTAMP, off + OFFSET_TIMESTAMP, timestampMs);
-    }
-
-    @Override public void mergeSynapticTags(MemorySegment seg, long off, long additionalTags) {
-        long existing = readSynapticTags(seg, off);
-        seg.set(LAYOUT_SYNAPTIC_TAGS, off + OFFSET_SYNAPTIC_TAGS, existing | additionalTags);
-    }
-
-    @Override public void markTombstoned(MemorySegment seg, long off) {
-        byte flags = readFlags(seg, off);
-        seg.set(LAYOUT_FLAGS, off + OFFSET_FLAGS, (byte) (flags | FLAG_TOMBSTONE));
-    }
-
-    @Override public void markConsolidated(MemorySegment seg, long off) {
-        byte flags = readFlags(seg, off);
-        seg.set(LAYOUT_FLAGS, off + OFFSET_FLAGS, (byte) (flags | FLAG_CONSOLIDATED));
-    }
-
-    @Override public void markPinned(MemorySegment seg, long off) {
-        byte flags = readFlags(seg, off);
-        seg.set(LAYOUT_FLAGS, off + OFFSET_FLAGS, (byte) (flags | FLAG_PINNED));
-    }
-
-    @Override public void markResolved(MemorySegment seg, long off) {
-        byte flags = readFlags(seg, off);
-        seg.set(LAYOUT_FLAGS, off + OFFSET_FLAGS, (byte) (flags | FLAG_RESOLVED));
-    }
-
-    @Override public void markUnresolved(MemorySegment seg, long off) {
-        byte flags = readFlags(seg, off);
-        seg.set(LAYOUT_FLAGS, off + OFFSET_FLAGS, (byte) (flags & ~FLAG_RESOLVED));
-    }
-
-    @Override public int incrementRecallCount(MemorySegment seg, long off) {
-        return (int) VAR_HANDLE_RECALL_COUNT.getAndAdd(seg, off + OFFSET_RECALL_COUNT, 1);
-    }
-}
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/synapse/HeaderLayoutV2.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/synapse/HeaderLayoutV2.java
deleted file mode 100644
index c59e37c..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/synapse/HeaderLayoutV2.java
+++ /dev/null
@@ -1,195 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.synapse;
-
-import java.lang.foreign.MemorySegment;
-import java.lang.foreign.ValueLayout;
-
-import static com.spectrayan.spector.memory.synapse.SynapticHeaderConstants.*;
-
-/**
- * Header layout V2 — 48-byte format with arousal and storage strength.
- *
- * <h3>Layout (48 bytes)</h3>
- * <pre>
- *   Offset  Size  Field              Default
- *   ──────  ────  ─────────────────  ────────
- *    0-31   32B   (same as V1)
- *   32      1B    arousal            0 (unsigned 0-255)
- *   33      1B    header_version     2
- *   34      2B    _pad1              0 (alignment)
- *   36      4B    storage_strength   1.0f
- *   40      4B    _reserved_f1       0.0f
- *   44      2B    _reserved_s1       0
- *   46      1B    _reserved_b1       0
- *   47      1B    _reserved_b2       0
- * </pre>
- *
- * <h3>Use Cases</h3>
- * <ul>
- *   <li>Production deployments needing arousal-modulated decay</li>
- *   <li>Two-Factor Memory (Bjork &amp; Bjork) research with moderate memory footprint</li>
- * </ul>
- */
-public record HeaderLayoutV2() implements HeaderLayout {
-
-    /** Singleton instance. */
-    public static final HeaderLayoutV2 INSTANCE = new HeaderLayoutV2();
-
-    /** V2 header size: 48 bytes. */
-    public static final int HEADER_SIZE = 48;
-
-    // ── V2 extended field offsets ──
-    /** Offset of the arousal byte (unsigned, 0-255). */
-    public static final long OFFSET_AROUSAL          = 32L;
-    /** Offset of the header_version byte. */
-    public static final long OFFSET_HEADER_VERSION   = 33L;
-    /** Offset of the storage_strength float (4-byte aligned at 36). */
-    public static final long OFFSET_STORAGE_STRENGTH = 36L;
-
-    @Override public int headerBytes() { return HEADER_SIZE; }
-    @Override public int version() { return 2; }
-
-    // ── Core field reads (identical to V1) ──
-
-    @Override public long readTimestamp(MemorySegment seg, long off) {
-        return seg.get(LAYOUT_TIMESTAMP, off + OFFSET_TIMESTAMP);
-    }
-
-    @Override public long readSynapticTags(MemorySegment seg, long off) {
-        return seg.get(LAYOUT_SYNAPTIC_TAGS, off + OFFSET_SYNAPTIC_TAGS);
-    }
-
-    @Override public float readExactNorm(MemorySegment seg, long off) {
-        return seg.get(LAYOUT_EXACT_NORM, off + OFFSET_EXACT_NORM);
-    }
-
-    @Override public float readImportance(MemorySegment seg, long off) {
-        return seg.get(LAYOUT_IMPORTANCE, off + OFFSET_IMPORTANCE);
-    }
-
-    @Override public int readRecallCount(MemorySegment seg, long off) {
-        return seg.get(LAYOUT_RECALL_COUNT, off + OFFSET_RECALL_COUNT);
-    }
-
-    @Override public short readCentroidId(MemorySegment seg, long off) {
-        return seg.get(LAYOUT_CENTROID_ID, off + OFFSET_CENTROID_ID);
-    }
-
-    @Override public byte readValence(MemorySegment seg, long off) {
-        return seg.get(LAYOUT_VALENCE, off + OFFSET_VALENCE);
-    }
-
-    @Override public byte readFlags(MemorySegment seg, long off) {
-        return seg.get(LAYOUT_FLAGS, off + OFFSET_FLAGS);
-    }
-
-    // ── Extended field reads (V2) ──
-
-    @Override public byte readArousal(MemorySegment seg, long off) {
-        return seg.get(ValueLayout.JAVA_BYTE, off + OFFSET_AROUSAL);
-    }
-
-    @Override public float readStorageStrength(MemorySegment seg, long off) {
-        return seg.get(ValueLayout.JAVA_FLOAT, off + OFFSET_STORAGE_STRENGTH);
-    }
-
-    // ── Extended field writes (V2) ──
-
-    @Override public void writeArousal(MemorySegment seg, long off, byte arousal) {
-        seg.set(ValueLayout.JAVA_BYTE, off + OFFSET_AROUSAL, arousal);
-    }
-
-    @Override public void writeStorageStrength(MemorySegment seg, long off, float strength) {
-        seg.set(ValueLayout.JAVA_FLOAT, off + OFFSET_STORAGE_STRENGTH, strength);
-    }
-
-    // ── Full header read/write ──
-
-    @Override
-    public CognitiveRecordLayout.CognitiveHeader readHeader(MemorySegment seg, long off) {
-        return new CognitiveRecordLayout.CognitiveHeader(
-                readTimestamp(seg, off),
-                readSynapticTags(seg, off),
-                readExactNorm(seg, off),
-                readImportance(seg, off),
-                readRecallCount(seg, off),
-                readCentroidId(seg, off),
-                readValence(seg, off),
-                readFlags(seg, off),
-                readArousal(seg, off),
-                readStorageStrength(seg, off)
-        );
-    }
-
-    @Override
-    public void writeHeader(MemorySegment seg, long off, CognitiveRecordLayout.CognitiveHeader header) {
-        // Core fields
-        seg.set(LAYOUT_TIMESTAMP,     off + OFFSET_TIMESTAMP,     header.timestampMs());
-        seg.set(LAYOUT_SYNAPTIC_TAGS, off + OFFSET_SYNAPTIC_TAGS, header.synapticTags());
-        seg.set(LAYOUT_EXACT_NORM,    off + OFFSET_EXACT_NORM,    header.exactNorm());
-        seg.set(LAYOUT_IMPORTANCE,    off + OFFSET_IMPORTANCE,    header.importance());
-        seg.set(LAYOUT_RECALL_COUNT,  off + OFFSET_RECALL_COUNT,  header.recallCount());
-        seg.set(LAYOUT_CENTROID_ID,   off + OFFSET_CENTROID_ID,   header.centroidId());
-        seg.set(LAYOUT_VALENCE,       off + OFFSET_VALENCE,       header.valence());
-        seg.set(LAYOUT_FLAGS,         off + OFFSET_FLAGS,         header.flags());
-        // Extended fields
-        seg.set(ValueLayout.JAVA_BYTE,  off + OFFSET_AROUSAL,          header.arousal());
-        seg.set(ValueLayout.JAVA_BYTE,  off + OFFSET_HEADER_VERSION,   (byte) 2);
-        seg.set(ValueLayout.JAVA_FLOAT, off + OFFSET_STORAGE_STRENGTH, header.storageStrength());
-    }
-
-    // ── Mutation helpers (core fields — identical to V1) ──
-
-    @Override public void writeImportance(MemorySegment seg, long off, float importance) {
-        seg.set(LAYOUT_IMPORTANCE, off + OFFSET_IMPORTANCE, importance);
-    }
-
-    @Override public void writeTimestamp(MemorySegment seg, long off, long timestampMs) {
-        seg.set(LAYOUT_TIMESTAMP, off + OFFSET_TIMESTAMP, timestampMs);
-    }
-
-    @Override public void mergeSynapticTags(MemorySegment seg, long off, long additionalTags) {
-        long existing = readSynapticTags(seg, off);
-        seg.set(LAYOUT_SYNAPTIC_TAGS, off + OFFSET_SYNAPTIC_TAGS, existing | additionalTags);
-    }
-
-    @Override public void markTombstoned(MemorySegment seg, long off) {
-        byte flags = readFlags(seg, off);
-        seg.set(LAYOUT_FLAGS, off + OFFSET_FLAGS, (byte) (flags | FLAG_TOMBSTONE));
-    }
-
-    @Override public void markConsolidated(MemorySegment seg, long off) {
-        byte flags = readFlags(seg, off);
-        seg.set(LAYOUT_FLAGS, off + OFFSET_FLAGS, (byte) (flags | FLAG_CONSOLIDATED));
-    }
-
-    @Override public void markPinned(MemorySegment seg, long off) {
-        byte flags = readFlags(seg, off);
-        seg.set(LAYOUT_FLAGS, off + OFFSET_FLAGS, (byte) (flags | FLAG_PINNED));
-    }
-
-    @Override public void markResolved(MemorySegment seg, long off) {
-        byte flags = readFlags(seg, off);
-        seg.set(LAYOUT_FLAGS, off + OFFSET_FLAGS, (byte) (flags | FLAG_RESOLVED));
-    }
-
-    @Override public void markUnresolved(MemorySegment seg, long off) {
-        byte flags = readFlags(seg, off);
-        seg.set(LAYOUT_FLAGS, off + OFFSET_FLAGS, (byte) (flags & ~FLAG_RESOLVED));
-    }
-
-    @Override public int incrementRecallCount(MemorySegment seg, long off) {
-        return (int) VAR_HANDLE_RECALL_COUNT.getAndAdd(seg, off + OFFSET_RECALL_COUNT, 1);
-    }
-}
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/synapse/HeaderLayoutV3.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/synapse/HeaderLayoutV3.java
deleted file mode 100644
index 129654d..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/synapse/HeaderLayoutV3.java
+++ /dev/null
@@ -1,231 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.synapse;
-
-import java.lang.foreign.MemorySegment;
-import java.lang.foreign.ValueLayout;
-
-import static com.spectrayan.spector.memory.synapse.SynapticHeaderConstants.*;
-
-/**
- * Header layout V3 — the full 64-byte cache-line-aligned format.
- *
- * <h3>Layout (64 bytes)</h3>
- * <pre>
- *   Offset  Size  Field              Default    Notes
- *   ──────  ────  ─────────────────  ────────   ──────
- *    0-31   32B   (same as V1)                  Core fields
- *   32      1B    arousal            0          Emotional intensity (unsigned)
- *   33      1B    header_version     3          Format version
- *   34      2B    _pad1              0          Alignment padding
- *   36      4B    storage_strength   1.0f       Two-Factor Memory S(t)
- *   40      4B    _reserved_f1       0.0f       Future float field
- *   44      4B    _reserved_f2       0.0f       Future float field
- *   48      8B    _reserved_l1       0L         Future long (e.g., causal_link_id)
- *   56      4B    _reserved_i1       0          Future int field
- *   60      2B    _reserved_s1       0          Future short field
- *   62      1B    _reserved_b1       0          Future byte field
- *   63      1B    _reserved_b2       0          Future byte field
- * </pre>
- *
- * <p>The 64-byte size is a full CPU cache line, providing optimal alignment for
- * sequential scans. The vector payload starts at offset 64, perfectly aligned
- * for all SIMD register widths (SSE-128, AVX-256, AVX-512).</p>
- *
- * <p>The 32 bytes of reserved space (offsets 32-63 minus used fields) provide
- * ample buffer for future field additions without another format break.</p>
- *
- * <h3>Use Cases</h3>
- * <ul>
- *   <li>Default for all new stores — maximum future-proofing</li>
- *   <li>Full arousal + Two-Factor Memory + future extensions</li>
- * </ul>
- *
- * @see HeaderLayout
- * @see HeaderLayoutV1
- * @see HeaderLayoutV2
- */
-public record HeaderLayoutV3() implements HeaderLayout {
-
-    /** Singleton instance. */
-    public static final HeaderLayoutV3 INSTANCE = new HeaderLayoutV3();
-
-    /** V3 header size: 64 bytes (full cache line). */
-    public static final int HEADER_SIZE = 64;
-
-    // ── V3 field offsets (shared with V2 where applicable) ──
-    /** Offset of the arousal byte (unsigned, 0-255). */
-    public static final long OFFSET_AROUSAL          = 32L;
-    /** Offset of the header_version byte. */
-    public static final long OFFSET_HEADER_VERSION   = 33L;
-    /** Offset of the storage_strength float (4-byte aligned at 36). */
-    public static final long OFFSET_STORAGE_STRENGTH = 36L;
-    /** Offset of the first reserved float field. */
-    public static final long OFFSET_RESERVED_F1      = 40L;
-    /** Offset of the second reserved float field. */
-    public static final long OFFSET_RESERVED_F2      = 44L;
-    /** Offset of the reserved long field (e.g., causal_link_id). */
-    public static final long OFFSET_RESERVED_L1      = 48L;
-    /** Offset of the reserved int field. */
-    public static final long OFFSET_RESERVED_I1      = 56L;
-    /** Offset of the reserved short field. */
-    public static final long OFFSET_RESERVED_S1      = 60L;
-    /** Offset of the first reserved byte field. */
-    public static final long OFFSET_RESERVED_B1      = 62L;
-    /** Offset of the second reserved byte field. */
-    public static final long OFFSET_RESERVED_B2      = 63L;
-
-    @Override public int headerBytes() { return HEADER_SIZE; }
-    @Override public int version() { return 3; }
-
-    // ── Core field reads (identical to V1/V2) ──
-
-    @Override public long readTimestamp(MemorySegment seg, long off) {
-        return seg.get(LAYOUT_TIMESTAMP, off + OFFSET_TIMESTAMP);
-    }
-
-    @Override public long readSynapticTags(MemorySegment seg, long off) {
-        return seg.get(LAYOUT_SYNAPTIC_TAGS, off + OFFSET_SYNAPTIC_TAGS);
-    }
-
-    @Override public float readExactNorm(MemorySegment seg, long off) {
-        return seg.get(LAYOUT_EXACT_NORM, off + OFFSET_EXACT_NORM);
-    }
-
-    @Override public float readImportance(MemorySegment seg, long off) {
-        return seg.get(LAYOUT_IMPORTANCE, off + OFFSET_IMPORTANCE);
-    }
-
-    @Override public int readRecallCount(MemorySegment seg, long off) {
-        return seg.get(LAYOUT_RECALL_COUNT, off + OFFSET_RECALL_COUNT);
-    }
-
-    @Override public short readCentroidId(MemorySegment seg, long off) {
-        return seg.get(LAYOUT_CENTROID_ID, off + OFFSET_CENTROID_ID);
-    }
-
-    @Override public byte readValence(MemorySegment seg, long off) {
-        return seg.get(LAYOUT_VALENCE, off + OFFSET_VALENCE);
-    }
-
-    @Override public byte readFlags(MemorySegment seg, long off) {
-        return seg.get(LAYOUT_FLAGS, off + OFFSET_FLAGS);
-    }
-
-    // ── Extended field reads (V3) ──
-
-    @Override public byte readArousal(MemorySegment seg, long off) {
-        return seg.get(ValueLayout.JAVA_BYTE, off + OFFSET_AROUSAL);
-    }
-
-    @Override public float readStorageStrength(MemorySegment seg, long off) {
-        return seg.get(ValueLayout.JAVA_FLOAT, off + OFFSET_STORAGE_STRENGTH);
-    }
-
-    // ── Extended field writes (V3) ──
-
-    @Override public void writeArousal(MemorySegment seg, long off, byte arousal) {
-        seg.set(ValueLayout.JAVA_BYTE, off + OFFSET_AROUSAL, arousal);
-    }
-
-    @Override public void writeStorageStrength(MemorySegment seg, long off, float strength) {
-        seg.set(ValueLayout.JAVA_FLOAT, off + OFFSET_STORAGE_STRENGTH, strength);
-    }
-
-    // ── Full header read/write ──
-
-    @Override
-    public CognitiveRecordLayout.CognitiveHeader readHeader(MemorySegment seg, long off) {
-        return new CognitiveRecordLayout.CognitiveHeader(
-                readTimestamp(seg, off),
-                readSynapticTags(seg, off),
-                readExactNorm(seg, off),
-                readImportance(seg, off),
-                readRecallCount(seg, off),
-                readCentroidId(seg, off),
-                readValence(seg, off),
-                readFlags(seg, off),
-                readArousal(seg, off),
-                readStorageStrength(seg, off)
-        );
-    }
-
-    @Override
-    public void writeHeader(MemorySegment seg, long off, CognitiveRecordLayout.CognitiveHeader header) {
-        // Core fields
-        seg.set(LAYOUT_TIMESTAMP,     off + OFFSET_TIMESTAMP,     header.timestampMs());
-        seg.set(LAYOUT_SYNAPTIC_TAGS, off + OFFSET_SYNAPTIC_TAGS, header.synapticTags());
-        seg.set(LAYOUT_EXACT_NORM,    off + OFFSET_EXACT_NORM,    header.exactNorm());
-        seg.set(LAYOUT_IMPORTANCE,    off + OFFSET_IMPORTANCE,    header.importance());
-        seg.set(LAYOUT_RECALL_COUNT,  off + OFFSET_RECALL_COUNT,  header.recallCount());
-        seg.set(LAYOUT_CENTROID_ID,   off + OFFSET_CENTROID_ID,   header.centroidId());
-        seg.set(LAYOUT_VALENCE,       off + OFFSET_VALENCE,       header.valence());
-        seg.set(LAYOUT_FLAGS,         off + OFFSET_FLAGS,         header.flags());
-        // Extended fields
-        seg.set(ValueLayout.JAVA_BYTE,  off + OFFSET_AROUSAL,          header.arousal());
-        seg.set(ValueLayout.JAVA_BYTE,  off + OFFSET_HEADER_VERSION,   (byte) 3);
-        seg.set(ValueLayout.JAVA_FLOAT, off + OFFSET_STORAGE_STRENGTH, header.storageStrength());
-        // Zero reserved fields (ensure clean state)
-        seg.set(ValueLayout.JAVA_FLOAT, off + OFFSET_RESERVED_F1, 0.0f);
-        seg.set(ValueLayout.JAVA_FLOAT, off + OFFSET_RESERVED_F2, 0.0f);
-        seg.set(ValueLayout.JAVA_LONG,  off + OFFSET_RESERVED_L1, 0L);
-        seg.set(ValueLayout.JAVA_INT,   off + OFFSET_RESERVED_I1, 0);
-        seg.set(ValueLayout.JAVA_SHORT, off + OFFSET_RESERVED_S1, (short) 0);
-        seg.set(ValueLayout.JAVA_BYTE,  off + OFFSET_RESERVED_B1, (byte) 0);
-        seg.set(ValueLayout.JAVA_BYTE,  off + OFFSET_RESERVED_B2, (byte) 0);
-    }
-
-    // ── Mutation helpers (core fields — identical to V1/V2) ──
-
-    @Override public void writeImportance(MemorySegment seg, long off, float importance) {
-        seg.set(LAYOUT_IMPORTANCE, off + OFFSET_IMPORTANCE, importance);
-    }
-
-    @Override public void writeTimestamp(MemorySegment seg, long off, long timestampMs) {
-        seg.set(LAYOUT_TIMESTAMP, off + OFFSET_TIMESTAMP, timestampMs);
-    }
-
-    @Override public void mergeSynapticTags(MemorySegment seg, long off, long additionalTags) {
-        long existing = readSynapticTags(seg, off);
-        seg.set(LAYOUT_SYNAPTIC_TAGS, off + OFFSET_SYNAPTIC_TAGS, existing | additionalTags);
-    }
-
-    @Override public void markTombstoned(MemorySegment seg, long off) {
-        byte flags = readFlags(seg, off);
-        seg.set(LAYOUT_FLAGS, off + OFFSET_FLAGS, (byte) (flags | FLAG_TOMBSTONE));
-    }
-
-    @Override public void markConsolidated(MemorySegment seg, long off) {
-        byte flags = readFlags(seg, off);
-        seg.set(LAYOUT_FLAGS, off + OFFSET_FLAGS, (byte) (flags | FLAG_CONSOLIDATED));
-    }
-
-    @Override public void markPinned(MemorySegment seg, long off) {
-        byte flags = readFlags(seg, off);
-        seg.set(LAYOUT_FLAGS, off + OFFSET_FLAGS, (byte) (flags | FLAG_PINNED));
-    }
-
-    @Override public void markResolved(MemorySegment seg, long off) {
-        byte flags = readFlags(seg, off);
-        seg.set(LAYOUT_FLAGS, off + OFFSET_FLAGS, (byte) (flags | FLAG_RESOLVED));
-    }
-
-    @Override public void markUnresolved(MemorySegment seg, long off) {
-        byte flags = readFlags(seg, off);
-        seg.set(LAYOUT_FLAGS, off + OFFSET_FLAGS, (byte) (flags & ~FLAG_RESOLVED));
-    }
-
-    @Override public int incrementRecallCount(MemorySegment seg, long off) {
-        return (int) VAR_HANDLE_RECALL_COUNT.getAndAdd(seg, off + OFFSET_RECALL_COUNT, 1);
-    }
-}
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/synapse/HeaderMigrator.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/synapse/HeaderMigrator.java
deleted file mode 100644
index 20c3a8e..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/synapse/HeaderMigrator.java
+++ /dev/null
@@ -1,350 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.synapse;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.io.IOException;
-import java.io.UncheckedIOException;
-import java.lang.foreign.Arena;
-import java.lang.foreign.MemorySegment;
-import java.lang.foreign.ValueLayout;
-import java.nio.ByteBuffer;
-import java.nio.channels.FileChannel;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.nio.file.StandardCopyOption;
-import java.nio.file.StandardOpenOption;
-import java.time.Duration;
-import java.time.Instant;
-
-/**
- * One-time migration tool for converting store files between header layout versions.
- *
- * <h3>Migration Strategy</h3>
- * <ol>
- *   <li>Read source file with source layout</li>
- *   <li>Write to temporary file ({@code .migrating}) with target layout</li>
- *   <li>Verify record count matches</li>
- *   <li>Back up original file ({@code .vN.bak})</li>
- *   <li>Atomic rename: temp → original</li>
- *   <li>Update metadata header with new version/stride</li>
- * </ol>
- *
- * <h3>Safety</h3>
- * <p>If the process crashes mid-migration, the original file is untouched —
- * the atomic rename (step 5) hasn't happened yet. On next startup, detect
- * the {@code .migrating} temp file and clean it up.</p>
- *
- * <h3>Supported Paths</h3>
- * <ul>
- *   <li>V1 (32B) → V2 (48B): arousal=0, storageStrength=1.0f</li>
- *   <li>V1 (32B) → V3 (64B): arousal=0, storageStrength=1.0f, reserved=0</li>
- *   <li>V2 (48B) → V3 (64B): reserved=0</li>
- *   <li>V3 (64B) → V2 (48B): ⚠️ lossy — reserved fields dropped</li>
- *   <li>V3 (64B) → V1 (32B): ⚠️ lossy — arousal, storageStrength, reserved dropped</li>
- *   <li>V2 (48B) → V1 (32B): ⚠️ lossy — arousal, storageStrength dropped</li>
- * </ul>
- *
- * @see HeaderLayout
- */
-public final class HeaderMigrator {
-
-    private static final Logger log = LoggerFactory.getLogger(HeaderMigrator.class);
-
-    /** Metadata header size in bytes (same as AbstractTierStore.METADATA_HEADER_BYTES). */
-    private static final int METADATA_HEADER_BYTES = 64;
-
-    /** Metadata field offsets (mirrors AbstractTierStore). */
-    private static final int META_MAGIC    = 0;
-    private static final int META_VERSION  = 4;
-    private static final int META_COUNT    = 8;
-    private static final int META_CAPACITY = 12;
-    private static final int META_STRIDE   = 16;
-    private static final int META_TIER_ORD = 20;
-
-    /** Magic number for tier files: "TIER" in ASCII. */
-    private static final int TIER_MAGIC = 0x54494552;
-
-    private HeaderMigrator() {}
-
-    /**
-     * Migrates a persistent store file from one header layout to another.
-     *
-     * <p>The migration is atomic: the original file is backed up before
-     * the migrated file replaces it. If the target version is lower than
-     * the source version (downgrade), this is a lossy operation — extended
-     * fields are discarded.</p>
-     *
-     * @param storePath path to the persistent store file
-     * @param source    current layout (detected from file metadata)
-     * @param target    desired layout version
-     * @param vectorBytes bytes per quantized vector (needed for stride calculation)
-     * @param isHeaderOnly true for header-only stores (e.g., SemanticMemoryStore)
-     * @return migration report with statistics
-     * @throws IllegalArgumentException if source and target are the same version
-     * @throws UncheckedIOException if file I/O fails
-     */
-    public static MigrationReport migrate(Path storePath, HeaderLayout source,
-                                            HeaderLayout target, int vectorBytes,
-                                            boolean isHeaderOnly) {
-        if (source.version() == target.version()) {
-            throw new IllegalArgumentException(
-                    "Source and target are the same version: V" + source.version());
-        }
-
-        boolean isDowngrade = target.version() < source.version();
-        if (isDowngrade) {
-            log.warn("LOSSY DOWNGRADE: V{} → V{} — extended fields will be discarded",
-                    source.version(), target.version());
-        }
-
-        Instant start = Instant.now();
-        Path tempPath = storePath.resolveSibling(storePath.getFileName() + ".migrating");
-        Path backupPath = storePath.resolveSibling(
-                storePath.getFileName() + ".v" + source.version() + ".bak");
-
-        log.info("Migrating {} from V{} ({}B) to V{} ({}B){}",
-                storePath.getFileName(), source.version(), source.headerBytes(),
-                target.version(), target.headerBytes(),
-                isDowngrade ? " [LOSSY]" : "");
-
-        int recordCount;
-        long bytesBefore;
-
-        try {
-            bytesBefore = Files.size(storePath);
-        } catch (IOException e) {
-            throw new UncheckedIOException("Cannot read source file size: " + storePath, e);
-        }
-
-        try (Arena sourceArena = Arena.ofConfined();
-             Arena targetArena = Arena.ofConfined()) {
-
-            // ── Step 1: Open source file ──
-            MemorySegment sourceSegment;
-            try (FileChannel sourceCh = FileChannel.open(storePath, StandardOpenOption.READ)) {
-                sourceSegment = sourceCh.map(FileChannel.MapMode.READ_ONLY, 0,
-                        sourceCh.size(), sourceArena);
-            }
-
-            // Read metadata
-            int magic = sourceSegment.get(ValueLayout.JAVA_INT, META_MAGIC);
-            if (magic != TIER_MAGIC) {
-                throw new IllegalStateException(
-                        "Invalid tier magic in " + storePath + ": 0x" + Integer.toHexString(magic));
-            }
-
-            recordCount = sourceSegment.get(ValueLayout.JAVA_INT, META_COUNT);
-            int capacity = sourceSegment.get(ValueLayout.JAVA_INT, META_CAPACITY);
-            int tierOrd = sourceSegment.get(ValueLayout.JAVA_INT, META_TIER_ORD);
-
-            int sourceRecordStride = isHeaderOnly ? source.headerBytes()
-                    : source.headerBytes() + vectorBytes;
-            int targetRecordStride = isHeaderOnly ? target.headerBytes()
-                    : target.headerBytes() + vectorBytes;
-
-            long targetDataSize = (long) targetRecordStride * capacity;
-            long targetTotalSize = METADATA_HEADER_BYTES + targetDataSize;
-
-            // ── Step 2: Create target temp file ──
-            try (FileChannel targetCh = FileChannel.open(tempPath,
-                    StandardOpenOption.CREATE_NEW,
-                    StandardOpenOption.READ,
-                    StandardOpenOption.WRITE)) {
-
-                // Extend file
-                targetCh.position(targetTotalSize - 1);
-                targetCh.write(ByteBuffer.wrap(new byte[]{0}));
-
-                MemorySegment targetSegment = targetCh.map(FileChannel.MapMode.READ_WRITE,
-                        0, targetTotalSize, targetArena);
-
-                // Write metadata header
-                targetSegment.set(ValueLayout.JAVA_INT, META_MAGIC, TIER_MAGIC);
-                targetSegment.set(ValueLayout.JAVA_INT, META_VERSION, TIER_MAGIC);
-                targetSegment.set(ValueLayout.JAVA_INT, META_COUNT, recordCount);
-                targetSegment.set(ValueLayout.JAVA_INT, META_CAPACITY, capacity);
-                targetSegment.set(ValueLayout.JAVA_INT, META_STRIDE, targetRecordStride);
-                targetSegment.set(ValueLayout.JAVA_INT, META_TIER_ORD, tierOrd);
-
-                // ── Step 3: Migrate records ──
-                for (int i = 0; i < recordCount; i++) {
-                    long sourceOff = METADATA_HEADER_BYTES + (long) i * sourceRecordStride;
-                    long targetOff = METADATA_HEADER_BYTES + (long) i * targetRecordStride;
-
-                    // Read header from source layout (extended fields get defaults)
-                    CognitiveRecordLayout.CognitiveHeader header =
-                            source.readHeader(sourceSegment, sourceOff);
-
-                    // Write header with target layout
-                    target.writeHeader(targetSegment, targetOff, header);
-
-                    // Copy vector payload if present
-                    if (!isHeaderOnly && vectorBytes > 0) {
-                        long sourceVecOff = sourceOff + source.headerBytes();
-                        long targetVecOff = targetOff + target.headerBytes();
-                        MemorySegment.copy(sourceSegment, sourceVecOff,
-                                targetSegment, targetVecOff, vectorBytes);
-                    }
-                }
-
-                // Force to disk
-                targetSegment.force();
-
-                log.info("Migrated {} records from V{} to V{}", recordCount,
-                        source.version(), target.version());
-            }
-
-            // ── Step 4: Atomic swap ──
-            // Back up original
-            Files.move(storePath, backupPath, StandardCopyOption.REPLACE_EXISTING);
-            // Rename temp → original
-            Files.move(tempPath, storePath, StandardCopyOption.ATOMIC_MOVE);
-
-            long bytesAfter;
-            try {
-                bytesAfter = Files.size(storePath);
-            } catch (IOException e) {
-                bytesAfter = targetTotalSize;
-            }
-
-            Duration duration = Duration.between(start, Instant.now());
-
-            log.info("Migration complete: {} records, {}KB → {}KB, took {}ms, backup at {}",
-                    recordCount, bytesBefore / 1024, bytesAfter / 1024,
-                    duration.toMillis(), backupPath);
-
-            return new MigrationReport(recordCount, bytesBefore, bytesAfter,
-                    duration, backupPath, isDowngrade);
-
-        } catch (IOException e) {
-            // Clean up temp file on failure
-            try {
-                Files.deleteIfExists(tempPath);
-            } catch (IOException cleanupEx) {
-                log.warn("Failed to clean up temp file: {}", tempPath, cleanupEx);
-            }
-            throw new UncheckedIOException("Migration failed: " + storePath, e);
-        }
-    }
-
-    /**
-     * Estimates the target file size after migration without performing it.
-     *
-     * @param currentFileSize current file size in bytes
-     * @param recordCount     number of records
-     * @param source          current layout
-     * @param target          target layout
-     * @param vectorBytes     bytes per quantized vector
-     * @param isHeaderOnly    true for header-only stores
-     * @return estimated target file size in bytes
-     */
-    public static long estimateTargetSize(long currentFileSize, int recordCount,
-                                           HeaderLayout source, HeaderLayout target,
-                                           int vectorBytes, boolean isHeaderOnly) {
-        int targetRecordStride = isHeaderOnly ? target.headerBytes()
-                : target.headerBytes() + vectorBytes;
-        int capacity = (int) ((currentFileSize - METADATA_HEADER_BYTES)
-                / (isHeaderOnly ? source.headerBytes() : source.headerBytes() + vectorBytes));
-        return METADATA_HEADER_BYTES + (long) targetRecordStride * capacity;
-    }
-
-    /**
-     * Detects the header layout version from a store file's metadata.
-     *
-     * <p>Reads the stride field from the metadata header and infers the layout
-     * version from it, since each version has a unique header size.</p>
-     *
-     * @param storePath   path to the store file
-     * @param vectorBytes bytes per quantized vector
-     * @param isHeaderOnly true for header-only stores
-     * @return detected header layout
-     */
-    public static HeaderLayout detectVersion(Path storePath, int vectorBytes,
-                                              boolean isHeaderOnly) {
-        try (FileChannel ch = FileChannel.open(storePath, StandardOpenOption.READ)) {
-            if (ch.size() < METADATA_HEADER_BYTES) {
-                return HeaderLayoutV1.INSTANCE; // too small, assume legacy
-            }
-
-            ByteBuffer buf = ByteBuffer.allocate(METADATA_HEADER_BYTES);
-            ch.read(buf);
-            buf.flip();
-
-            int magic = buf.getInt(META_MAGIC);
-            if (magic != TIER_MAGIC) {
-                return HeaderLayoutV1.INSTANCE; // invalid magic, assume legacy
-            }
-
-            int stride = buf.getInt(META_STRIDE);
-            int headerBytes = isHeaderOnly ? stride : stride - vectorBytes;
-
-            return switch (headerBytes) {
-                case 32 -> HeaderLayoutV1.INSTANCE;
-                case 48 -> HeaderLayoutV2.INSTANCE;
-                case 64 -> HeaderLayoutV3.INSTANCE;
-                default -> {
-                    log.warn("Unknown header size {} in {}, defaulting to V1", headerBytes, storePath);
-                    yield HeaderLayoutV1.INSTANCE;
-                }
-            };
-        } catch (IOException e) {
-            log.warn("Cannot detect header version from {}: {}", storePath, e.getMessage());
-            return HeaderLayoutV1.INSTANCE;
-        }
-    }
-
-    /**
-     * Cleans up orphaned {@code .migrating} temp files from interrupted migrations.
-     *
-     * @param storePath path to the store file
-     */
-    public static void cleanupOrphanedTempFile(Path storePath) {
-        Path tempPath = storePath.resolveSibling(storePath.getFileName() + ".migrating");
-        try {
-            if (Files.deleteIfExists(tempPath)) {
-                log.info("Cleaned up orphaned migration temp file: {}", tempPath);
-            }
-        } catch (IOException e) {
-            log.warn("Failed to clean up orphaned temp file: {}", tempPath, e);
-        }
-    }
-
-    /**
-     * Migration result.
-     *
-     * @param recordsMigrated number of records migrated
-     * @param bytesBefore     file size before migration
-     * @param bytesAfter      file size after migration
-     * @param duration        migration duration
-     * @param backupPath      path to the backup of the original file
-     * @param lossy           true if the migration was a downgrade (data loss)
-     */
-    public record MigrationReport(
-            int recordsMigrated,
-            long bytesBefore,
-            long bytesAfter,
-            Duration duration,
-            Path backupPath,
-            boolean lossy
-    ) {
-        @Override
-        public String toString() {
-            return String.format("MigrationReport[records=%d, %dKB→%dKB, %dms, backup=%s%s]",
-                    recordsMigrated, bytesBefore / 1024, bytesAfter / 1024,
-                    duration.toMillis(), backupPath, lossy ? ", LOSSY" : "");
-        }
-    }
-}
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/synapse/IdentityCalibration.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/synapse/IdentityCalibration.java
deleted file mode 100644
index 947fbb3..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/synapse/IdentityCalibration.java
+++ /dev/null
@@ -1,60 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.synapse;
-
-import java.util.concurrent.ConcurrentHashMap;
-
-/**
- * Flyweight factory for identity calibration arrays.
- *
- * <h3>Design Pattern: Flyweight</h3>
- * <p>In uncalibrated mode, {@link CognitiveScorer} and
- * {@link com.spectrayan.spector.memory.interference.SemanticDeduplicator}
- * create identical identity calibration arrays on every call. This factory
- * caches arrays by dimension count, eliminating redundant allocations.</p>
- *
- * <h3>Identity Transform</h3>
- * <p>Maps unsigned byte [0, 255] to [-1.0, 1.0] range:
- * {@code min = -1.0}, {@code scale = 2.0/255}.</p>
- */
-public final class IdentityCalibration {
-
-    private static final ConcurrentHashMap<Integer, float[]> MINS_CACHE = new ConcurrentHashMap<>();
-    private static final ConcurrentHashMap<Integer, float[]> SCALES_CACHE = new ConcurrentHashMap<>();
-
-    private IdentityCalibration() {}
-
-    /**
-     * Returns a cached identity minimum array for the given dimension count.
-     * All values are -1.0f.
-     */
-    public static float[] mins(int dims) {
-        return MINS_CACHE.computeIfAbsent(dims, d -> {
-            float[] mins = new float[d];
-            java.util.Arrays.fill(mins, -1.0f);
-            return mins;
-        });
-    }
-
-    /**
-     * Returns a cached identity scale array for the given dimension count.
-     * All values are 2.0/255.
-     */
-    public static float[] scales(int dims) {
-        return SCALES_CACHE.computeIfAbsent(dims, d -> {
-            float[] scales = new float[d];
-            java.util.Arrays.fill(scales, 2.0f / 255.0f);
-            return scales;
-        });
-    }
-}
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/synapse/SynapticHeaderConstants.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/synapse/SynapticHeaderConstants.java
deleted file mode 100644
index c954d7e..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/synapse/SynapticHeaderConstants.java
+++ /dev/null
@@ -1,170 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.synapse;
-
-import java.lang.foreign.MemorySegment;
-import java.lang.foreign.ValueLayout;
-
-/**
- * Constants for the Synaptic Header — shared across all layout versions.
- *
- * <h3>Versioned Layout System</h3>
- * <p>The header format is versioned via the {@link HeaderLayout} sealed interface.
- * Three versions are supported:</p>
- * <ul>
- *   <li><b>V1 (32B)</b> — Legacy/lightweight. Core fields only.
- *       See {@link HeaderLayoutV1}.</li>
- *   <li><b>V2 (48B)</b> — Adds arousal + storage_strength for emotional
- *       modulation and Two-Factor Memory. See {@link HeaderLayoutV2}.</li>
- *   <li><b>V3 (64B)</b> — Full cache-line-aligned format with 32B of future
- *       buffer. Default for all new stores. See {@link HeaderLayoutV3}.</li>
- * </ul>
- *
- * <h3>Core Layout (first 32 bytes — shared by all versions)</h3>
- * <pre>
- *   [8B timestamp_ms]      Offset 0  — when the memory was formed
- *   [8B synaptic_tags]     Offset 8  — 64-bit Bloom filter of contextual markers
- *   [4B exact_norm]        Offset 16 — L2 norm for SIMD distance computation
- *   [4B importance]        Offset 20 — base importance (auto-set by Prediction Error engine)
- *   [4B recall_count]      Offset 24 — LTP reinforcement counter (4-byte aligned for atomic CAS)
- *   [2B centroid_id]       Offset 28 — IVF partition routing ID (max 65,535 centroids)
- *   [1B valence]           Offset 30 — signed INT8 emotion/reward (-128 to +127)
- *   [1B flags]             Offset 31 — bit field (tombstone, memory_type, consolidated, pinned)
- * </pre>
- *
- * <h3>Flags Bitfield</h3>
- * <pre>
- *   bit 0:   tombstone  (deleted / pruned by Deep Sleep)
- *   bit 1-2: memory_type (2 bits → 4 types)
- *   bit 3:   consolidated (has been reflected into Semantic tier)
- *   bit 4:   pinned (exempt from decay/pruning)
- *   bit 5:   resolved (Zeigarnik Effect — unresolved tasks resist decay)
- *   bits 6-7: reserved
- * </pre>
- *
- * <p>This class holds only the <em>core</em> constants shared across all versions.
- * Version-specific offsets and layouts are defined in the respective
- * {@link HeaderLayout} implementations.</p>
- *
- * @see HeaderLayout
- * @see CognitiveRecordLayout
- */
-public final class SynapticHeaderConstants {
-
-    private SynapticHeaderConstants() {}
-
-    /**
-     * V1 (core) header size in bytes.
-     *
-     * <p>This constant is retained for SIMD alignment purposes (Arena allocation
-     * alignment parameter) and for backward compatibility. The actual header size
-     * used at runtime is determined by the {@link HeaderLayout#headerBytes()} method
-     * on the active layout version.</p>
-     *
-     * @see HeaderLayout#headerBytes()
-     */
-    public static final int HEADER_BYTES = 32;
-
-    // ── Field offsets ──
-    public static final long OFFSET_TIMESTAMP     = 0L;
-    public static final long OFFSET_SYNAPTIC_TAGS = 8L;
-    public static final long OFFSET_EXACT_NORM    = 16L;
-    public static final long OFFSET_IMPORTANCE    = 20L;
-    public static final long OFFSET_RECALL_COUNT  = 24L;
-    public static final long OFFSET_CENTROID_ID   = 28L;
-    public static final long OFFSET_VALENCE       = 30L;
-    public static final long OFFSET_FLAGS         = 31L;
-
-    // ── Value layouts ──
-    public static final ValueLayout.OfLong  LAYOUT_TIMESTAMP     = ValueLayout.JAVA_LONG;
-    public static final ValueLayout.OfLong  LAYOUT_SYNAPTIC_TAGS = ValueLayout.JAVA_LONG;
-    public static final ValueLayout.OfFloat LAYOUT_EXACT_NORM    = ValueLayout.JAVA_FLOAT;
-    public static final ValueLayout.OfFloat LAYOUT_IMPORTANCE    = ValueLayout.JAVA_FLOAT;
-    public static final ValueLayout.OfInt   LAYOUT_RECALL_COUNT  = ValueLayout.JAVA_INT;
-    public static final ValueLayout.OfShort LAYOUT_CENTROID_ID   = ValueLayout.JAVA_SHORT;
-    public static final ValueLayout.OfByte  LAYOUT_VALENCE       = ValueLayout.JAVA_BYTE;
-    public static final ValueLayout.OfByte  LAYOUT_FLAGS         = ValueLayout.JAVA_BYTE;
-
-    // ── V2+ Extended field offsets (beyond 32-byte core) ──
-    /** Arousal byte offset (V2/V3 only — returns 0 on V1 reads). */
-    public static final long OFFSET_AROUSAL = 32L;
-    /** Layout for arousal: unsigned byte (0-255), stored as signed Java byte. */
-    public static final ValueLayout.OfByte  LAYOUT_AROUSAL       = ValueLayout.JAVA_BYTE;
-
-    // ── VarHandle view for atomic access ──
-    /** VarHandle for atomic updates to the recall_count field. */
-    public static final java.lang.invoke.VarHandle VAR_HANDLE_RECALL_COUNT = LAYOUT_RECALL_COUNT.varHandle();
-
-    // ── Flags bitmasks ──
-    /** Bit 0: Record has been logically deleted (tombstoned). */
-    public static final byte FLAG_TOMBSTONE    = 0x01;
-    /** Bits 1-2: Memory type (2 bits → 4 types). */
-    public static final byte FLAG_TYPE_MASK    = 0x06;
-    /** Number of bits to shift to read/write memory type from flags. */
-    public static final int  FLAG_TYPE_SHIFT   = 1;
-    /** Bit 3: Memory has been consolidated (reflected from Episodic → Semantic). */
-    public static final byte FLAG_CONSOLIDATED = 0x08;
-    /** Bit 4: Memory is pinned (exempt from decay and pruning). */
-    public static final byte FLAG_PINNED       = 0x10;
-    /** Bit 5: Memory is resolved (Zeigarnik Effect — unresolved memories resist time-decay). */
-    public static final byte FLAG_RESOLVED     = 0x20;
-
-    // ── Convenience methods ──
-
-    /**
-     * Checks if the tombstone flag is set in the given flags byte.
-     */
-    public static boolean isTombstoned(byte flags) {
-        return (flags & FLAG_TOMBSTONE) != 0;
-    }
-
-    /**
-     * Checks if the pinned flag is set.
-     */
-    public static boolean isPinned(byte flags) {
-        return (flags & FLAG_PINNED) != 0;
-    }
-
-    /**
-     * Checks if the resolved flag is set (Zeigarnik Effect).
-     *
-     * <p>When {@code false} (default for new memories), the memory resists
-     * time-decay — it floats to the top of recall like an unfinished task.
-     * When the agent marks the task complete, this flips to {@code true}
-     * and the memory succumbs to normal decay.</p>
-     */
-    public static boolean isResolved(byte flags) {
-        return (flags & FLAG_RESOLVED) != 0;
-    }
-
-    /**
-     * Checks if the consolidated flag is set.
-     */
-    public static boolean isConsolidated(byte flags) {
-        return (flags & FLAG_CONSOLIDATED) != 0;
-    }
-
-    /**
-     * Extracts the 2-bit memory type ordinal (0–3) from the flags byte.
-     */
-    public static int memoryTypeOrdinal(byte flags) {
-        return (flags & FLAG_TYPE_MASK) >>> FLAG_TYPE_SHIFT;
-    }
-
-    /**
-     * Encodes a memory type ordinal into a flags byte, preserving other bits.
-     */
-    public static byte withMemoryType(byte flags, int typeOrdinal) {
-        return (byte) ((flags & ~FLAG_TYPE_MASK) | ((typeOrdinal << FLAG_TYPE_SHIFT) & FLAG_TYPE_MASK));
-    }
-}
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/synapse/SynapticTagEncoder.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/synapse/SynapticTagEncoder.java
deleted file mode 100644
index 9d4a16c..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/synapse/SynapticTagEncoder.java
+++ /dev/null
@@ -1,166 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.synapse;
-
-/**
- * 64-bit inline Bloom filter encoder for synaptic tags.
- *
- * <h3>Biological Analog: Synaptic Tagging and Capture (STC)</h3>
- * <p>In neuroscience, synapses are "tagged" during learning with lightweight markers
- * that identify what the memory is about. This encoder creates a 64-bit digital
- * equivalent using double-hashing Bloom filter construction.</p>
- *
- * <h3>Design</h3>
- * <p>Uses MurmurHash3-inspired double hashing with k=3 hash functions.
- * Each tag string produces 3 bit positions in a 64-bit word. Multiple tags
- * are combined via bitwise OR. Matching uses bitwise AND to check if all
- * query tag bits are set in the record.</p>
- *
- * <h3>False Positive Rate</h3>
- * <table>
- *   <tr><th>Tags per Record</th><th>FPR</th><th>Assessment</th></tr>
- *   <tr><td>5</td><td>0.03%</td><td>Excellent</td></tr>
- *   <tr><td>10</td><td>0.2%</td><td>Excellent</td></tr>
- *   <tr><td>20</td><td>2.3%</td><td>Good</td></tr>
- *   <tr><td>50</td><td>12%</td><td>Acceptable — vector distance rejects false matches</td></tr>
- * </table>
- */
-public final class SynapticTagEncoder {
-
-    /** Number of hash functions (bits set per tag). */
-    private static final int K = 3;
-
-    /** Number of bits in the filter. */
-    private static final int M = 64;
-
-    private SynapticTagEncoder() {}
-
-    /**
-     * Encodes one or more tag strings into a 64-bit Bloom filter.
-     *
-     * @param tags tag strings to encode (e.g., "java", "performance", "coding")
-     * @return 64-bit Bloom filter with k=3 bits set per tag
-     */
-    public static long encode(String... tags) {
-        long filter = 0L;
-        for (String tag : tags) {
-            filter |= encodeTag(tag);
-        }
-        return filter;
-    }
-
-    /**
-     * Encodes a single tag into a 64-bit Bloom filter.
-     *
-     * @param tag tag string to encode
-     * @return 64-bit value with k=3 bits set
-     */
-    public static long encodeTag(String tag) {
-        long h = murmurHash64(tag);
-        long h1 = h;
-        // Golden ratio hash — produces an independent second hash without
-        // a separate hash function call. The half-swap (h >>> 32 | h << 32)
-        // previously used here is a weak construction that doesn't provide
-        // true independence. This uses φ * 2^64 multiplication + avalanche.
-        long h2 = h * 0x9e3779b97f4a7c15L;
-        h2 ^= h2 >>> 33;
-        h2 *= 0xc4ceb9fe1a85ec53L;
-        h2 ^= h2 >>> 33;
-
-        long filter = 0L;
-        for (int i = 0; i < K; i++) {
-            int bitIndex = Math.abs((int) ((h1 + (long) i * h2) % M));
-            filter |= (1L << bitIndex);
-        }
-        return filter;
-    }
-
-    /**
-     * Checks if a record's synaptic tags match the query mask.
-     *
-     * <p>Returns {@code true} if ALL bits set in {@code queryMask} are also
-     * set in {@code recordTags} (i.e., subset check via AND).</p>
-     *
-     * @param recordTags the record's 64-bit Bloom filter
-     * @param queryMask  the query's required tag bits
-     * @return true if the record passes the tag filter
-     */
-    public static boolean matches(long recordTags, long queryMask) {
-        return (recordTags & queryMask) == queryMask;
-    }
-
-    /**
-     * Merges two Bloom filters by ORing them together.
-     *
-     * @param existing existing tags
-     * @param additional new tags to merge
-     * @return combined Bloom filter
-     */
-    public static long merge(long existing, long additional) {
-        return existing | additional;
-    }
-
-    /**
-     * Returns the approximate number of bits set in the Bloom filter.
-     * Useful for estimating tag density.
-     */
-    public static int bitCount(long filter) {
-        return Long.bitCount(filter);
-    }
-
-    /**
-     * Computes the overlap ratio between a record's tags and a query mask.
-     *
-     * <p>Returns the fraction of query tag bits that are also set in the record's
-     * Bloom filter. Used by {@code CognitiveScorer} for weighted tag relevance —
-     * partial matches score proportionally lower than full matches.</p>
-     *
-     * <ul>
-     *   <li>{@code 1.0} — all query bits present (full match)</li>
-     *   <li>{@code 0.5} — half the query bits present (partial match)</li>
-     *   <li>{@code 0.0} — no overlap (should have been skipped in Phase 2)</li>
-     * </ul>
-     *
-     * @param recordTags the record's 64-bit Bloom filter
-     * @param queryMask  the query's required tag bits
-     * @return overlap ratio in [0.0, 1.0], or 1.0 if queryMask is 0 (no filter)
-     */
-    public static float overlapRatio(long recordTags, long queryMask) {
-        if (queryMask == 0) return 1.0f;
-        int queryBits = Long.bitCount(queryMask);
-        int matchedBits = Long.bitCount(recordTags & queryMask);
-        return (float) matchedBits / queryBits;
-    }
-
-    // ── MurmurHash3-inspired 64-bit hash ──
-
-    /**
-     * MurmurHash3-inspired 64-bit hash for short strings.
-     * Optimized for tag-length strings (typically 3–30 characters).
-     */
-    private static long murmurHash64(String key) {
-        long h = 0xcbf29ce484222325L; // FNV offset basis
-        for (int i = 0; i < key.length(); i++) {
-            h ^= key.charAt(i);
-            h *= 0x100000001b3L; // FNV prime
-            h ^= h >>> 33;
-            h *= 0xff51afd7ed558ccdL;
-            h ^= h >>> 33;
-        }
-        // Final avalanche
-        h ^= h >>> 33;
-        h *= 0xc4ceb9fe1a85ec53L;
-        h ^= h >>> 33;
-        return h;
-    }
-}
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/sync/CloudSync.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/sync/CloudSync.java
deleted file mode 100644
index b583ced..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/sync/CloudSync.java
+++ /dev/null
@@ -1,331 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.sync;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.io.IOException;
-import java.io.UncheckedIOException;
-import java.net.URI;
-import java.net.http.HttpClient;
-import java.net.http.HttpRequest;
-import java.net.http.HttpResponse;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.time.Duration;
-import java.util.Comparator;
-import java.util.List;
-import java.util.concurrent.atomic.AtomicLong;
-import com.spectrayan.spector.commons.error.SpectorServerException;
-import com.spectrayan.spector.commons.error.ErrorCode;
-
-/**
- * Cross-agent memory replication via WAL event replay.
- *
- * <h3>Biological Analog: Inter-Hemispheric Transfer</h3>
- * <p>The corpus callosum transfers information between the left and right brain
- * hemispheres, enabling a unified memory experience despite physically separate
- * neural networks. CloudSync provides the same for distributed agents.</p>
- *
- * <h3>Design: Pull-Based Replication</h3>
- * <ul>
- *   <li>Each agent maintains a local WAL with monotonic sequence numbers</li>
- *   <li>Remote agents poll with their high-water mark → receive only new events</li>
- *   <li>Events are replayed into the remote agent's local memory store</li>
- *   <li>Conflicts resolved by timestamp (last-writer-wins)</li>
- * </ul>
- *
- * <h3>V2 Scope</h3>
- * <p>V2 implements in-process replication (single JVM, multiple memory stores).
- * Network transport (gRPC, HTTP) is deferred to V3.</p>
- */
-public final class CloudSync {
-
-    private static final Logger log = LoggerFactory.getLogger(CloudSync.class);
-
-    private final MemoryWal localWal;
-    private final AtomicLong remoteHighWaterMark = new AtomicLong(0);
-
-    /**
-     * Creates a CloudSync instance backed by a local WAL.
-     *
-     * @param localWal the local memory WAL
-     */
-    public CloudSync(MemoryWal localWal) {
-        this.localWal = localWal;
-    }
-
-    /**
-     * Exports events from the local WAL that are newer than the remote's high-water mark.
-     *
-     * @param remoteHwm the remote agent's last replayed sequence number
-     * @return list of events to ship to the remote agent
-     */
-    public List<WalEvent> exportEvents(long remoteHwm) {
-        List<WalEvent> events = localWal.replay(remoteHwm);
-        log.debug("Exporting {} events (after seq={})", events.size(), remoteHwm);
-        return events;
-    }
-
-    /**
-     * Imports events from a remote agent and applies them to the local store.
-     *
-     * <p>V2: In-memory replay. V3: will include conflict resolution and
-     * deduplication check.</p>
-     *
-     * @param remoteEvents events received from a remote agent
-     * @param replayHandler callback to apply each event to the local memory store
-     */
-    public void importEvents(List<WalEvent> remoteEvents, EventReplayHandler replayHandler) {
-        int applied = 0;
-        try {
-            for (WalEvent event : remoteEvents) {
-                if (event.sequence() > remoteHighWaterMark.get()) {
-                    replayHandler.replay(event);
-                    remoteHighWaterMark.set(event.sequence());
-                    applied++;
-                }
-            }
-        } catch (Exception e) {
-            if (e instanceof WalCorruptionException || e.getCause() instanceof WalCorruptionException) {
-                log.error("WAL Corruption detected during event replication! Triggering cold bootstrap sync...", e);
-                throw new SpectorServerException(ErrorCode.INTERNAL_ERROR, e, "WAL corruption");
-            }
-            throw e;
-        }
-        log.info("Imported {} events from remote (new hwm={})",
-                applied, remoteHighWaterMark.get());
-    }
-
-    /**
-     * Returns the remote high-water mark (last replayed remote sequence).
-     */
-    public long remoteHighWaterMark() {
-        return remoteHighWaterMark.get();
-    }
-
-    // ── V3: CRDT Merge + StorageAdapter Integration ──
-
-    private StorageAdapter storageAdapter;
-    private String namespace;
-
-    /**
-     * Configures cloud storage for WAL chunk upload/download.
-     *
-     * @param adapter   the storage backend (S3, GCS, etc.)
-     * @param namespace the agent namespace (isolation boundary)
-     */
-    public void configureCloudStorage(StorageAdapter adapter, String namespace) {
-        this.storageAdapter = adapter;
-        this.namespace = namespace;
-        log.info("CloudSync configured: namespace='{}', adapter={}", namespace, adapter.getClass().getSimpleName());
-    }
-
-    /**
-     * Uploads pending WAL events to cloud storage.
-     *
-     * @return number of events uploaded
-     */
-    public int uploadToCloud() {
-        if (storageAdapter == null) {
-            log.warn("No storage adapter configured — skipping cloud upload");
-            return 0;
-        }
-
-        List<WalEvent> events = localWal.replay(remoteHighWaterMark.get());
-        if (events.isEmpty()) return 0;
-
-        // Serialize events to a compact binary format
-        int estimatedSize = events.size() * 256; // rough estimate
-        var buf = java.nio.ByteBuffer.allocate(estimatedSize);
-        for (WalEvent event : events) {
-            byte[] idBytes = event.memoryId().getBytes(java.nio.charset.StandardCharsets.UTF_8);
-            buf.putLong(event.sequence());
-            buf.put((byte) event.type().ordinal());
-            buf.putInt(idBytes.length);
-            buf.put(idBytes);
-            buf.putLong(event.timestamp().toEpochMilli());
-            buf.putInt(event.payload().length);
-            buf.put(event.payload());
-        }
-        buf.flip();
-
-        String chunkName = String.format("wal-%012d.bin", events.getLast().sequence());
-        storageAdapter.upload(namespace, chunkName, buf);
-
-        log.info("Uploaded {} events to cloud: {}/{}", events.size(), namespace, chunkName);
-        return events.size();
-    }
-
-    /**
-     * Imports events from a remote agent using CRDT merge strategy.
-     *
-     * <p>V3: Each event is merged using CRDT rules before applying to
-     * the local store. This ensures convergence regardless of merge order.</p>
-     *
-     * @param remoteEvents  events from remote agent
-     * @param replayHandler callback to apply each event to local store
-     * @param crdtEnabled   if true, uses CRDT merge resolution for conflicts
-     */
-    public void importEvents(List<WalEvent> remoteEvents, EventReplayHandler replayHandler,
-                              boolean crdtEnabled) {
-        int applied = 0;
-        try {
-            for (WalEvent event : remoteEvents) {
-                if (event.sequence() > remoteHighWaterMark.get()) {
-                    // V3: CRDT merge would resolve field-level conflicts here
-                    // The actual merge happens at the header level in the replay handler
-                    replayHandler.replay(event);
-                    remoteHighWaterMark.set(event.sequence());
-                    applied++;
-                }
-            }
-        } catch (Exception e) {
-            if (e instanceof WalCorruptionException || e.getCause() instanceof WalCorruptionException) {
-                log.error("WAL Corruption detected during CRDT event replication! Triggering cold bootstrap sync...", e);
-                throw new SpectorServerException(ErrorCode.INTERNAL_ERROR, e, "WAL corruption");
-            }
-            throw e;
-        }
-        log.info("Imported {} events from remote (crdt={}, new hwm={})",
-                applied, crdtEnabled, remoteHighWaterMark.get());
-    }
-
-    // ── REST/HTTP Cold Bootstrap Sync Utilities (V2 Upgrade) ──
-
-    /**
-     * Recursively packages the entire source directory into a Zip stream.
-     *
-     * @param sourceDir the source directory path
-     * @param os the target output stream
-     * @throws IOException if zipping fails
-     */
-    public static void zipDirectory(Path sourceDir, java.io.OutputStream os) throws IOException {
-        try (var zos = new java.util.zip.ZipOutputStream(os)) {
-            Files.walk(sourceDir)
-                .filter(path -> !Files.isDirectory(path))
-                .forEach(path -> {
-                    String zipPath = sourceDir.relativize(path).toString().replace('\\', '/');
-                    try {
-                        zos.putNextEntry(new java.util.zip.ZipEntry(zipPath));
-                        Files.copy(path, zos);
-                        zos.closeEntry();
-                    } catch (IOException e) {
-                        throw new UncheckedIOException(e);
-                    }
-                });
-        } catch (UncheckedIOException e) {
-            throw e.getCause();
-        }
-    }
-
-    /**
-     * Cleans the target directory and unpacks a Zip stream into it, with Zip Slip security checks.
-     *
-     * @param is the zip input stream
-     * @param targetDir the target extraction directory path
-     * @throws IOException if unzipping fails
-     */
-    public static void unzipDirectory(java.io.InputStream is, Path targetDir) throws IOException {
-        if (Files.exists(targetDir)) {
-            try (var stream = Files.walk(targetDir)) {
-                stream.sorted(Comparator.reverseOrder())
-                      .forEach(p -> {
-                          try {
-                              Files.delete(p);
-                          } catch (IOException e) {
-                              // ignore
-                          }
-                      });
-            }
-        }
-
-        if (is == null) {
-            return;
-        }
-
-        Files.createDirectories(targetDir);
-
-        try (var zis = new java.util.zip.ZipInputStream(is)) {
-            java.util.zip.ZipEntry entry;
-            while ((entry = zis.getNextEntry()) != null) {
-                Path entryPath = targetDir.resolve(entry.getName());
-                // Prevent Zip Slip vulnerability
-                if (!entryPath.normalize().startsWith(targetDir.normalize())) {
-                    throw new IOException("Bad zip entry path: " + entry.getName());
-                }
-                if (entry.isDirectory()) {
-                    Files.createDirectories(entryPath);
-                } else {
-                    Files.createDirectories(entryPath.getParent());
-                    Files.copy(zis, entryPath, java.nio.file.StandardCopyOption.REPLACE_EXISTING);
-                }
-                zis.closeEntry();
-            }
-        }
-    }
-
-    /**
-     * Downloads a snapshot zip from the leader node and restores the local directory.
-     *
-     * @param leaderUrl the leader's base URL (e.g. "http://localhost:7070")
-     * @param localDir the local off-heap persistence directory
-     * @return the leader's snapshot high-water mark (HWM)
-     * @throws Exception if bootstrap fails
-     */
-    public static long bootstrapFromLeader(String leaderUrl, Path localDir) throws Exception {
-        log.info("Initiating REST/HTTP Cold Bootstrap from Leader: {} to local directory: {}", leaderUrl, localDir);
-
-        HttpClient client = HttpClient.newBuilder()
-                .connectTimeout(Duration.ofSeconds(10))
-                .build();
-
-        HttpRequest request = HttpRequest.newBuilder()
-                .uri(URI.create(leaderUrl + "/api/v2/memory/snapshot"))
-                .timeout(Duration.ofSeconds(60))
-                .GET()
-                .build();
-
-        HttpResponse<java.io.InputStream> response = client.send(request, HttpResponse.BodyHandlers.ofInputStream());
-
-        if (response.statusCode() != 200) {
-            throw new IOException("Failed to download snapshot from leader. HTTP Status: " + response.statusCode());
-        }
-
-        String hwmHeader = response.headers().firstValue("X-Snapshot-HWM").orElse("0");
-        long leaderHwm = Long.parseLong(hwmHeader);
-
-        log.info("Leader snapshot HWM is: {}. Unpacking snapshot zip...", leaderHwm);
-
-        try (java.io.InputStream is = response.body()) {
-            unzipDirectory(is, localDir);
-        }
-
-        log.info("Cold Bootstrap successful! Local directory restored to Leader's state up to HWM {}", leaderHwm);
-        return leaderHwm;
-    }
-
-    /**
-     * Functional interface for replaying events into a memory store.
-     */
-    @FunctionalInterface
-    public interface EventReplayHandler {
-        /**
-         * Replays a single WAL event into the local memory store.
-         *
-         * @param event the event to replay
-         */
-        void replay(WalEvent event);
-    }
-}
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/sync/CrdtMergeStrategy.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/sync/CrdtMergeStrategy.java
deleted file mode 100644
index 0a03d3e..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/sync/CrdtMergeStrategy.java
+++ /dev/null
@@ -1,142 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.sync;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-/**
- * CRDT-style conflict resolution strategy for multi-writer memory sync.
- *
- * <h3>Biological Analog: Inter-Hemispheric Transfer</h3>
- * <p>The corpus callosum enables both brain hemispheres to share information
- * without conflicts — each hemisphere processes and modifies memories independently,
- * then transfers knowledge via a deterministic protocol. CRDT merge provides the
- * same guarantee for distributed agents.</p>
- *
- * <h3>Merge Rules</h3>
- * <ul>
- *   <li><b>Timestamp:</b> Last-Writer-Wins (LWW) — keep the most recent</li>
- *   <li><b>Importance:</b> Max-merge — keep the higher importance</li>
- *   <li><b>Valence:</b> Last-Writer-Wins (LWW) — most recent outcome</li>
- *   <li><b>Recall Count:</b> Max-merge — keep the higher count</li>
- *   <li><b>Synaptic Tags:</b> OR-merge — union of Bloom filters</li>
- *   <li><b>Tombstone:</b> Tombstone wins — delete is permanent (crdt-tombstone)</li>
- *   <li><b>Consolidated:</b> OR — once consolidated, stays consolidated</li>
- *   <li><b>Pinned:</b> OR — once pinned, stays pinned</li>
- * </ul>
- *
- * <h3>Guarantee</h3>
- * <p>All merge operations are commutative, associative, and idempotent.
- * This means any order of merges from any agents produces the same final state.</p>
- */
-public final class CrdtMergeStrategy {
-
-    private static final Logger log = LoggerFactory.getLogger(CrdtMergeStrategy.class);
-
-    /**
-     * Merged header fields produced by CRDT resolution.
-     *
-     * @param timestampMs   LWW: most recent timestamp
-     * @param synapticTags  OR-merge: union of Bloom filters
-     * @param importance    Max-merge: highest importance
-     * @param recallCount   Max-merge: highest recall count
-     * @param valence       LWW: valence from most recent timestamp
-     * @param flags         Merged flags (tombstone wins, consolidated/pinned OR)
-     */
-    public record MergedHeader(
-            long timestampMs,
-            long synapticTags,
-            float importance,
-            int recallCount,
-            byte valence,
-            byte flags
-    ) {}
-
-    /**
-     * Input header fields from a single source.
-     */
-    public record SourceHeader(
-            long timestampMs,
-            long synapticTags,
-            float importance,
-            int recallCount,
-            byte valence,
-            byte flags
-    ) {}
-
-    /**
-     * Merges two headers using CRDT rules.
-     *
-     * @param local  the local header
-     * @param remote the remote header
-     * @return merged header with CRDT-resolved fields
-     */
-    public static MergedHeader merge(SourceHeader local, SourceHeader remote) {
-        // LWW: most recent timestamp wins for timestamp and valence
-        boolean remoteIsNewer = remote.timestampMs() >= local.timestampMs();
-
-        long mergedTimestamp = Math.max(local.timestampMs(), remote.timestampMs());
-        long mergedTags = local.synapticTags() | remote.synapticTags(); // OR-merge
-        float mergedImportance = Math.max(local.importance(), remote.importance()); // Max-merge
-        int mergedRecallCount = Math.max(local.recallCount(), remote.recallCount()); // Max-merge
-        byte mergedValence = remoteIsNewer ? remote.valence() : local.valence(); // LWW
-
-        // Flag merge: tombstone and consolidated/pinned are OR-merged
-        byte mergedFlags = mergeFlags(local.flags(), remote.flags());
-
-        log.trace("CRDT merge: local_ts={}, remote_ts={}, winner={}",
-                local.timestampMs(), remote.timestampMs(),
-                remoteIsNewer ? "remote" : "local");
-
-        return new MergedHeader(mergedTimestamp, mergedTags, mergedImportance,
-                mergedRecallCount, mergedValence, mergedFlags);
-    }
-
-    /**
-     * Merges flag bytes.
-     * <ul>
-     *   <li>Tombstone (bit 0): OR — once tombstoned, always tombstoned</li>
-     *   <li>Memory type (bits 1-2): taken from newer source</li>
-     *   <li>Consolidated (bit 3): OR</li>
-     *   <li>Pinned (bit 4): OR</li>
-     * </ul>
-     */
-    static byte mergeFlags(byte local, byte remote) {
-        // OR for tombstone, consolidated, pinned
-        byte orBits = (byte) ((local | remote) & 0b00011001); // bits 0, 3, 4
-
-        // Memory type from either (they should be the same for the same memory ID)
-        byte memType = (byte) (local & 0b00000110); // bits 1-2 from local
-
-        return (byte) (orBits | memType);
-    }
-
-    /**
-     * Checks if a merge would change any fields.
-     *
-     * @param local  current local state
-     * @param remote incoming remote state
-     * @return true if the remote has newer/higher values that would change the local state
-     */
-    public static boolean wouldChange(SourceHeader local, SourceHeader remote) {
-        if (remote.timestampMs() > local.timestampMs()) return true;
-        if (remote.importance() > local.importance()) return true;
-        if (remote.recallCount() > local.recallCount()) return true;
-        if ((remote.synapticTags() & ~local.synapticTags()) != 0) return true; // remote has bits local doesn't
-        if ((remote.flags() & ~local.flags()) != 0) return true; // remote has flag bits local doesn't
-        return false;
-    }
-
-    private CrdtMergeStrategy() {} // static utility
-}
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/sync/MemoryWal.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/sync/MemoryWal.java
deleted file mode 100644
index feff17e..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/sync/MemoryWal.java
+++ /dev/null
@@ -1,787 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.sync;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.io.ByteArrayOutputStream;
-import java.io.IOException;
-import java.io.UncheckedIOException;
-import java.nio.ByteBuffer;
-import java.nio.channels.FileChannel;
-import java.nio.charset.StandardCharsets;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.nio.file.StandardOpenOption;
-import java.time.Instant;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.concurrent.atomic.AtomicLong;
-import java.util.concurrent.locks.ReentrantLock;
-import java.util.zip.CRC32;
-import java.util.zip.DataFormatException;
-import java.util.zip.Deflater;
-import java.util.zip.Inflater;
-
-/**
- * Append-only Write-Ahead Log for memory events.
- *
- * <h3>Biological Analog: Hippocampal Replay Buffer</h3>
- * <p>Before memories are consolidated into long-term storage, they exist as
- * transient activity patterns in the hippocampus. The WAL is the digital equivalent
- * — an ordered, durable log of every memory mutation that can be replayed.</p>
- *
- * <h3>V3 Design: File-Backed Persistence</h3>
- * <ul>
- *   <li>Append-only with sequential numbering — O(1) writes</li>
- *   <li>No deletions — tombstone events instead</li>
- *   <li>Replay from any sequence number → enables distributed sync</li>
- *   <li>Binary record format: {@code [4B length][8B seq][1B type][4B id_len][N id][8B ts_epoch][4B payload_len][N payload]}</li>
- *   <li>Per-write fsync for crash durability (negligible vs. embedding latency)</li>
- *   <li>Rolled WAL chunks when file exceeds max size (default 8MB)</li>
- *   <li>Crash recovery: replay WAL file to rebuild in-memory state</li>
- * </ul>
- *
- * <h3>Dual Mode</h3>
- * <ul>
- *   <li><b>File mode</b> ({@code walPath != null}): All appends are durable on disk.</li>
- *   <li><b>In-memory mode</b> ({@code walPath == null}): Volatile, for tests and ephemeral agents.</li>
- * </ul>
- *
- * <h3>CloudSync (V2+)</h3>
- * <p>A replication daemon reads events after a high-water mark and ships them
- * to remote agents. Each agent replays events into their local memory store.</p>
- */
-public final class MemoryWal implements AutoCloseable {
-
-    private static final Logger log = LoggerFactory.getLogger(MemoryWal.class);
-
-    /** Magic bytes for WAL file identification: "SPEC" in ASCII. */
-    static final int WAL_MAGIC = 0x53504543;
-
-    /** WAL format version. */
-    static final int WAL_VERSION = 2;
-
-    /** Record magic for Version 2: 'W' and 'A' (0x5741) */
-    static final short RECORD_MAGIC = 0x5741;
-
-    /** File header size: 4B magic + 4B version = 8 bytes. */
-    static final int FILE_HEADER_BYTES = 8;
-
-    /** Default max chunk size before rolling (8 MB). */
-    private static final long DEFAULT_MAX_CHUNK_BYTES = 8L * 1024 * 1024;
-
-    private final Path walDir;
-    private final long maxChunkBytes;
-    private final boolean compressionEnabled;
-    private final int compressionThreshold;
-    private final boolean fsyncPerWrite;
-    private final AtomicLong sequenceCounter;
-    private final ReentrantLock writeLock = new ReentrantLock();
-
-    /** In-memory event cache for fast replay from recent HWM. */
-    private final List<WalEvent> events = new ArrayList<>();
-
-    /** Active FileChannel for the current WAL chunk (null in memory-only mode). */
-    private FileChannel activeChannel;
-    private Path activeChunkPath;
-    private long activeChunkBytes;
-    private int chunkIndex;
-
-    /**
-     * Opens or creates a file-backed WAL with custom configurations.
-     *
-     * @param walDir               directory for WAL chunk files
-     * @param maxChunkBytes        maximum bytes per chunk before rolling (default: 8MB)
-     * @param compressionEnabled   whether text/payload compression is enabled
-     * @param compressionThreshold byte threshold above which payload compression is triggered
-     * @param fsyncPerWrite        whether to physically fsync the disk on every individual write
-     */
-    public MemoryWal(Path walDir, long maxChunkBytes, boolean compressionEnabled, int compressionThreshold, boolean fsyncPerWrite) {
-        this.walDir = walDir;
-        this.maxChunkBytes = maxChunkBytes;
-        this.compressionEnabled = compressionEnabled;
-        this.compressionThreshold = compressionThreshold;
-        this.fsyncPerWrite = fsyncPerWrite;
-        this.sequenceCounter = new AtomicLong(0);
-
-        if (walDir != null) {
-            try {
-                Files.createDirectories(walDir);
-            } catch (IOException e) {
-                throw new UncheckedIOException("Cannot create WAL directory: " + walDir, e);
-            }
-
-            // Recover state from existing chunk files
-            recoverFromDisk();
-
-            // Open (or create) the active chunk
-            openActiveChunk();
-
-            log.info("MemoryWal opened: dir={}, chunks={}, recovered={} events, hwm={}, compression={}, fsyncPerWrite={}",
-                    walDir, chunkIndex + 1, events.size(), sequenceCounter.get(), compressionEnabled, fsyncPerWrite);
-        } else {
-            log.info("MemoryWal opened: in-memory mode");
-        }
-    }
-
-    /**
-     * Opens or creates a file-backed WAL with default compaction configurations.
-     *
-     * @param walDir        directory for WAL chunk files
-     * @param maxChunkBytes maximum bytes per chunk before rolling (default: 8MB)
-     */
-    public MemoryWal(Path walDir, long maxChunkBytes) {
-        this(walDir, maxChunkBytes, false, 1024, false);
-    }
-
-    /**
-     * Opens or creates a file-backed WAL with default chunk size (8 MB).
-     *
-     * @param walDir directory for WAL chunk files
-     */
-    public MemoryWal(Path walDir) {
-        this(walDir, DEFAULT_MAX_CHUNK_BYTES, false, 1024, false);
-    }
-
-    /**
-     * Creates an in-memory WAL (no file persistence).
-     */
-    public MemoryWal() {
-        this(null, Long.MAX_VALUE, false, 1024, false);
-    }
-
-    /**
-     * Appends a new event to the WAL.
-     *
-     * <p>In file mode, the event is serialized to the binary format and written
-     * to the active chunk with {@code FileChannel.force(true)} for durability.</p>
-     *
-     * @param type     event type
-     * @param memoryId the affected memory ID
-     * @param payload  serialized event data (can be empty)
-     * @return the event with its assigned sequence number
-     */
-    public WalEvent append(WalEvent.EventType type, String memoryId, byte[] payload) {
-        long seq = sequenceCounter.incrementAndGet();
-        WalEvent event = new WalEvent(seq, type, memoryId, Instant.now(),
-                payload != null ? payload : new byte[0]);
-
-        writeLock.lock();
-        try {
-            events.add(event);
-
-            if (activeChannel != null) {
-                writeEventToChannel(event);
-
-                // Roll chunk if needed
-                if (activeChunkBytes >= maxChunkBytes) {
-                    rollChunk();
-                }
-            }
-        } catch (IOException e) {
-            throw new UncheckedIOException("WAL write failed at seq=" + seq, e);
-        } finally {
-            writeLock.unlock();
-        }
-
-        log.trace("WAL append: seq={}, type={}, id={}", seq, type, memoryId);
-        return event;
-    }
-
-    /**
-     * Appends a REMEMBER event.
-     */
-    public WalEvent appendRemember(String memoryId, byte[] payload) {
-        return append(WalEvent.EventType.REMEMBER, memoryId, payload);
-    }
-
-    /**
-     * Appends a FORGET event.
-     */
-    public WalEvent appendForget(String memoryId) {
-        return append(WalEvent.EventType.FORGET, memoryId, null);
-    }
-
-    /**
-     * Appends a REINFORCE event.
-     */
-    public WalEvent appendReinforce(String memoryId, byte valence) {
-        return append(WalEvent.EventType.REINFORCE, memoryId, new byte[]{valence});
-    }
-
-    /**
-     * Replays all events after a given sequence number.
-     *
-     * <p>Used by CloudSync to ship events to remote agents. Returns events
-     * from the in-memory cache first; if the cache doesn't cover the requested
-     * range, reads from disk.</p>
-     *
-     * @param afterSequence replay events with sequence &gt; this value (0 = replay all)
-     * @return list of events in order
-     */
-    public List<WalEvent> replay(long afterSequence) {
-        return events.stream()
-                .filter(e -> e.sequence() > afterSequence)
-                .toList();
-    }
-
-    /**
-     * Replays all events from disk WAL files, ignoring the in-memory cache.
-     *
-     * <p>Used for crash recovery and consistency verification.</p>
-     *
-     * @return list of all events read from WAL chunk files
-     */
-    public List<WalEvent> replayFromDisk() {
-        if (walDir == null) return List.of();
-
-        List<WalEvent> diskEvents = new ArrayList<>();
-        try {
-            List<Path> chunks = findChunkFiles();
-            for (Path chunk : chunks) {
-                readChunkFile(chunk, diskEvents);
-            }
-        } catch (IOException e) {
-            throw new UncheckedIOException("WAL disk replay failed", e);
-        }
-        return diskEvents;
-    }
-
-    /**
-     * Returns the current high-water mark (latest sequence number).
-     */
-    public long highWaterMark() {
-        return sequenceCounter.get();
-    }
-
-    /**
-     * Returns the total number of events in the WAL (in-memory cache).
-     */
-    public int size() {
-        return events.size();
-    }
-
-    /**
-     * Returns the WAL directory path (null for in-memory mode).
-     */
-    public Path path() {
-        return walDir;
-    }
-
-    /**
-     * Returns whether this WAL is file-backed.
-     */
-    public boolean isPersistent() {
-        return walDir != null;
-    }
-
-    @Override
-    public void close() {
-        writeLock.lock();
-        try {
-            if (activeChannel != null) {
-                try {
-                    activeChannel.force(true);
-                    activeChannel.close();
-                } catch (IOException e) {
-                    log.warn("Error closing WAL channel: {}", e.getMessage());
-                }
-            }
-        } finally {
-            writeLock.unlock();
-        }
-        log.info("MemoryWal closing ({} events, hwm={})", events.size(), sequenceCounter.get());
-    }
-
-    // ── Internal: File I/O ──
-
-    /**
-     * Recovers state from existing WAL chunk files on disk.
-     * Rebuilds the in-memory event cache and restores the sequence counter.
-     */
-    private void recoverFromDisk() {
-        if (walDir == null) return;
-
-        try {
-            List<Path> chunks = findChunkFiles();
-            int maxIdx = -1;
-            for (Path chunk : chunks) {
-                maxIdx = Math.max(maxIdx, parseChunkIndex(chunk.getFileName().toString()));
-            }
-            chunkIndex = maxIdx + 1; // next chunk index
-
-            for (Path chunk : chunks) {
-                readChunkFile(chunk, events);
-            }
-
-            // Restore sequence counter to the max seen
-            long maxSeq = events.stream()
-                    .mapToLong(WalEvent::sequence)
-                    .max()
-                    .orElse(0L);
-            sequenceCounter.set(maxSeq);
-
-        } catch (WalCorruptionException e) {
-            log.error("Fatal WAL corruption detected during recovery: {}", e.getMessage());
-            throw new UncheckedIOException(e);
-        } catch (IOException e) {
-            log.error("WAL recovery failed: {}", e.getMessage());
-            throw new UncheckedIOException("Failed to recover WAL from disk", e);
-        }
-    }
-
-    /**
-     * Opens the active chunk file for writing. Creates a new file with header
-     * if it doesn't exist.
-     */
-    private void openActiveChunk() {
-        if (walDir == null) return;
-
-        try {
-            activeChunkPath = walDir.resolve(chunkFileName(chunkIndex));
-            boolean isNew = !Files.exists(activeChunkPath);
-
-            activeChannel = FileChannel.open(activeChunkPath,
-                    StandardOpenOption.CREATE,
-                    StandardOpenOption.WRITE,
-                    StandardOpenOption.READ);
-
-            if (isNew) {
-                writeFileHeader();
-                activeChunkBytes = FILE_HEADER_BYTES;
-            } else {
-                activeChunkBytes = activeChannel.size();
-                activeChannel.position(activeChunkBytes); // seek to end for appending
-            }
-        } catch (IOException e) {
-            throw new UncheckedIOException("Cannot open WAL chunk: " + activeChunkPath, e);
-        }
-    }
-
-    /**
-     * Writes the WAL file header (magic + version).
-     */
-    private void writeFileHeader() throws IOException {
-        ByteBuffer header = ByteBuffer.allocate(FILE_HEADER_BYTES);
-        header.putInt(WAL_MAGIC);
-        header.putInt(WAL_VERSION);
-        header.flip();
-        activeChannel.write(header);
-        activeChannel.force(true);
-    }
-
-    /**
-     * Serializes and writes a single event to the active FileChannel.
-     */
-    private void writeEventToChannel(WalEvent event) throws IOException {
-        byte[] idBytes = event.memoryId().getBytes(StandardCharsets.UTF_8);
-        byte[] rawPayload = event.payload();
-        byte[] payload = rawPayload;
-        byte flags = 0;
-
-        if (compressionEnabled && rawPayload.length > compressionThreshold) {
-            payload = compress(rawPayload);
-            flags |= 1; // Bit 0: Compressed
-        }
-
-        int idLen = idBytes.length;
-        int payloadLen = payload.length;
-        int totalVarLen = idLen + payloadLen;
-        int paddingLen = (8 - (totalVarLen % 8)) % 8;
-        int recordSize = 40 + totalVarLen + paddingLen;
-
-        ByteBuffer buf = ByteBuffer.allocate(recordSize);
-
-        // Offset 0-7: Metadata Block
-        buf.putShort(RECORD_MAGIC);
-        buf.put((byte) WAL_VERSION);
-        buf.put(flags);
-        buf.put((byte) event.type().ordinal());
-        buf.putShort((short) idLen);
-        buf.put((byte) 0); // Reserved byte
-
-        // Offset 8-15: Sequence Number
-        buf.putLong(event.sequence());
-
-        // Offset 16-23: Timestamp
-        buf.putLong(event.timestamp().toEpochMilli());
-
-        // Offset 24-27: Payload Length
-        buf.putInt(payloadLen);
-
-        // Offset 28-31: Payload CRC32
-        int payloadCrc = calculateCrc32(payload);
-        buf.putInt(payloadCrc);
-
-        // Offset 32-35: Reserved field
-        buf.putInt(0);
-
-        // Offset 36-39: Compute Header CRC over the first 36 bytes of the header
-        int headerCrc = calculateCrc32(buf, 36);
-        buf.putInt(headerCrc);
-
-        // Variable segments
-        buf.put(idBytes);
-        buf.put(payload);
-
-        // Alignment padding to 8-byte boundaries
-        for (int i = 0; i < paddingLen; i++) {
-            buf.put((byte) 0);
-        }
-
-        buf.flip();
-        activeChannel.write(buf);
-
-        if (fsyncPerWrite) {
-            activeChannel.force(false); // metadata update not needed per-write
-        }
-        activeChunkBytes += recordSize;
-    }
-
-    /**
-     * Rolls to a new WAL chunk file.
-     */
-    private void rollChunk() throws IOException {
-        log.info("WAL chunk {} reached {}KB — rolling to next chunk",
-                chunkIndex, activeChunkBytes / 1024);
-
-        activeChannel.force(true);
-        activeChannel.close();
-
-        chunkIndex++;
-        openActiveChunk();
-    }
-
-    /**
-     * Reads all events from a single WAL chunk file.
-     */
-    private void readChunkFile(Path chunkPath, List<WalEvent> out) throws IOException {
-        // Open with READ and WRITE to support auto-repair of torn writes during recovery
-        try (FileChannel ch = FileChannel.open(chunkPath, StandardOpenOption.READ, StandardOpenOption.WRITE)) {
-            long fileSize = ch.size();
-            if (fileSize < FILE_HEADER_BYTES) return; // too small, skip
-
-            // Read and validate file header
-            ByteBuffer headerBuf = ByteBuffer.allocate(FILE_HEADER_BYTES);
-            ch.read(headerBuf);
-            headerBuf.flip();
-
-            int magic = headerBuf.getInt();
-            int version = headerBuf.getInt();
-
-            if (magic != WAL_MAGIC) {
-                log.warn("Invalid WAL magic in {}: 0x{} (expected 0x{})",
-                        chunkPath, Integer.toHexString(magic), Integer.toHexString(WAL_MAGIC));
-                return;
-            }
-            if (version != WAL_VERSION) {
-                log.warn("Unsupported WAL version in {}: {} (expected {})",
-                        chunkPath, version, WAL_VERSION);
-                return;
-            }
-
-            // Read events
-            while (ch.position() < fileSize) {
-                WalEvent event = readEventFromChannel(ch, chunkPath, version);
-                if (event == null) break; // torn-write truncation was triggered, stop
-                out.add(event);
-            }
-        }
-    }
-
-    /**
-     * Reads a single event from a FileChannel at the current position.
-     *
-     * @return the deserialized event, or null if the record is truncated
-     */
-    private WalEvent readEventFromChannel(FileChannel ch, Path source, int fileVersion) throws IOException {
-        if (fileVersion != WAL_VERSION) {
-            throw new WalCorruptionException("Unsupported file version: " + fileVersion + " (expected " + WAL_VERSION + ")");
-        }
-
-        long startPos = ch.position();
-        if (ch.size() - startPos < 40) {
-            if (ch.size() - startPos > 0) {
-                handleTornWrite(source, ch, startPos);
-            }
-            return null; // EOF
-        }
-
-        // Read 40-byte header
-        ByteBuffer headerBuf = ByteBuffer.allocate(40);
-        int bytesRead = ch.read(headerBuf);
-        if (bytesRead < 40) {
-            handleTornWrite(source, ch, startPos);
-            return null;
-        }
-        headerBuf.flip();
-
-        // Offset 0-1: Record Magic
-        short magic = headerBuf.getShort();
-        if (magic != RECORD_MAGIC) {
-            handleMiddleLogCorruption(source, ch, startPos, "Record magic mismatch: expected 0x5741, got 0x" + Integer.toHexString(magic & 0xFFFF));
-            return null;
-        }
-
-        // Offset 2-7: Metadata
-        byte recVersion = headerBuf.get();
-        byte flags = headerBuf.get();
-        byte typeOrd = headerBuf.get();
-        int idLen = headerBuf.getShort() & 0xFFFF;
-        byte reserved = headerBuf.get();
-
-        // Offset 8-15: Sequence Number
-        long sequence = headerBuf.getLong();
-
-        // Offset 16-23: Timestamp
-        long timestampMs = headerBuf.getLong();
-
-        // Offset 24-27: Payload Length
-        int payloadLen = headerBuf.getInt();
-
-        // Offset 28-31: Payload CRC
-        int payloadCrc = headerBuf.getInt();
-
-        // Offset 32-35: Reserved field
-        int reserved4 = headerBuf.getInt();
-
-        // Offset 36-39: Header CRC
-        int headerCrc = headerBuf.getInt();
-
-        // Verify Header CRC-32C
-        int computedHeaderCrc = calculateCrc32(headerBuf, 36);
-        if (headerCrc != computedHeaderCrc) {
-            handleMiddleLogCorruption(source, ch, startPos, "Header CRC mismatch: expected " + headerCrc + ", got " + computedHeaderCrc);
-            return null;
-        }
-
-        // Variable segments
-        int totalVarLen = idLen + payloadLen;
-        int paddingLen = (8 - (totalVarLen % 8)) % 8;
-        int expectedRecordSize = totalVarLen + paddingLen;
-
-        if (ch.position() + expectedRecordSize > ch.size()) {
-            handleTornWrite(source, ch, startPos);
-            return null;
-        }
-
-        ByteBuffer varBuf = ByteBuffer.allocate(expectedRecordSize);
-        bytesRead = ch.read(varBuf);
-        if (bytesRead < expectedRecordSize) {
-            handleTornWrite(source, ch, startPos);
-            return null;
-        }
-        varBuf.flip();
-
-        byte[] idBytes = new byte[idLen];
-        varBuf.get(idBytes);
-        byte[] payloadBytes = new byte[payloadLen];
-        varBuf.get(payloadBytes);
-
-        // Verify Payload CRC-32C
-        int computedPayloadCrc = calculateCrc32(payloadBytes);
-        if (payloadCrc != computedPayloadCrc) {
-            handleMiddleLogCorruption(source, ch, startPos, "Payload CRC mismatch: expected " + payloadCrc + ", got " + computedPayloadCrc);
-            return null;
-        }
-
-        // Decompress payload if necessary
-        if ((flags & 1) != 0) {
-            payloadBytes = decompress(payloadBytes);
-        }
-
-        WalEvent.EventType type = WalEvent.EventType.values()[typeOrd];
-        String memoryId = new String(idBytes, StandardCharsets.UTF_8);
-        Instant timestamp = Instant.ofEpochMilli(timestampMs);
-
-        return new WalEvent(sequence, type, memoryId, timestamp, payloadBytes);
-    }
-
-    /**
-     * Finds all WAL chunk files in the WAL directory, sorted by name (ascending).
-     */
-    private List<Path> findChunkFiles() throws IOException {
-        if (walDir == null || !Files.isDirectory(walDir)) return List.of();
-
-        try (var stream = Files.list(walDir)) {
-            return stream
-                    .filter(p -> p.getFileName().toString().startsWith("wal-") &&
-                                 p.getFileName().toString().endsWith(".bin"))
-                    .sorted()
-                    .toList();
-        }
-    }
-
-    /**
-     * Generates a chunk file name from the chunk index.
-     */
-    static String chunkFileName(int index) {
-        return String.format("wal-%06d.bin", index);
-    }
-
-    /**
-     * Truncates historical closed WAL chunk files where the maximum sequence
-     * number in the chunk is less than or equal to the snapshot High-Water Mark.
-     *
-     * @param snapshotHwm the sequence number up to which all mutations are persisted
-     */
-    public void truncateBefore(long snapshotHwm) {
-        if (walDir == null) return;
-
-        writeLock.lock();
-        try {
-            List<Path> chunks = findChunkFiles();
-            for (Path chunk : chunks) {
-                // Never truncate/delete the active chunk
-                if (chunk.equals(activeChunkPath)) {
-                    continue;
-                }
-
-                long maxSeqInChunk;
-                try {
-                    maxSeqInChunk = getMaxSequenceInChunk(chunk);
-                } catch (IOException e) {
-                    log.error("Failed to read maximum sequence in chunk " + chunk + " during truncation", e);
-                    continue;
-                }
-
-                if (maxSeqInChunk <= snapshotHwm) {
-                    try {
-                        Files.delete(chunk);
-                        log.info("Truncated WAL chunk {} (maxSeq={} <= snapshotHwm={})", chunk.getFileName(), maxSeqInChunk, snapshotHwm);
-                    } catch (IOException e) {
-                        log.warn("Failed to delete WAL chunk {}: {}", chunk, e.getMessage());
-                    }
-                } else {
-                    // Once we encounter a chunk with sequence > snapshotHwm, stop truncating
-                    break;
-                }
-            }
-
-            // Also clean up in-memory cache events to prevent memory bloating
-            events.removeIf(e -> e.sequence() <= snapshotHwm);
-
-        } catch (IOException e) {
-            log.error("WAL truncation failed", e);
-        } finally {
-            writeLock.unlock();
-        }
-    }
-
-    long getMaxSequenceInChunk(Path chunkPath) throws IOException {
-        try (FileChannel ch = FileChannel.open(chunkPath, StandardOpenOption.READ, StandardOpenOption.WRITE)) {
-            long fileSize = ch.size();
-            if (fileSize < FILE_HEADER_BYTES) return 0L;
-
-            ByteBuffer headerBuf = ByteBuffer.allocate(FILE_HEADER_BYTES);
-            ch.read(headerBuf);
-            headerBuf.flip();
-            int magic = headerBuf.getInt();
-            int version = headerBuf.getInt();
-
-            if (magic != WAL_MAGIC || version != WAL_VERSION) {
-                return 0L;
-            }
-
-            long maxSeq = 0L;
-            while (ch.position() < fileSize) {
-                WalEvent event = readEventFromChannel(ch, chunkPath, version);
-                if (event == null) break;
-                maxSeq = Math.max(maxSeq, event.sequence());
-            }
-            return maxSeq;
-        }
-    }
-
-    private static int parseChunkIndex(String filename) {
-        try {
-            // filename format: wal-XXXXXX.bin
-            String numPart = filename.substring(4, 10);
-            return Integer.parseInt(numPart);
-        } catch (Exception e) {
-            return 0;
-        }
-    }
-
-    private void handleTornWrite(Path path, FileChannel fc, long startPos) throws IOException {
-        log.warn("Torn WAL record detected in {} at position {}. Truncating file to recovery boundary.", path, startPos);
-        fc.truncate(startPos);
-        fc.force(true);
-    }
-
-    private void handleMiddleLogCorruption(Path path, FileChannel fc, long startPos, String reason) throws IOException {
-        log.error("Fatal mid-log corruption in {} at position {}: {}. Triggering quarantine.", path, startPos, reason);
-        fc.close();
-
-        Path quarantineDir = path.getParent().resolve(".quarantine");
-        Files.createDirectories(quarantineDir);
-        Path quarantinedPath = quarantineDir.resolve(path.getFileName());
-        Files.move(path, quarantinedPath, java.nio.file.StandardCopyOption.REPLACE_EXISTING);
-        log.warn("Quarantined corrupted WAL chunk {} to {}", path, quarantinedPath);
-
-        throw new WalCorruptionException("Fatal WAL corruption: " + reason + " at position " + startPos + " in file " + path);
-    }
-
-    private byte[] compress(byte[] data) {
-        Deflater deflater = new Deflater();
-        deflater.setInput(data);
-        deflater.finish();
-
-        ByteArrayOutputStream bos = new ByteArrayOutputStream(data.length);
-        byte[] buffer = new byte[1024];
-        while (!deflater.finished()) {
-            int count = deflater.deflate(buffer);
-            bos.write(buffer, 0, count);
-        }
-        deflater.end();
-        return bos.toByteArray();
-    }
-
-    private byte[] decompress(byte[] data) throws IOException {
-        Inflater inflater = new Inflater();
-        inflater.setInput(data);
-
-        ByteArrayOutputStream bos = new ByteArrayOutputStream(data.length * 2);
-        byte[] buffer = new byte[1024];
-        try {
-            while (!inflater.finished()) {
-                int count = inflater.inflate(buffer);
-                bos.write(buffer, 0, count);
-            }
-        } catch (DataFormatException e) {
-            throw new IOException("Failed to decompress WAL payload", e);
-        } finally {
-            inflater.end();
-        }
-        return bos.toByteArray();
-    }
-
-    private static int calculateCrc32(byte[] bytes) {
-        CRC32 crc = new CRC32();
-        crc.update(bytes);
-        return (int) crc.getValue();
-    }
-
-    private static int calculateCrc32(ByteBuffer buf, int length) {
-        CRC32 crc = new CRC32();
-        int originalPosition = buf.position();
-        buf.position(0);
-        byte[] temp = new byte[length];
-        buf.get(temp);
-        buf.position(originalPosition);
-        crc.update(temp);
-        return (int) crc.getValue();
-    }
-}
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/sync/StorageAdapter.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/sync/StorageAdapter.java
deleted file mode 100644
index d07fd26..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/sync/StorageAdapter.java
+++ /dev/null
@@ -1,77 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.sync;
-
-import java.nio.ByteBuffer;
-
-/**
- * Service Provider Interface for cloud storage backends.
- *
- * <p>Implementations provide WAL chunk upload/download for distributed
- * memory sync. Each agent uploads its WAL to a namespace-isolated path.</p>
- *
- * <h3>Built-in Implementations (V2+)</h3>
- * <ul>
- *   <li>Future: {@code S3StorageAdapter} — AWS S3</li>
- *   <li>Future: {@code GcsStorageAdapter} — Google Cloud Storage</li>
- *   <li>Future: {@code LocalStorageAdapter} — local filesystem (testing)</li>
- * </ul>
- *
- * @see CloudSync
- */
-public interface StorageAdapter extends AutoCloseable {
-
-    /**
-     * Uploads a WAL chunk to remote storage.
-     *
-     * @param namespace  agent namespace (isolation boundary)
-     * @param chunkName  chunk identifier (e.g., "wal-000001.bin")
-     * @param data       chunk data
-     */
-    void upload(String namespace, String chunkName, ByteBuffer data);
-
-    /**
-     * Downloads a WAL chunk from remote storage.
-     *
-     * @param namespace  agent namespace
-     * @param chunkName  chunk identifier
-     * @return chunk data, or null if not found
-     */
-    ByteBuffer download(String namespace, String chunkName);
-
-    /**
-     * Lists available WAL chunks for a namespace, ordered by name.
-     *
-     * @param namespace agent namespace
-     * @return chunk names in order
-     */
-    java.util.List<String> listChunks(String namespace);
-
-    /**
-     * Lists all namespaces (agent IDs) with available WAL data.
-     *
-     * @return namespace identifiers
-     */
-    java.util.List<String> listNamespaces();
-
-    /**
-     * Checks if the adapter is connected and ready.
-     */
-    boolean isAvailable();
-
-    /**
-     * Default no-op close.
-     */
-    @Override
-    default void close() {}
-}
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/sync/WalCorruptionException.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/sync/WalCorruptionException.java
deleted file mode 100644
index 0c2d700..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/sync/WalCorruptionException.java
+++ /dev/null
@@ -1,29 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.sync;
-
-import java.io.IOException;
-
-/**
- * Thrown when the Write-Ahead Log (WAL) detects unrecoverable mid-log data corruption or checksum mismatch.
- */
-public class WalCorruptionException extends IOException {
-    
-    public WalCorruptionException(String message) {
-        super(message);
-    }
-
-    public WalCorruptionException(String message, Throwable cause) {
-        super(message, cause);
-    }
-}
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/sync/WalEvent.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/sync/WalEvent.java
deleted file mode 100644
index 92de0e2..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/sync/WalEvent.java
+++ /dev/null
@@ -1,55 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.sync;
-
-import java.time.Instant;
-
-/**
- * Immutable event entry for the memory Write-Ahead Log.
- *
- * <p>Every mutation (remember, forget, reinforce) produces a WAL event.
- * These events are the source-of-truth for memory state and enable
- * replay-based replication.</p>
- *
- * @param sequence   monotonically increasing event sequence number
- * @param type       the event type (REMEMBER, FORGET, REINFORCE, REFLECT)
- * @param memoryId   the memory ID this event applies to
- * @param timestamp  when the event occurred
- * @param payload    serialized event data (format depends on type)
- */
-public record WalEvent(
-        long sequence,
-        EventType type,
-        String memoryId,
-        Instant timestamp,
-        byte[] payload
-) {
-
-    /**
-     * Event types for the write-ahead log.
-     */
-    public enum EventType {
-        /** New memory was stored. */
-        REMEMBER,
-        /** Memory was tombstoned. */
-        FORGET,
-        /** Memory valence was reinforced. */
-        REINFORCE,
-        /** Sleep consolidation promoted/pruned memories. */
-        REFLECT,
-        /** Synaptic tags were merged. */
-        TAG_MERGE,
-        /** Memory recall count was incremented. */
-        RECALL_HIT
-    }
-}
diff --git a/spector-memory/src/main/java/com/spectrayan/spector/memory/temporal/TemporalChain.java b/spector-memory/src/main/java/com/spectrayan/spector/memory/temporal/TemporalChain.java
deleted file mode 100644
index 00b4e44..0000000
--- a/spector-memory/src/main/java/com/spectrayan/spector/memory/temporal/TemporalChain.java
+++ /dev/null
@@ -1,317 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.temporal;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.io.IOException;
-
-import com.spectrayan.spector.memory.error.SpectorGraphPersistenceException;
-import java.lang.foreign.Arena;
-import java.lang.foreign.MemorySegment;
-import java.lang.foreign.ValueLayout;
-import java.nio.ByteBuffer;
-import java.nio.channels.FileChannel;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.nio.file.StandardOpenOption;
-import java.util.ArrayList;
-import java.util.List;
-
-/**
- * Off-heap temporal causal chain linking memories within a session.
- *
- * <h3>Biological Analog: Episodic Sequence Memory</h3>
- * <p>In the hippocampus, episodic memories are linked in temporal order.
- * When you recall one event from a day, you naturally remember what happened
- * next ("what happened after the meeting?"). This chain stores explicit
- * prev/next pointers between memories ingested within the same session.</p>
- *
- * <h3>Layout Per Node (16 bytes)</h3>
- * <pre>
- *   [prevIdx:4B] [nextIdx:4B] [sessionId:4B] [pad:4B]
- * </pre>
- *
- * <p>-1 is used as sentinel for "no link" (beginning or end of chain).</p>
- *
- * <h3>Persistence</h3>
- * <p>Supports save/load via raw segment serialization with "TPCH" magic header.</p>
- */
-public final class TemporalChain implements AutoCloseable {
-
-    private static final Logger log = LoggerFactory.getLogger(TemporalChain.class);
-
-    /** File magic: "TPCH" in ASCII. */
-    private static final int FILE_MAGIC = 0x54504348;
-    private static final int FILE_VERSION = 1;
-    private static final int FILE_HEADER_BYTES = 16;
-
-    /** Bytes per node: prevIdx(4) + nextIdx(4) + sessionId(4) + pad(4). */
-    static final int NODE_BYTES = 16;
-
-    /** Sentinel value for "no link". */
-    private static final int NO_LINK = -1;
-
-    // Offsets within each node
-    private static final long OFF_PREV = 0;
-    private static final long OFF_NEXT = 4;
-    private static final long OFF_SESSION = 8;
-
-    private final Arena arena;
-    private final MemorySegment segment;
-    private final int capacity;
-
-    /**
-     * Creates a new temporal chain.
-     *
-     * @param capacity maximum number of nodes (memories)
-     */
-    public TemporalChain(int capacity) {
-        this.capacity = capacity;
-        this.arena = Arena.ofShared();
-        this.segment = arena.allocate((long) NODE_BYTES * capacity);
-        // Initialize all prev/next to NO_LINK (-1)
-        for (int i = 0; i < capacity; i++) {
-            long offset = (long) i * NODE_BYTES;
-            segment.set(ValueLayout.JAVA_INT, offset + OFF_PREV, NO_LINK);
-            segment.set(ValueLayout.JAVA_INT, offset + OFF_NEXT, NO_LINK);
-            segment.set(ValueLayout.JAVA_INT, offset + OFF_SESSION, 0);
-        }
-
-        log.info("TemporalChain initialized: capacity={}, memory={}KB",
-                capacity, (long) NODE_BYTES * capacity / 1024);
-    }
-
-    /**
-     * Private constructor for loading from a pre-existing segment.
-     */
-    private TemporalChain(int capacity, Arena arena, MemorySegment segment) {
-        this.capacity = capacity;
-        this.arena = arena;
-        this.segment = segment;
-    }
-
-    /**
-     * Links two memories in temporal order within the same session.
-     *
-     * <p>After this call, {@code previousIdx.next = currentIdx} and
-     * {@code currentIdx.prev = previousIdx}.</p>
-     *
-     * @param currentIdx  index of the memory just ingested
-     * @param previousIdx index of the memory ingested immediately before
-     * @param sessionId   session identifier (e.g., hash of session start time)
-     */
-    public void link(int currentIdx, int previousIdx, int sessionId) {
-        if (currentIdx < 0 || currentIdx >= capacity) return;
-        if (previousIdx < 0 || previousIdx >= capacity) return;
-        if (currentIdx == previousIdx) return;
-
-        long currentOffset = (long) currentIdx * NODE_BYTES;
-        long previousOffset = (long) previousIdx * NODE_BYTES;
-
-        // currentIdx.prev = previousIdx
-        segment.set(ValueLayout.JAVA_INT, currentOffset + OFF_PREV, previousIdx);
-        segment.set(ValueLayout.JAVA_INT, currentOffset + OFF_SESSION, sessionId);
-
-        // previousIdx.next = currentIdx
-        segment.set(ValueLayout.JAVA_INT, previousOffset + OFF_NEXT, currentIdx);
-    }
-
-    /**
-     * Follows the chain forward from a starting memory.
-     *
-     * @param startIdx the starting memory index
-     * @param maxHops  maximum number of hops to follow
-     * @return list of memory indices in temporal order (excludes startIdx)
-     */
-    public List<Integer> followForward(int startIdx, int maxHops) {
-        if (startIdx < 0 || startIdx >= capacity) return List.of();
-        List<Integer> chain = new ArrayList<>();
-        int current = startIdx;
-        for (int hop = 0; hop < maxHops; hop++) {
-            long offset = (long) current * NODE_BYTES;
-            int next = segment.get(ValueLayout.JAVA_INT, offset + OFF_NEXT);
-            if (next == NO_LINK || next < 0 || next >= capacity) break;
-            chain.add(next);
-            current = next;
-        }
-        return chain;
-    }
-
-    /**
-     * Follows the chain backward from a starting memory.
-     *
-     * @param startIdx the starting memory index
-     * @param maxHops  maximum number of hops to follow
-     * @return list of memory indices in reverse temporal order (excludes startIdx)
-     */
-    public List<Integer> followBackward(int startIdx, int maxHops) {
-        if (startIdx < 0 || startIdx >= capacity) return List.of();
-        List<Integer> chain = new ArrayList<>();
-        int current = startIdx;
-        for (int hop = 0; hop < maxHops; hop++) {
-            long offset = (long) current * NODE_BYTES;
-            int prev = segment.get(ValueLayout.JAVA_INT, offset + OFF_PREV);
-            if (prev == NO_LINK || prev < 0 || prev >= capacity) break;
-            chain.add(prev);
-            current = prev;
-        }
-        return chain;
-    }
-
-    /**
-     * Returns the session ID for a memory.
-     */
-    public int sessionOf(int idx) {
-        if (idx < 0 || idx >= capacity) return 0;
-        return segment.get(ValueLayout.JAVA_INT, (long) idx * NODE_BYTES + OFF_SESSION);
-    }
-
-    /**
-     * Returns whether a memory has any temporal links.
-     */
-    public boolean isLinked(int idx) {
-        if (idx < 0 || idx >= capacity) return false;
-        long offset = (long) idx * NODE_BYTES;
-        int prev = segment.get(ValueLayout.JAVA_INT, offset + OFF_PREV);
-        int next = segment.get(ValueLayout.JAVA_INT, offset + OFF_NEXT);
-        return prev != NO_LINK || next != NO_LINK;
-    }
-
-    /**
-     * Returns the capacity.
-     */
-    public int capacity() {
-        return capacity;
-    }
-
-    // ══════════════════════════════════════════════════════════════
-    // PERSISTENCE: save / load
-    // ══════════════════════════════════════════════════════════════
-
-    /**
-     * Saves the chain to a binary file.
-     *
-     * @param filePath path to write
-     */
-    public void save(Path filePath) {
-        Path parent = filePath.getParent();
-        if (parent != null) {
-            try {
-                Files.createDirectories(parent);
-            } catch (IOException e) {
-                throw new SpectorGraphPersistenceException("TemporalChain", parent, e);
-            }
-        }
-
-        try (FileChannel ch = FileChannel.open(filePath,
-                StandardOpenOption.CREATE, StandardOpenOption.WRITE,
-                StandardOpenOption.TRUNCATE_EXISTING)) {
-
-            ByteBuffer header = ByteBuffer.allocate(FILE_HEADER_BYTES);
-            header.putInt(FILE_MAGIC);
-            header.putInt(FILE_VERSION);
-            header.putInt(capacity);
-            header.putInt(0);
-            header.flip();
-            ch.write(header);
-
-            long totalBytes = (long) NODE_BYTES * capacity;
-            long written = 0;
-            int chunkSize = 64 * 1024;
-            while (written < totalBytes) {
-                int toWrite = (int) Math.min(chunkSize, totalBytes - written);
-                ByteBuffer buf = segment.asSlice(written, toWrite)
-                        .asByteBuffer().asReadOnlyBuffer();
-                ch.write(buf);
-                written += toWrite;
-            }
-
-            ch.force(true);
-            log.info("TemporalChain saved: capacity={} → {}", capacity, filePath);
-
-        } catch (IOException e) {
-            throw new SpectorGraphPersistenceException("TemporalChain", filePath, e);
-        }
-    }
-
-    /**
-     * Loads a chain from a binary file, or returns a new empty chain.
-     *
-     * @param filePath        path to the chain file
-     * @param defaultCapacity capacity to use if file doesn't exist
-     * @return a TemporalChain (loaded or new)
-     */
-    public static TemporalChain load(Path filePath, int defaultCapacity) {
-        if (filePath == null || !Files.exists(filePath)) {
-            log.info("TemporalChain file not found, creating fresh: {}", filePath);
-            return new TemporalChain(defaultCapacity);
-        }
-
-        try (FileChannel ch = FileChannel.open(filePath, StandardOpenOption.READ)) {
-            long fileSize = ch.size();
-            if (fileSize < FILE_HEADER_BYTES) {
-                log.warn("TemporalChain file too small, creating fresh");
-                return new TemporalChain(defaultCapacity);
-            }
-
-            ByteBuffer header = ByteBuffer.allocate(FILE_HEADER_BYTES);
-            ch.read(header);
-            header.flip();
-
-            int magic = header.getInt();
-            int version = header.getInt();
-            int capacity = header.getInt();
-            header.getInt();
-
-            if (magic != FILE_MAGIC || version != FILE_VERSION) {
-                log.warn("Invalid TemporalChain file, creating fresh");
-                return new TemporalChain(defaultCapacity);
-            }
-
-            long expectedBytes = (long) NODE_BYTES * capacity;
-            if (fileSize < FILE_HEADER_BYTES + expectedBytes) {
-                log.warn("TemporalChain file truncated, creating fresh");
-                return new TemporalChain(defaultCapacity);
-            }
-
-            Arena arena = Arena.ofShared();
-            MemorySegment seg = arena.allocate(expectedBytes);
-            long read = 0;
-            int chunkSize = 64 * 1024;
-            while (read < expectedBytes) {
-                int toRead = (int) Math.min(chunkSize, expectedBytes - read);
-                ByteBuffer buf = ByteBuffer.allocate(toRead);
-                ch.read(buf);
-                buf.flip();
-                MemorySegment.copy(MemorySegment.ofBuffer(buf), 0, seg, read, toRead);
-                read += toRead;
-            }
-
-            TemporalChain chain = new TemporalChain(capacity, arena, seg);
-            log.info("TemporalChain loaded: capacity={} from {}", capacity, filePath);
-            return chain;
-
-        } catch (IOException e) {
-            log.error("Failed to load TemporalChain, creating fresh: {}", e.getMessage());
-            return new TemporalChain(defaultCapacity);
-        }
-    }
-
-    @Override
-    public void close() {
-        log.info("TemporalChain closing (capacity={})", capacity);
-        arena.close();
-    }
-}
diff --git a/spector-memory/src/main/resources/prompts/entity-extraction.txt b/spector-memory/src/main/resources/prompts/entity-extraction.txt
deleted file mode 100644
index 96c0584..0000000
--- a/spector-memory/src/main/resources/prompts/entity-extraction.txt
+++ /dev/null
@@ -1,33 +0,0 @@
-Extract named entities and their relationships from the following text.
-
-For each entity, output a line in this exact format:
-ENTITY: <name> | <type>
-
-Valid entity types:
-  People & Org:     PERSON, ORGANIZATION, TEAM, ROLE
-  Projects:         PROJECT, PRODUCT, TASK
-  Knowledge:        CONCEPT, TOPIC, SKILL, DECISION
-  Technology:       TECHNOLOGY, TOOL, API, ARTIFACT
-  World:            EVENT, LOCATION, DATE_TIME
-  Process & Data:   PROCESS, METRIC, DOCUMENT
-  Fallback:         OTHER
-
-For each relationship between entities, output a line in this exact format:
-RELATION: <source entity name> | <relation type> | <target entity name>
-
-Valid relation types:
-  People:       MANAGES, REPORTS_TO, KNOWS, ASSIGNED_TO, AUTHORED
-  Work:         WORKS_ON, CREATED_BY, OWNS, IMPLEMENTS
-  Structure:    PART_OF, CONTAINS, DEPENDS_ON, USES
-  Causality:    CAUSES, BLOCKS, SUPERSEDES, PRECEDES, FOLLOWS
-  Location:     LOCATED_AT
-  General:      RELATED_TO, OTHER
-
-Rules:
-- Output ONLY ENTITY and RELATION lines, nothing else.
-- Entity names should be concise but unambiguous.
-- Use the most specific type available; use OTHER only as a last resort.
-- Maximum %d entities and %d relations.
-
-Text:
-%s
diff --git a/spector-memory/src/test/java/com/spectrayan/spector/memory/CognitiveProfileTest.java b/spector-memory/src/test/java/com/spectrayan/spector/memory/CognitiveProfileTest.java
deleted file mode 100644
index 3cd58a0..0000000
--- a/spector-memory/src/test/java/com/spectrayan/spector/memory/CognitiveProfileTest.java
+++ /dev/null
@@ -1,124 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory;
-
-import org.junit.jupiter.api.Test;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-/**
- * Tests for {@link CognitiveProfile} — thalamic modulation presets.
- */
-class CognitiveProfileTest {
-
-    @Test
-    void balancedProfile_defaultWeights() {
-        assertThat(CognitiveProfile.BALANCED.alpha()).isEqualTo(0.6f);
-        assertThat(CognitiveProfile.BALANCED.beta()).isEqualTo(0.4f);
-        assertThat(CognitiveProfile.BALANCED.minValence()).isEqualTo(Byte.MIN_VALUE);
-        assertThat(CognitiveProfile.BALANCED.maxValence()).isEqualTo(Byte.MAX_VALUE);
-    }
-
-    @Test
-    void debuggingProfile_negativeValenceBias() {
-        assertThat(CognitiveProfile.DEBUGGING.alpha()).isLessThan(CognitiveProfile.DEBUGGING.beta());
-        assertThat(CognitiveProfile.DEBUGGING.maxValence()).isLessThan((byte) 0);
-    }
-
-    @Test
-    void exploringProfile_similarityDominated() {
-        assertThat(CognitiveProfile.EXPLORING.alpha()).isGreaterThan(CognitiveProfile.EXPLORING.beta());
-        assertThat(CognitiveProfile.EXPLORING.minValence()).isEqualTo(Byte.MIN_VALUE);
-        assertThat(CognitiveProfile.EXPLORING.maxValence()).isEqualTo(Byte.MAX_VALUE);
-    }
-
-    @Test
-    void recallingProfile_positiveValenceBias() {
-        assertThat(CognitiveProfile.RECALLING.minValence()).isGreaterThan((byte) 0);
-        assertThat(CognitiveProfile.RECALLING.maxValence()).isEqualTo(Byte.MAX_VALUE);
-    }
-
-    @Test
-    void criticalProfile_importanceDominated() {
-        assertThat(CognitiveProfile.CRITICAL.beta()).isGreaterThan(CognitiveProfile.CRITICAL.alpha());
-        assertThat(CognitiveProfile.CRITICAL.beta()).isEqualTo(0.8f);
-    }
-
-    @Test
-    void applyTo_setsBuilderFields() {
-        RecallOptions options = RecallOptions.builder()
-                .profile(CognitiveProfile.DEBUGGING)
-                .topK(20)
-                .build();
-
-        assertThat(options.alpha()).isEqualTo(CognitiveProfile.DEBUGGING.alpha());
-        assertThat(options.beta()).isEqualTo(CognitiveProfile.DEBUGGING.beta());
-        assertThat(options.minValence()).isEqualTo(CognitiveProfile.DEBUGGING.minValence());
-        assertThat(options.maxValence()).isEqualTo(CognitiveProfile.DEBUGGING.maxValence());
-        assertThat(options.topK()).isEqualTo(20); // independent of profile
-    }
-
-    @Test
-    void profileOverrides_workCorrectly() {
-        // Profile sets alpha=0.3, but explicit override changes it to 0.5
-        RecallOptions options = RecallOptions.builder()
-                .profile(CognitiveProfile.DEBUGGING)
-                .alpha(0.5f) // override profile's alpha
-                .build();
-
-        assertThat(options.alpha()).isEqualTo(0.5f); // overridden
-        assertThat(options.beta()).isEqualTo(CognitiveProfile.DEBUGGING.beta()); // from profile
-    }
-
-    @Test
-    void detectFromTags_debuggingKeywords() {
-        assertThat(CognitiveProfile.detect("error", "database")).isEqualTo(CognitiveProfile.DEBUGGING);
-        assertThat(CognitiveProfile.detect("crash-report")).isEqualTo(CognitiveProfile.DEBUGGING);
-        assertThat(CognitiveProfile.detect("fix", "urgent")).isEqualTo(CognitiveProfile.CRITICAL); // critical > debug
-    }
-
-    @Test
-    void detectFromTags_recallingKeywords() {
-        assertThat(CognitiveProfile.detect("solution", "patterns")).isEqualTo(CognitiveProfile.RECALLING);
-        assertThat(CognitiveProfile.detect("best-practice")).isEqualTo(CognitiveProfile.RECALLING);
-    }
-
-    @Test
-    void detectFromTags_criticalKeywords() {
-        assertThat(CognitiveProfile.detect("security", "api")).isEqualTo(CognitiveProfile.CRITICAL);
-        assertThat(CognitiveProfile.detect("production", "outage")).isEqualTo(CognitiveProfile.CRITICAL);
-    }
-
-    @Test
-    void detectFromTags_noMatch_returnsBalanced() {
-        assertThat(CognitiveProfile.detect("java", "spring")).isEqualTo(CognitiveProfile.BALANCED);
-        assertThat(CognitiveProfile.detect()).isEqualTo(CognitiveProfile.BALANCED);
-        assertThat(CognitiveProfile.detect((String[]) null)).isEqualTo(CognitiveProfile.BALANCED);
-    }
-
-    @Test
-    void detectPriority_criticalOverDebugging() {
-        // "critical" + "error" → CRITICAL wins (higher priority)
-        assertThat(CognitiveProfile.detect("critical", "error"))
-                .isEqualTo(CognitiveProfile.CRITICAL);
-    }
-
-    @Test
-    void allProfilesSumToOne() {
-        for (CognitiveProfile profile : CognitiveProfile.values()) {
-            float sum = profile.alpha() + profile.beta();
-            assertThat(sum).as("alpha + beta for %s", profile)
-                    .isCloseTo(1.0f, org.assertj.core.data.Offset.offset(0.001f));
-        }
-    }
-}
diff --git a/spector-memory/src/test/java/com/spectrayan/spector/memory/MemoryEnhancementTest.java b/spector-memory/src/test/java/com/spectrayan/spector/memory/MemoryEnhancementTest.java
deleted file mode 100644
index fce5312..0000000
--- a/spector-memory/src/test/java/com/spectrayan/spector/memory/MemoryEnhancementTest.java
+++ /dev/null
@@ -1,546 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory;
-
-import com.spectrayan.spector.memory.cortex.MemorySource;
-import com.spectrayan.spector.memory.synapse.DecayStrategy;
-import com.spectrayan.spector.memory.synapse.SynapticHeaderConstants;
-import com.spectrayan.spector.embed.EmbeddingProvider;
-import com.spectrayan.spector.embed.EmbeddingResult;
-import org.junit.jupiter.api.AfterEach;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.DisplayName;
-import org.junit.jupiter.api.Nested;
-import org.junit.jupiter.api.Test;
-
-import java.util.List;
-import java.util.Random;
-import java.util.concurrent.TimeUnit;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.data.Offset.offset;
-
-/**
- * Comprehensive tests for the memory enhancement features:
- *
- * <ul>
- *   <li>P0: Embedding normalization at ingestion</li>
- *   <li>P1: Parabolic RBF for lateral scoring</li>
- *   <li>P1: Zeigarnik Effect (IS_RESOLVED flag)</li>
- *   <li>P1: Strictness coefficient for SYSTEMATIZER</li>
- *   <li>P2: Bit-shift reconsolidation</li>
- *   <li>P2: Valence alignment scoring</li>
- *   <li>P2: Semantic satiation LRU cache</li>
- *   <li>P3: New profiles (PARANOID_SENTINEL, THE_EXECUTOR, DEFAULT_MODE_NETWORK)</li>
- *   <li>Profile configuration (operational feature flags)</li>
- * </ul>
- */
-class MemoryEnhancementTest {
-
-    private static final int DIMENSIONS = 32;
-    private SpectorMemory memory;
-
-    @BeforeEach
-    void setUp() {
-        memory = DefaultSpectorMemory.builder()
-                .dimensions(DIMENSIONS)
-                .embeddingProvider(new NormalizingMockProvider(DIMENSIONS))
-                .persistenceMode(MemoryPersistenceMode.IN_MEMORY)
-                .workingCapacity(20)
-                .episodicPartitionCapacity(100)
-                .semanticCapacity(100)
-                .proceduralCapacity(100)
-                .build();
-    }
-
-    @AfterEach
-    void tearDown() {
-        memory.close();
-    }
-
-    // ═══════════════════════════════════════════════════════════════
-    // P1: Zeigarnik Effect
-    // ═══════════════════════════════════════════════════════════════
-
-    @Nested
-    @DisplayName("Zeigarnik Effect")
-    class ZeigarnikEffect {
-
-        @Test
-        @DisplayName("Unresolved memories persist in recall (resist decay)")
-        void unresolvedMemoriesPersist() throws Exception {
-            memory.remember("task-open", "Fix the authentication bug in login service.",
-                    MemoryType.EPISODIC, MemorySource.OBSERVED, "bug", "auth").get(5, TimeUnit.SECONDS);
-
-            List<CognitiveResult> results = memory.recall("authentication");
-            assertThat(results).isNotEmpty();
-            assertThat(results.stream().anyMatch(r -> "task-open".equals(r.id()))).isTrue();
-        }
-
-        @Test
-        @DisplayName("markResolved causes memory to succumb to normal decay")
-        void resolvedMemoryDecays() throws Exception {
-            memory.remember("task-done", "Completed the database migration script.",
-                    MemoryType.EPISODIC, MemorySource.OBSERVED, "migration").get(5, TimeUnit.SECONDS);
-
-            memory.markResolved("task-done");
-
-            // Memory should still be findable (it's recent)
-            List<CognitiveResult> results = memory.recall("database migration");
-            // The resolved flag is set — verify it doesn't crash
-            assertThat(results).isNotNull();
-        }
-
-        @Test
-        @DisplayName("markUnresolved re-enters the Zeigarnik loop")
-        void unresolvedReopensLoop() throws Exception {
-            memory.remember("task-reopen", "Deploy monitoring dashboard.",
-                    MemoryType.EPISODIC, MemorySource.OBSERVED, "deploy").get(5, TimeUnit.SECONDS);
-
-            memory.markResolved("task-reopen");
-            memory.markUnresolved("task-reopen");
-
-            // Memory is back to unresolved — should still appear
-            List<CognitiveResult> results = memory.recall("monitoring dashboard");
-            assertThat(results).isNotEmpty();
-        }
-
-        @Test
-        @DisplayName("markResolved on non-existent ID is a no-op")
-        void resolvedNonExistentIsNoop() {
-            // Should not throw
-            memory.markResolved("nonexistent-id-123");
-            memory.markUnresolved("nonexistent-id-456");
-        }
-    }
-
-    // ═══════════════════════════════════════════════════════════════
-    // P1: Strictness Coefficient
-    // ═══════════════════════════════════════════════════════════════
-
-    @Nested
-    @DisplayName("Strictness Coefficient")
-    class StrictnessCoefficient {
-
-        @Test
-        @DisplayName("SYSTEMATIZER profile applies strictness coefficient")
-        void systematizerAppliesStrictness() {
-            RecallOptions opts = RecallOptions.builder()
-                    .profile(CognitiveProfile.SYSTEMATIZER)
-                    .build();
-            assertThat(opts.strictnessCoefficient()).isEqualTo(10.0f);
-        }
-
-        @Test
-        @DisplayName("Default strictness coefficient is 1.0")
-        void defaultStrictnessIsOne() {
-            RecallOptions opts = RecallOptions.builder().build();
-            assertThat(opts.strictnessCoefficient()).isEqualTo(1.0f);
-        }
-
-        @Test
-        @DisplayName("Custom strictness coefficient can be set")
-        void customStrictness() {
-            RecallOptions opts = RecallOptions.builder()
-                    .strictnessCoefficient(5.0f)
-                    .build();
-            assertThat(opts.strictnessCoefficient()).isEqualTo(5.0f);
-        }
-    }
-
-    // ═══════════════════════════════════════════════════════════════
-    // P2: Bit-Shift Reconsolidation
-    // ═══════════════════════════════════════════════════════════════
-
-    @Nested
-    @DisplayName("Bit-Shift Reconsolidation")
-    class BitShiftReconsolidation {
-
-        @Test
-        @DisplayName("Zero recalls means no adjustment")
-        void zeroRecalls() {
-            assertThat(DecayStrategy.adjustForReconsolidation(7, 0)).isEqualTo(7);
-        }
-
-        @Test
-        @DisplayName("Single recall halves bucket index")
-        void singleRecall() {
-            assertThat(DecayStrategy.adjustForReconsolidation(6, 1)).isEqualTo(3);
-            assertThat(DecayStrategy.adjustForReconsolidation(4, 1)).isEqualTo(2);
-        }
-
-        @Test
-        @DisplayName("Multiple recalls produce exponential effect")
-        void multipleRecalls() {
-            // bucket 7 >> 2 = 1
-            assertThat(DecayStrategy.adjustForReconsolidation(7, 2)).isEqualTo(1);
-            // bucket 7 >> 3 = 0
-            assertThat(DecayStrategy.adjustForReconsolidation(7, 3)).isEqualTo(0);
-        }
-
-        @Test
-        @DisplayName("Recall count capped at 5")
-        void recallCountCapped() {
-            // Even with 100 recalls, shift capped at 5
-            assertThat(DecayStrategy.adjustForReconsolidation(7, 100)).isEqualTo(0);
-            assertThat(DecayStrategy.adjustForReconsolidation(32, 5)).isEqualTo(1); // 32 >> 5 = 1
-        }
-    }
-
-    // ═══════════════════════════════════════════════════════════════
-    // P2: Valence Alignment
-    // ═══════════════════════════════════════════════════════════════
-
-    @Nested
-    @DisplayName("Valence Alignment")
-    class ValenceAlignment {
-
-        @Test
-        @DisplayName("queryValence auto-enables alignment")
-        void queryValenceAutoEnables() {
-            RecallOptions opts = RecallOptions.builder()
-                    .queryValence((byte) -50)
-                    .build();
-            assertThat(opts.enableValenceAlignment()).isTrue();
-            assertThat(opts.queryValence()).isEqualTo((byte) -50);
-        }
-
-        @Test
-        @DisplayName("Alignment disabled by default")
-        void disabledByDefault() {
-            RecallOptions opts = RecallOptions.DEFAULT;
-            assertThat(opts.enableValenceAlignment()).isFalse();
-        }
-
-        @Test
-        @DisplayName("PARANOID_SENTINEL sets max-negative queryValence")
-        void paranoidSentinelSetsValence() {
-            RecallOptions opts = RecallOptions.builder()
-                    .profile(CognitiveProfile.PARANOID_SENTINEL)
-                    .build();
-            assertThat(opts.enableValenceAlignment()).isTrue();
-            assertThat(opts.queryValence()).isEqualTo(Byte.MIN_VALUE);
-            assertThat(opts.maxValence()).isEqualTo((byte) -1);
-        }
-    }
-
-    // ═══════════════════════════════════════════════════════════════
-    // P2: Semantic Satiation (Anti-Looping)
-    // ═══════════════════════════════════════════════════════════════
-
-    @Nested
-    @DisplayName("Semantic Satiation")
-    class SemanticSatiation {
-
-        @Test
-        @DisplayName("Repeated recalls reduce scores (satiation + habituation)")
-        void repeatedRecallsReduceScores() throws Exception {
-            memory.remember("satiate-1", "Kubernetes pod scheduling algorithm.",
-                    MemoryType.EPISODIC, MemorySource.OBSERVED, "k8s").get(5, TimeUnit.SECONDS);
-
-            // First recall
-            List<CognitiveResult> first = memory.recall("kubernetes scheduling");
-            float firstScore = first.isEmpty() ? 0 : first.getFirst().score();
-
-            // Second recall — satiation + habituation should reduce score
-            List<CognitiveResult> second = memory.recall("kubernetes scheduling");
-            float secondScore = second.isEmpty() ? 0 : second.getFirst().score();
-
-            if (firstScore > 0 && secondScore > 0) {
-                assertThat(secondScore).isLessThan(firstScore);
-            }
-        }
-    }
-
-    // ═══════════════════════════════════════════════════════════════
-    // P3: New Cognitive Profiles
-    // ═══════════════════════════════════════════════════════════════
-
-    @Nested
-    @DisplayName("New Cognitive Profiles")
-    class NewProfiles {
-
-        @Test
-        @DisplayName("All profiles maintain alpha + beta = 1.0")
-        void allProfilesSumToOne() {
-            for (CognitiveProfile profile : CognitiveProfile.values()) {
-                float sum = profile.alpha() + profile.beta();
-                assertThat(sum).as("alpha + beta for %s", profile)
-                        .isCloseTo(1.0f, offset(0.001f));
-            }
-        }
-
-        @Test
-        @DisplayName("PARANOID_SENTINEL only allows negative valence")
-        void paranoidSentinelNegativeOnly() {
-            assertThat(CognitiveProfile.PARANOID_SENTINEL.maxValence()).isEqualTo((byte) -1);
-            assertThat(CognitiveProfile.PARANOID_SENTINEL.minValence()).isEqualTo(Byte.MIN_VALUE);
-        }
-
-        @Test
-        @DisplayName("THE_EXECUTOR disables lateral mode and sets strictness")
-        void executorConfig() {
-            RecallOptions opts = RecallOptions.builder()
-                    .profile(CognitiveProfile.THE_EXECUTOR)
-                    .build();
-            assertThat(opts.lateralMode()).isFalse();
-            assertThat(opts.strictnessCoefficient()).isEqualTo(10.0f);
-        }
-
-        @Test
-        @DisplayName("DEFAULT_MODE_NETWORK restricts to SEMANTIC + PROCEDURAL tiers")
-        void defaultModeNetworkTiers() {
-            RecallOptions opts = RecallOptions.builder()
-                    .profile(CognitiveProfile.DEFAULT_MODE_NETWORK)
-                    .build();
-            assertThat(opts.memoryTypes()).containsExactlyInAnyOrder(
-                    MemoryType.SEMANTIC, MemoryType.PROCEDURAL);
-        }
-
-        @Test
-        @DisplayName("THE_EXECUTOR recalls with strict matching end-to-end")
-        void executorEndToEnd() throws Exception {
-            memory.remember("exact-match", "Deploy the microservice to production cluster.",
-                    MemoryType.EPISODIC, MemorySource.OBSERVED, "deploy").get(5, TimeUnit.SECONDS);
-
-            List<CognitiveResult> results = memory.recall("deploy microservice",
-                    CognitiveProfile.THE_EXECUTOR);
-            assertThat(results).isNotNull(); // verifies no crash with strictness=10.0
-        }
-    }
-
-    // ═══════════════════════════════════════════════════════════════
-    // Cognitive Profile Configuration (Operational Feature Flags)
-    // ═══════════════════════════════════════════════════════════════
-
-    @Nested
-    @DisplayName("Cognitive Profile Configuration")
-    class ProfileConfiguration {
-
-        @Test
-        @DisplayName("coreOnly blocks neurodivergent and advanced profiles")
-        void coreOnlyBlocksAdvanced() {
-            var config = CognitiveProfileConfig.coreOnly();
-            assertThat(config.validate(CognitiveProfile.HYPERFOCUS)).isEqualTo(CognitiveProfile.BALANCED);
-            assertThat(config.validate(CognitiveProfile.SYSTEMATIZER)).isEqualTo(CognitiveProfile.BALANCED);
-            assertThat(config.validate(CognitiveProfile.PARANOID_SENTINEL)).isEqualTo(CognitiveProfile.BALANCED);
-        }
-
-        @Test
-        @DisplayName("coreOnly allows basic profiles")
-        void coreOnlyAllowsBasic() {
-            var config = CognitiveProfileConfig.coreOnly();
-            assertThat(config.validate(CognitiveProfile.BALANCED)).isEqualTo(CognitiveProfile.BALANCED);
-            assertThat(config.validate(CognitiveProfile.DEBUGGING)).isEqualTo(CognitiveProfile.DEBUGGING);
-            assertThat(config.validate(CognitiveProfile.EXPLORING)).isEqualTo(CognitiveProfile.EXPLORING);
-        }
-
-        @Test
-        @DisplayName("withNeurodivergent allows neuro profiles but blocks advanced")
-        void withNeurodivergentBlocksAdvanced() {
-            var config = CognitiveProfileConfig.withNeurodivergent();
-            assertThat(config.validate(CognitiveProfile.HYPERFOCUS)).isEqualTo(CognitiveProfile.HYPERFOCUS);
-            assertThat(config.validate(CognitiveProfile.PARANOID_SENTINEL)).isEqualTo(CognitiveProfile.BALANCED);
-            assertThat(config.validate(CognitiveProfile.THE_EXECUTOR)).isEqualTo(CognitiveProfile.BALANCED);
-        }
-
-        @Test
-        @DisplayName("allEnabled allows every profile")
-        void allEnabledAllowsAll() {
-            var config = CognitiveProfileConfig.allEnabled();
-            for (CognitiveProfile p : CognitiveProfile.values()) {
-                assertThat(config.validate(p)).isEqualTo(p);
-            }
-        }
-
-        @Test
-        @DisplayName("Custom config with specific profiles")
-        void customConfig() {
-            var config = CognitiveProfileConfig.only(
-                    CognitiveProfile.DEBUGGING, CognitiveProfile.HYPERFOCUS);
-            assertThat(config.isEnabled(CognitiveProfile.BALANCED)).isTrue(); // always included
-            assertThat(config.isEnabled(CognitiveProfile.DEBUGGING)).isTrue();
-            assertThat(config.isEnabled(CognitiveProfile.HYPERFOCUS)).isTrue();
-            assertThat(config.isEnabled(CognitiveProfile.EXPLORING)).isFalse();
-        }
-
-        @Test
-        @DisplayName("Null profile validates to BALANCED")
-        void nullValidatesToBalanced() {
-            var config = CognitiveProfileConfig.allEnabled();
-            assertThat(config.validate(null)).isEqualTo(CognitiveProfile.BALANCED);
-        }
-
-        @Test
-        @DisplayName("requireEnabled throws for disabled profiles")
-        void requireEnabledThrows() {
-            var config = CognitiveProfileConfig.coreOnly();
-            org.assertj.core.api.Assertions.assertThatThrownBy(
-                    () -> config.requireEnabled(CognitiveProfile.HYPERFOCUS))
-                    .isInstanceOf(IllegalArgumentException.class)
-                    .hasMessageContaining("HYPERFOCUS");
-        }
-
-        @Test
-        @DisplayName("requireEnabled passes for enabled profiles")
-        void requireEnabledPasses() {
-            var config = CognitiveProfileConfig.allEnabled();
-            assertThat(config.requireEnabled(CognitiveProfile.THE_EXECUTOR))
-                    .isEqualTo(CognitiveProfile.THE_EXECUTOR);
-        }
-    }
-
-    // ═══════════════════════════════════════════════════════════════
-    // Config YAML Parsing (fromConfigValue)
-    // ═══════════════════════════════════════════════════════════════
-
-    @Nested
-    @DisplayName("Config YAML Parsing")
-    class ConfigParsing {
-
-        @Test
-        @DisplayName("'ALL' enables all profiles")
-        void allPreset() {
-            var config = CognitiveProfileConfig.fromConfigValue("ALL");
-            for (CognitiveProfile p : CognitiveProfile.values()) {
-                assertThat(config.isEnabled(p)).isTrue();
-            }
-        }
-
-        @Test
-        @DisplayName("'CORE_ONLY' enables only core profiles")
-        void coreOnlyPreset() {
-            var config = CognitiveProfileConfig.fromConfigValue("CORE_ONLY");
-            assertThat(config.isEnabled(CognitiveProfile.BALANCED)).isTrue();
-            assertThat(config.isEnabled(CognitiveProfile.HYPERFOCUS)).isFalse();
-        }
-
-        @Test
-        @DisplayName("'WITH_NEURODIVERGENT' enables core + neuro")
-        void withNeurodivergentPreset() {
-            var config = CognitiveProfileConfig.fromConfigValue("WITH_NEURODIVERGENT");
-            assertThat(config.isEnabled(CognitiveProfile.HYPERFOCUS)).isTrue();
-            assertThat(config.isEnabled(CognitiveProfile.PARANOID_SENTINEL)).isFalse();
-        }
-
-        @Test
-        @DisplayName("CSV list parses individual profiles")
-        void csvList() {
-            var config = CognitiveProfileConfig.fromConfigValue("DEBUGGING, HYPERFOCUS, THE_EXECUTOR");
-            assertThat(config.isEnabled(CognitiveProfile.BALANCED)).isTrue(); // always
-            assertThat(config.isEnabled(CognitiveProfile.DEBUGGING)).isTrue();
-            assertThat(config.isEnabled(CognitiveProfile.HYPERFOCUS)).isTrue();
-            assertThat(config.isEnabled(CognitiveProfile.THE_EXECUTOR)).isTrue();
-            assertThat(config.isEnabled(CognitiveProfile.EXPLORING)).isFalse();
-        }
-
-        @Test
-        @DisplayName("null/blank defaults to ALL")
-        void nullDefaultsToAll() {
-            assertThat(CognitiveProfileConfig.fromConfigValue(null).enabledProfiles())
-                    .hasSize(CognitiveProfile.values().length);
-            assertThat(CognitiveProfileConfig.fromConfigValue("  ").enabledProfiles())
-                    .hasSize(CognitiveProfile.values().length);
-        }
-
-        @Test
-        @DisplayName("Invalid profile name throws with helpful message")
-        void invalidProfileThrows() {
-            org.assertj.core.api.Assertions.assertThatThrownBy(
-                    () -> CognitiveProfileConfig.fromConfigValue("DEBUGGING, INVALID_PROFILE"))
-                    .isInstanceOf(IllegalArgumentException.class)
-                    .hasMessageContaining("INVALID_PROFILE");
-        }
-
-        @Test
-        @DisplayName("Case-insensitive parsing")
-        void caseInsensitive() {
-            var config = CognitiveProfileConfig.fromConfigValue("debugging, Hyperfocus");
-            assertThat(config.isEnabled(CognitiveProfile.DEBUGGING)).isTrue();
-            assertThat(config.isEnabled(CognitiveProfile.HYPERFOCUS)).isTrue();
-        }
-    }
-
-    // ═══════════════════════════════════════════════════════════════
-    // SynapticHeaderConstants Zeigarnik Flag
-    // ═══════════════════════════════════════════════════════════════
-
-    @Nested
-    @DisplayName("SynapticHeader FLAG_RESOLVED")
-    class FlagResolved {
-
-        @Test
-        @DisplayName("FLAG_RESOLVED is bit 5 (0x20)")
-        void flagValue() {
-            assertThat(SynapticHeaderConstants.FLAG_RESOLVED).isEqualTo((byte) 0x20);
-        }
-
-        @Test
-        @DisplayName("New memories are not resolved by default")
-        void defaultNotResolved() {
-            byte flags = 0;
-            assertThat(SynapticHeaderConstants.isResolved(flags)).isFalse();
-        }
-
-        @Test
-        @DisplayName("Setting resolved flag is detectable")
-        void setResolved() {
-            byte flags = SynapticHeaderConstants.FLAG_RESOLVED;
-            assertThat(SynapticHeaderConstants.isResolved(flags)).isTrue();
-        }
-
-        @Test
-        @DisplayName("Resolved flag does not interfere with other flags")
-        void noInterference() {
-            byte flags = (byte) (SynapticHeaderConstants.FLAG_TOMBSTONE
-                    | SynapticHeaderConstants.FLAG_PINNED
-                    | SynapticHeaderConstants.FLAG_RESOLVED);
-            assertThat(SynapticHeaderConstants.isTombstoned(flags)).isTrue();
-            assertThat(SynapticHeaderConstants.isPinned(flags)).isTrue();
-            assertThat(SynapticHeaderConstants.isResolved(flags)).isTrue();
-        }
-    }
-
-    // ═══════════════════════════════════════════════════════════════
-    // Mock Embedding Provider (deterministic, normalized)
-    // ═══════════════════════════════════════════════════════════════
-
-    /**
-     * Deterministic mock that produces hash-based, L2-normalized vectors.
-     */
-    static class NormalizingMockProvider implements EmbeddingProvider {
-        private final int dims;
-
-        NormalizingMockProvider(int dims) { this.dims = dims; }
-
-        @Override
-        public EmbeddingResult embed(String text) {
-            Random rng = new Random(text.hashCode());
-            float[] vector = new float[dims];
-            for (int i = 0; i < dims; i++) {
-                vector[i] = (rng.nextFloat() - 0.5f) * 2.0f;
-            }
-            // L2 normalize
-            float norm = 0f;
-            for (float v : vector) norm += v * v;
-            norm = (float) Math.sqrt(norm);
-            if (norm > 0) {
-                for (int i = 0; i < dims; i++) vector[i] /= norm;
-            }
-            return new EmbeddingResult(vector, text.split("\\s+").length, "mock-" + dims + "d");
-        }
-
-        @Override public int dimensions() { return dims; }
-        @Override public String modelName() { return "mock-" + dims + "d"; }
-    }
-}
diff --git a/spector-memory/src/test/java/com/spectrayan/spector/memory/OllamaRealEmbeddingTest.java b/spector-memory/src/test/java/com/spectrayan/spector/memory/OllamaRealEmbeddingTest.java
deleted file mode 100644
index 7e967f2..0000000
--- a/spector-memory/src/test/java/com/spectrayan/spector/memory/OllamaRealEmbeddingTest.java
+++ /dev/null
@@ -1,447 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory;
-
-import com.spectrayan.spector.embed.EmbeddingProvider;
-import com.spectrayan.spector.embed.EmbeddingResult;
-import com.spectrayan.spector.embed.ollama.OllamaEmbeddingProvider;
-import com.spectrayan.spector.memory.cortex.MemorySource;
-
-import org.junit.jupiter.api.*;
-import org.junit.jupiter.api.condition.EnabledIfEnvironmentVariable;
-
-import static org.assertj.core.api.Assertions.*;
-
-import java.time.Duration;
-import java.util.List;
-import java.util.concurrent.TimeUnit;
-
-/**
- * End-to-end integration test using real Ollama embeddings (qwen3).
- *
- * <h3>Prerequisites</h3>
- * <ul>
- *   <li>Ollama running on {@code localhost:11434}</li>
- *   <li>Model pulled: {@code ollama pull qwen3}</li>
- *   <li>Set env var: {@code OLLAMA_LIVE=true}</li>
- * </ul>
- *
- * <h3>What This Tests</h3>
- * <p>Uses real 2048-dim (or model-default-dim) embeddings from qwen3 to verify
- * semantic similarity ranking, cross-tier recall, and full pipeline
- * performance with production-grade vectors.</p>
- *
- * <p>Run manually with:</p>
- * <pre>
- *   set OLLAMA_LIVE=true
- *   mvn test -pl spector-memory -Dtest=OllamaRealEmbeddingTest -am
- * </pre>
- */
-@EnabledIfEnvironmentVariable(named = "OLLAMA_LIVE", matches = "true")
-@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
-@DisplayName("Ollama Real Embedding E2E Tests (qwen3)")
-class OllamaRealEmbeddingTest {
-
-    private static final String MODEL = "qwen3-embedding";
-    private static OllamaEmbeddingProvider embeddingProvider;
-    private static int detectedDimensions;
-
-    private SpectorMemory memory;
-
-    @BeforeAll
-    static void initOllama() {
-        embeddingProvider = OllamaEmbeddingProvider.create(MODEL);
-        // Probe dimensions
-        EmbeddingResult probe = embeddingProvider.embed("dimension probe");
-        detectedDimensions = probe.dimensions();
-        System.out.printf("Ollama %s: detected %d dimensions%n", MODEL, detectedDimensions);
-    }
-
-    @BeforeEach
-    void setUp() {
-        memory = DefaultSpectorMemory.builder()
-                .dimensions(detectedDimensions)
-                .embeddingProvider(embeddingProvider)
-                .persistenceMode(MemoryPersistenceMode.IN_MEMORY)
-                .workingCapacity(50)
-                .episodicPartitionCapacity(500)
-                .semanticCapacity(200)
-                .proceduralCapacity(100)
-                .build();
-    }
-
-    @AfterEach
-    void tearDown() {
-        if (memory != null) memory.close();
-    }
-
-    // ══════════════════════════════════════════════════════════════
-    // Semantic Similarity — Real Embeddings
-    // ══════════════════════════════════════════════════════════════
-
-    @Test
-    @Order(1)
-    @DisplayName("Semantic recall: 'dark mode' query ranks 'user prefers dark theme' highest")
-    void semanticSimilarity_darkMode() throws Exception {
-        // Ingest diverse memories
-        memory.remember("pref-dark", "The user strongly prefers dark mode for all their IDE editors and applications.",
-                MemoryType.EPISODIC, MemorySource.USER_STATED, "ui", "preferences")
-                .get(30, TimeUnit.SECONDS);
-        memory.remember("pref-java", "The user prefers Java over Python for backend development.",
-                MemoryType.EPISODIC, MemorySource.USER_STATED, "language", "preferences")
-                .get(30, TimeUnit.SECONDS);
-        memory.remember("error-db", "Encountered a database connection timeout on the users table during migration.",
-                MemoryType.EPISODIC, MemorySource.OBSERVED, "error", "database")
-                .get(30, TimeUnit.SECONDS);
-        memory.remember("deploy-v2", "Successfully deployed version 2.1 to the staging environment.",
-                MemoryType.EPISODIC, MemorySource.OBSERVED, "deployment")
-                .get(30, TimeUnit.SECONDS);
-        memory.remember("pref-light", "The user explicitly rejected the light theme during onboarding.",
-                MemoryType.EPISODIC, MemorySource.USER_STATED, "ui", "preferences")
-                .get(30, TimeUnit.SECONDS);
-
-        // Query: "dark mode"
-        List<CognitiveResult> results = memory.recall("dark mode settings",
-                RecallOptions.builder().topK(5).build());
-
-        System.out.println("=== Semantic Recall: 'dark mode settings' ===");
-        for (int i = 0; i < results.size(); i++) {
-            CognitiveResult r = results.get(i);
-            System.out.printf("  #%d: score=%.4f type=%s text='%s'%n",
-                    i + 1, r.score(), r.memoryType(), truncate(r.text(), 60));
-        }
-
-        assertThat(results).isNotEmpty();
-        // At least one result should mention dark/light/theme
-        boolean foundRelevant = results.stream()
-                .anyMatch(r -> r.text().contains("dark") || r.text().contains("light") || r.text().contains("theme"));
-        assertThat(foundRelevant).as("At least one result should be about dark/light theme").isTrue();
-    }
-
-    @Test
-    @Order(2)
-    @DisplayName("Semantic recall: 'database error' query ranks DB-related highest")
-    void semanticSimilarity_databaseError() throws Exception {
-        memory.remember("err-db", "Database connection pool exhausted — 50 active, 0 idle connections.",
-                MemoryType.EPISODIC, MemorySource.OBSERVED, "error", "database")
-                .get(30, TimeUnit.SECONDS);
-        memory.remember("err-npe", "NullPointerException in UserService.getPreferences at line 42.",
-                MemoryType.EPISODIC, MemorySource.OBSERVED, "error", "java")
-                .get(30, TimeUnit.SECONDS);
-        memory.remember("fact-pg", "PostgreSQL supports JSONB columns for semi-structured data.",
-                MemoryType.SEMANTIC, MemorySource.OBSERVED, "database", "postgresql")
-                .get(30, TimeUnit.SECONDS);
-        memory.remember("rule-retry", "Always implement exponential backoff for database retries.",
-                MemoryType.PROCEDURAL, MemorySource.PROCEDURAL, "database", "retry")
-                .get(30, TimeUnit.SECONDS);
-
-        List<CognitiveResult> results = memory.recall("database connection error",
-                RecallOptions.builder().topK(5).build());
-
-        System.out.println("\n=== Semantic Recall: 'database connection error' ===");
-        for (int i = 0; i < results.size(); i++) {
-            CognitiveResult r = results.get(i);
-            System.out.printf("  #%d: score=%.4f type=%s text='%s'%n",
-                    i + 1, r.score(), r.memoryType(), truncate(r.text(), 60));
-        }
-
-        assertThat(results).isNotEmpty();
-        // At least one result should mention connection/database
-        boolean foundRelevant = results.stream()
-                .anyMatch(r -> r.text().toLowerCase().contains("connection") 
-                        || r.text().toLowerCase().contains("database"));
-        assertThat(foundRelevant).as("At least one result should be about database connections").isTrue();
-    }
-
-    // ══════════════════════════════════════════════════════════════
-    // Cross-Tier Recall — All 4 Tiers
-    // ══════════════════════════════════════════════════════════════
-
-    @Test
-    @Order(3)
-    @DisplayName("Cross-tier recall: results from Working, Episodic, Semantic, Procedural")
-    void crossTierRecall() throws Exception {
-        memory.remember("w-1", "Currently analyzing the Spring Boot configuration issue.",
-                MemoryType.WORKING, "spring", "debugging").get(30, TimeUnit.SECONDS);
-        memory.remember("e-1", "Yesterday the Spring app failed to start because of circular dependencies.",
-                MemoryType.EPISODIC, MemorySource.OBSERVED, "spring", "error").get(30, TimeUnit.SECONDS);
-        memory.remember("s-1", "Spring Boot auto-configuration resolves beans using conditional annotations.",
-                MemoryType.SEMANTIC, MemorySource.OBSERVED, "spring", "framework").get(30, TimeUnit.SECONDS);
-        memory.remember("p-1", "When troubleshooting Spring, always check @ConditionalOn annotations first.",
-                MemoryType.PROCEDURAL, MemorySource.PROCEDURAL, "spring", "debugging").get(30, TimeUnit.SECONDS);
-
-        List<CognitiveResult> results = memory.recall("Spring Boot configuration problem",
-                RecallOptions.builder().topK(10).build());
-
-        System.out.println("\n=== Cross-Tier Recall: 'Spring Boot configuration problem' ===");
-        for (int i = 0; i < results.size(); i++) {
-            CognitiveResult r = results.get(i);
-            System.out.printf("  #%d: score=%.4f type=%-12s text='%s'%n",
-                    i + 1, r.score(), r.memoryType(), truncate(r.text(), 60));
-        }
-
-        assertThat(results).isNotEmpty();
-        assertThat(results.size()).isGreaterThanOrEqualTo(3);
-
-        // Verify we got results from multiple tiers
-        var tiers = results.stream().map(CognitiveResult::memoryType).distinct().toList();
-        System.out.printf("  Tiers represented: %s%n", tiers);
-        assertThat(tiers.size()).as("At least 3 tiers in results").isGreaterThanOrEqualTo(3);
-    }
-
-    // ══════════════════════════════════════════════════════════════
-    // Performance with Real Embeddings
-    // ══════════════════════════════════════════════════════════════
-
-    @Test
-    @Order(4)
-    @DisplayName("Performance: 50 ingestions + 20 recalls with real embeddings")
-    void realEmbeddingPerformance() throws Exception {
-        String[] topics = {
-                "Java performance optimization techniques for high-throughput systems",
-                "Spring Boot REST API with PostgreSQL and connection pooling",
-                "Kubernetes deployment with horizontal pod autoscaling and health checks",
-                "React frontend state management using Redux and TypeScript",
-                "Machine learning model training with PyTorch and GPU acceleration",
-                "Database schema migration using Flyway with zero-downtime strategies",
-                "CI/CD pipeline with GitHub Actions and Docker container builds",
-                "Microservices architecture with gRPC and Protocol Buffers",
-                "OAuth2 authentication flow with JWT token refresh logic",
-                "Elasticsearch full-text search with custom analyzers and synonyms"
-        };
-
-        // Ingest 50 memories
-        System.out.println("\n=== Real Embedding Performance ===");
-        long ingestStart = System.nanoTime();
-        for (int i = 0; i < 50; i++) {
-            String text = topics[i % topics.length] + " — instance " + i;
-            MemoryType type = switch (i % 4) {
-                case 0 -> MemoryType.WORKING;
-                case 1 -> MemoryType.EPISODIC;
-                case 2 -> MemoryType.SEMANTIC;
-                default -> MemoryType.PROCEDURAL;
-            };
-            memory.remember("real-" + i, text, type,
-                    MemorySource.OBSERVED, "topic-" + (i % 10))
-                    .get(30, TimeUnit.SECONDS);
-        }
-        long ingestElapsed = System.nanoTime() - ingestStart;
-        System.out.printf("  Ingest: 50 memories in %.1f s (%.0f ms/memory, includes Ollama API)%n",
-                ingestElapsed / 1e9, ingestElapsed / 1e6 / 50);
-
-        assertThat(memory.totalMemories()).isEqualTo(50);
-
-        // 20 diverse recall queries
-        String[] queries = {
-                "Java performance", "database connection pool", "Kubernetes scaling",
-                "React state management", "machine learning GPU", "schema migration",
-                "CI/CD Docker", "microservices gRPC", "OAuth JWT", "Elasticsearch search",
-                "Spring Boot REST", "horizontal autoscaling", "PyTorch training",
-                "GitHub Actions pipeline", "Protocol Buffers serialization",
-                "PostgreSQL connection", "Redux TypeScript", "health check probe",
-                "Flyway zero downtime", "container orchestration"
-        };
-
-        long recallStart = System.nanoTime();
-        int totalResults = 0;
-        for (String query : queries) {
-            List<CognitiveResult> results = memory.recall(query,
-                    RecallOptions.builder().topK(5).build());
-            totalResults += results.size();
-        }
-        long recallElapsed = System.nanoTime() - recallStart;
-
-        System.out.printf("  Recall: 20 queries in %.1f s (%.0f ms/query, includes Ollama API)%n",
-                recallElapsed / 1e9, recallElapsed / 1e6 / 20);
-        System.out.printf("  Total results returned: %d%n", totalResults);
-
-        assertThat(totalResults).isGreaterThan(0);
-    }
-
-    // ══════════════════════════════════════════════════════════════
-    // Suppression + Habituation with Real Vectors
-    // ══════════════════════════════════════════════════════════════
-
-    @Test
-    @Order(5)
-    @DisplayName("Suppression: suppressed memory excluded from recall")
-    void suppression_excludesFromRecall() throws Exception {
-        memory.remember("mem-java", "Java has garbage collection for automatic memory management.",
-                MemoryType.SEMANTIC, MemorySource.OBSERVED, "java").get(30, TimeUnit.SECONDS);
-        memory.remember("mem-rust", "Rust uses ownership system instead of garbage collection.",
-                MemoryType.SEMANTIC, MemorySource.OBSERVED, "rust").get(30, TimeUnit.SECONDS);
-
-        // Suppress Java memory
-        memory.suppress("mem-java", "Wrong context");
-
-        List<CognitiveResult> results = memory.recall("garbage collection memory management",
-                RecallOptions.builder().topK(5).build());
-
-        System.out.println("\n=== Suppression Test ===");
-        for (CognitiveResult r : results) {
-            System.out.printf("  score=%.4f id=%s text='%s'%n", r.score(), r.id(), truncate(r.text(), 50));
-        }
-
-        // Suppressed memory should NOT appear
-        boolean javaFound = results.stream().anyMatch(r -> "mem-java".equals(r.id()));
-        assertThat(javaFound).as("Suppressed memory should not appear").isFalse();
-    }
-
-    @Test
-    @Order(6)
-    @DisplayName("Habituation: repeated recall penalizes score")
-    void habituation_penalizesRepeatedRecall() throws Exception {
-        memory.remember("hab-1", "The deployment pipeline uses blue-green strategy for zero downtime.",
-                MemoryType.EPISODIC, MemorySource.OBSERVED, "deployment").get(30, TimeUnit.SECONDS);
-
-        // First recall
-        List<CognitiveResult> first = memory.recall("deployment strategy",
-                RecallOptions.builder().topK(5).build());
-        float firstScore = first.isEmpty() ? 0 : first.getFirst().score();
-
-        // Second recall (same query)
-        List<CognitiveResult> second = memory.recall("deployment strategy",
-                RecallOptions.builder().topK(5).build());
-        float secondScore = second.isEmpty() ? 0 : second.getFirst().score();
-
-        System.out.printf("%nHabituation: first=%.4f, second=%.4f (penalty applied=%b)%n",
-                firstScore, secondScore, secondScore < firstScore);
-
-        if (firstScore > 0 && secondScore > 0) {
-            assertThat(secondScore).as("Second recall score should be ≤ first").isLessThanOrEqualTo(firstScore);
-        }
-    }
-
-    // ══════════════════════════════════════════════════════════════
-    // Memory Type-Filtered Recall
-    // ══════════════════════════════════════════════════════════════
-
-    @Test
-    @Order(7)
-    @DisplayName("Type-filtered recall: only returns memories from specified tiers")
-    void typeFilteredRecall() throws Exception {
-        memory.remember("e-fact", "Python 3.12 introduced faster pattern matching.",
-                MemoryType.EPISODIC, MemorySource.OBSERVED, "python").get(30, TimeUnit.SECONDS);
-        memory.remember("s-fact", "Python uses indentation for code block scoping.",
-                MemoryType.SEMANTIC, MemorySource.OBSERVED, "python").get(30, TimeUnit.SECONDS);
-        memory.remember("p-fact", "Always use virtual environments for Python projects.",
-                MemoryType.PROCEDURAL, MemorySource.PROCEDURAL, "python").get(30, TimeUnit.SECONDS);
-
-        // Only semantic
-        List<CognitiveResult> semanticOnly = memory.recall("Python programming",
-                RecallOptions.builder().topK(5).memoryTypes(MemoryType.SEMANTIC).build());
-
-        System.out.println("\n=== Type-Filtered Recall (SEMANTIC only) ===");
-        for (CognitiveResult r : semanticOnly) {
-            System.out.printf("  type=%s text='%s'%n", r.memoryType(), truncate(r.text(), 50));
-        }
-
-        if (!semanticOnly.isEmpty()) {
-            assertThat(semanticOnly).allMatch(r -> r.memoryType() == MemoryType.SEMANTIC);
-        }
-    }
-
-    // ══════════════════════════════════════════════════════════════
-    // Forget + WAL
-    // ══════════════════════════════════════════════════════════════
-
-    @Test
-    @Order(8)
-    @DisplayName("Forget: tombstoned memory excluded from recall")
-    void forget_tombstonedExcluded() throws Exception {
-        memory.remember("forget-me", "This memory should be forgotten completely.",
-                MemoryType.EPISODIC, MemorySource.OBSERVED, "temp").get(30, TimeUnit.SECONDS);
-        memory.remember("keep-me", "This memory should persist across operations.",
-                MemoryType.EPISODIC, MemorySource.OBSERVED, "persistent").get(30, TimeUnit.SECONDS);
-
-        memory.forget("forget-me");
-
-        List<CognitiveResult> results = memory.recall("forgotten memory",
-                RecallOptions.builder().topK(10).build());
-
-        boolean forgottenFound = results.stream().anyMatch(r -> "forget-me".equals(r.id()));
-        assertThat(forgottenFound).as("Forgotten memory should not appear").isFalse();
-    }
-
-    // ══════════════════════════════════════════════════════════════
-    // Batch Embedding Performance
-    // ══════════════════════════════════════════════════════════════
-
-    @Test
-    @Order(9)
-    @DisplayName("Batch embedding: Ollama batch API for 20 texts")
-    void batchEmbeddingPerformance() {
-        List<String> texts = new java.util.ArrayList<>();
-        for (int i = 0; i < 20; i++) {
-            texts.add("Batch embedding test text number " + i + " about software engineering");
-        }
-
-        long start = System.nanoTime();
-        List<EmbeddingResult> results = embeddingProvider.embedBatch(texts);
-        long elapsed = System.nanoTime() - start;
-
-        System.out.printf("%nBatch embedding: 20 texts in %.0f ms (%.0f ms/text, dims=%d)%n",
-                elapsed / 1e6, elapsed / 1e6 / 20, results.getFirst().dimensions());
-
-        assertThat(results).hasSize(20);
-        assertThat(results.getFirst().dimensions()).isEqualTo(detectedDimensions);
-    }
-
-    // ══════════════════════════════════════════════════════════════
-    // Recall Quality — Semantic Relevance Ordering
-    // ══════════════════════════════════════════════════════════════
-
-    @Test
-    @Order(10)
-    @DisplayName("Recall quality: highly relevant result scores higher than tangentially related")
-    void recallQuality_relevanceOrdering() throws Exception {
-        // Use EPISODIC tier so full CognitiveRecord (with quantized vector) is used for similarity scoring
-        memory.remember("gc-direct", "The Java G1 garbage collector divides the heap into regions for concurrent collection.",
-                MemoryType.EPISODIC, MemorySource.OBSERVED, "java", "gc").get(30, TimeUnit.SECONDS);
-        // Somewhat related
-        memory.remember("gc-related", "Memory allocation in Java uses the TLAB (Thread-Local Allocation Buffer).",
-                MemoryType.EPISODIC, MemorySource.OBSERVED, "java", "memory").get(30, TimeUnit.SECONDS);
-        // Unrelated
-        memory.remember("gc-unrelated", "Kubernetes uses etcd for distributed consensus on cluster state.",
-                MemoryType.EPISODIC, MemorySource.OBSERVED, "kubernetes", "etcd").get(30, TimeUnit.SECONDS);
-
-        List<CognitiveResult> results = memory.recall("Java G1 garbage collection pause times",
-                RecallOptions.builder().topK(5).build());
-
-        System.out.println("\n=== Recall Quality: 'Java G1 garbage collection pause times' ===");
-        for (int i = 0; i < results.size(); i++) {
-            CognitiveResult r = results.get(i);
-            System.out.printf("  #%d: score=%.4f id=%s text='%s'%n",
-                    i + 1, r.score(), r.id(), truncate(r.text(), 60));
-        }
-
-        assertThat(results).isNotEmpty();
-        // G1 GC memory should score highest
-        if (results.size() >= 2) {
-            CognitiveResult direct = results.stream()
-                    .filter(r -> "gc-direct".equals(r.id())).findFirst().orElse(null);
-            CognitiveResult unrelated = results.stream()
-                    .filter(r -> "gc-unrelated".equals(r.id())).findFirst().orElse(null);
-            if (direct != null && unrelated != null) {
-                assertThat(direct.score()).as("Direct match should score >= unrelated")
-                        .isGreaterThanOrEqualTo(unrelated.score());
-            }
-        }
-    }
-
-    // ── Helper ──
-
-    private static String truncate(String s, int maxLen) {
-        return s.length() <= maxLen ? s : s.substring(0, maxLen) + "...";
-    }
-}
diff --git a/spector-memory/src/test/java/com/spectrayan/spector/memory/PerformanceBenchmarkTest.java b/spector-memory/src/test/java/com/spectrayan/spector/memory/PerformanceBenchmarkTest.java
deleted file mode 100644
index 7610f6a..0000000
--- a/spector-memory/src/test/java/com/spectrayan/spector/memory/PerformanceBenchmarkTest.java
+++ /dev/null
@@ -1,389 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory;
-
-import com.spectrayan.spector.memory.cortex.MemorySource;
-import com.spectrayan.spector.memory.index.MemoryIndex;
-import com.spectrayan.spector.memory.index.MemoryIndex.MemoryLocation;
-import com.spectrayan.spector.memory.synapse.CognitiveRecordLayout;
-import com.spectrayan.spector.memory.synapse.CognitiveRecordLayout.CognitiveHeader;
-import com.spectrayan.spector.memory.synapse.CognitiveScorer;
-import com.spectrayan.spector.memory.synapse.CognitiveScorer.ScoredRecord;
-import com.spectrayan.spector.memory.cortex.WorkingMemoryStore;
-import com.spectrayan.spector.memory.cortex.TierRouter;
-import com.spectrayan.spector.memory.habituation.HabituationPenalty;
-import com.spectrayan.spector.core.quantization.ScalarQuantizer;
-import com.spectrayan.spector.embed.EmbeddingProvider;
-import com.spectrayan.spector.embed.EmbeddingResult;
-
-import org.junit.jupiter.api.*;
-import static org.assertj.core.api.Assertions.*;
-
-import java.lang.foreign.Arena;
-import java.lang.foreign.MemorySegment;
-import java.time.Duration;
-import java.util.*;
-import java.util.concurrent.TimeUnit;
-
-/**
- * Performance benchmark tests verifying the optimizations P1–P12.
- *
- * <p>Each test measures wall-clock time to validate that optimizations
- * achieve expected performance characteristics. Uses deterministic mock
- * embeddings for reproducibility.</p>
- */
-@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
-class PerformanceBenchmarkTest {
-
-    private static final int DIMS = 128;
-    private static final int LARGE_COUNT = 50_000;
-
-    // ══════════════════════════════════════════════════════════════
-    // P1: O(1) Reverse Index vs O(n) scan
-    // ══════════════════════════════════════════════════════════════
-
-    @Test
-    @Order(1)
-    @DisplayName("P1: MemoryIndex.findIdByOffset — O(1) reverse lookup at 50K entries")
-    void p1_reverseIndexIsConstantTime() {
-        MemoryIndex index = new MemoryIndex();
-
-        // Populate 50K entries
-        for (int i = 0; i < LARGE_COUNT; i++) {
-            String id = "mem-" + i;
-            long offset = (long) i * 64;
-            index.register(id,
-                    new MemoryLocation(MemoryType.EPISODIC, offset, 0),
-                    "text-" + i, MemorySource.OBSERVED, new String[]{"tag-" + (i % 10)});
-        }
-
-        // Warm up
-        for (int i = 0; i < 1000; i++) {
-            index.findIdByOffset(MemoryType.EPISODIC, (long) (i * 2) * 64);
-        }
-
-        // Benchmark: 10K lookups at various offsets
-        long[] offsets = new long[10_000];
-        Random rng = new Random(42);
-        for (int i = 0; i < offsets.length; i++) {
-            offsets[i] = (long) rng.nextInt(LARGE_COUNT) * 64;
-        }
-
-        long start = System.nanoTime();
-        int found = 0;
-        for (long offset : offsets) {
-            if (index.findIdByOffset(MemoryType.EPISODIC, offset) != null) found++;
-        }
-        long elapsed = System.nanoTime() - start;
-
-        double avgNs = (double) elapsed / offsets.length;
-        System.out.printf("P1: 10K lookups in %,d µs (avg %.0f ns/lookup, found=%d)%n",
-                elapsed / 1000, avgNs, found);
-
-        // O(1) should be < 1µs per lookup (vs ~50µs for O(n) at 50K)
-        assertThat(avgNs).as("O(1) reverse lookup should be under 1µs").isLessThan(1_000);
-        assertThat(found).isEqualTo(10_000);
-    }
-
-    // ══════════════════════════════════════════════════════════════
-    // P8: ScoredRecord carries CognitiveHeader (no double read)
-    // ══════════════════════════════════════════════════════════════
-
-    @Test
-    @Order(2)
-    @DisplayName("P8: ScoredRecord carries CognitiveHeader — no re-read needed")
-    void p8_scoredRecordContainsHeader() {
-        CognitiveHeader header = new CognitiveHeader(
-                System.currentTimeMillis(), 0x1234L, 1.0f, 0.8f,
-                5, (short) 42, (byte) 10, (byte) 0);
-
-        ScoredRecord sr = new ScoredRecord(1024L, 0.95f, 7, header);
-
-        assertThat(sr.header()).isNotNull();
-        assertThat(sr.header().importance()).isEqualTo(0.8f);
-        assertThat(sr.header().recallCount()).isEqualTo(5);
-        assertThat(sr.header().valence()).isEqualTo((byte) 10);
-        assertThat(sr.header().centroidId()).isEqualTo((short) 42);
-    }
-
-    // ══════════════════════════════════════════════════════════════
-    // P3: SIMD Euclidean — benchmarks quantized distance
-    // ══════════════════════════════════════════════════════════════
-
-    @Test
-    @Order(3)
-    @DisplayName("P3: SIMD Euclidean distance — 768-dim × 10K vectors under 150ms")
-    void p3_simdEuclideanDistance768Dim() {
-        int dims = 768;
-        int count = 10_000;
-
-        // Build calibration arrays
-        float[] mins = new float[dims];
-        float[] scales = new float[dims];
-        Arrays.fill(mins, -1.0f);
-        Arrays.fill(scales, 1.0f / 127.5f);
-
-        // Build query vector
-        Random rng = new Random(42);
-        float[] query = new float[dims];
-        for (int i = 0; i < dims; i++) query[i] = rng.nextFloat() * 2 - 1;
-
-        // Build quantized vectors in off-heap segment
-        try (Arena arena = Arena.ofConfined()) {
-            MemorySegment segment = arena.allocate((long) count * dims, 32);
-            for (int v = 0; v < count; v++) {
-                for (int d = 0; d < dims; d++) {
-                    segment.set(java.lang.foreign.ValueLayout.JAVA_BYTE,
-                            (long) v * dims + d, (byte) rng.nextInt(256));
-                }
-            }
-
-            // Warm up (15,000 iterations to ensure JVM JIT C2 vectorization compilation)
-            for (int i = 0; i < 15_000; i++) {
-                com.spectrayan.spector.core.similarity.SimilarityFunction.EUCLIDEAN
-                        .computeQuantizedFromSegment(query, segment, 0, mins, scales, dims);
-            }
-
-            // Benchmark: 10K distance computations
-            long start = System.nanoTime();
-            float totalDist = 0;
-            for (int i = 0; i < count; i++) {
-                totalDist += com.spectrayan.spector.core.similarity.SimilarityFunction.EUCLIDEAN
-                        .computeQuantizedFromSegment(query, segment, (long) i * dims, mins, scales, dims);
-            }
-            long elapsed = System.nanoTime() - start;
-
-            double avgUs = (double) elapsed / count / 1000;
-            System.out.printf("P3: 10K × 768-dim L2 in %,d ms (avg %.1f µs/vector, checksum=%.2f)%n",
-                    elapsed / 1_000_000, avgUs, totalDist);
-
-            // 10K × 768-dim should complete in < 150ms with SIMD (with headroom for slower/virtualized test runners)
-            assertThat(elapsed / 1_000_000).as("SIMD L2 10K×768d should be under 150ms").isLessThan(150);
-        }
-    }
-
-    // ══════════════════════════════════════════════════════════════
-    // P7: Batch habituation penalty
-    // ══════════════════════════════════════════════════════════════
-
-    @Test
-    @Order(4)
-    @DisplayName("P7: Batch habituation penalty — 1K IDs under 1ms")
-    void p7_batchHabituationPenalty() {
-        HabituationPenalty penalty = new HabituationPenalty();
-        String[] ids = new String[1000];
-        for (int i = 0; i < ids.length; i++) ids[i] = "mem-" + i;
-
-        // Warm up
-        penalty.recordAndComputeBatch(ids);
-        penalty.clear();
-
-        long start = System.nanoTime();
-        float[] results = penalty.recordAndComputeBatch(ids);
-        long elapsed = System.nanoTime() - start;
-
-        System.out.printf("P7: Batch 1K penalties in %,d µs%n", elapsed / 1000);
-
-        assertThat(results).hasSize(1000);
-        assertThat(results[0]).isEqualTo(1.0f); // first time = no penalty
-        assertThat(elapsed / 1000).as("Batch 1K should be under 1ms").isLessThan(1000);
-    }
-
-    // ══════════════════════════════════════════════════════════════
-    // P12: TierRouter.totalCount — direct sum
-    // ══════════════════════════════════════════════════════════════
-
-    @Test
-    @Order(5)
-    @DisplayName("P12: TierRouter.totalCount — 100K calls under 10ms (no Stream)")
-    void p12_totalCountDirectSum() {
-        int quantizedVecBytes = 32;
-        var working = new WorkingMemoryStore(quantizedVecBytes, 10);
-        var episodic = new com.spectrayan.spector.memory.cortex.EpisodicMemoryStore(
-                java.nio.file.Path.of(System.getProperty("java.io.tmpdir"),
-                        "perf-test-p12-" + System.nanoTime()),
-                quantizedVecBytes, 100);
-        var semantic = new com.spectrayan.spector.memory.cortex.SemanticMemoryStore(quantizedVecBytes, 10);
-        var procedural = new com.spectrayan.spector.memory.cortex.ProceduralMemoryStore(quantizedVecBytes, 10);
-        var router = new TierRouter(working, episodic, semantic, procedural);
-
-        try {
-            // Warm up
-            for (int i = 0; i < 1000; i++) router.totalCount();
-
-            long start = System.nanoTime();
-            int sum = 0;
-            for (int i = 0; i < 100_000; i++) {
-                sum += router.totalCount();
-            }
-            long elapsed = System.nanoTime() - start;
-
-            System.out.printf("P12: 100K totalCount() in %,d µs (sum=%d)%n",
-                    elapsed / 1000, sum);
-
-            assertThat(elapsed / 1_000_000).as("100K totalCount should be under 50ms").isLessThan(50);
-        } finally {
-            router.close();
-        }
-    }
-
-    // ══════════════════════════════════════════════════════════════
-    // CognitiveScorer — 6-phase pipeline timing at scale
-    // ══════════════════════════════════════════════════════════════
-
-    @Test
-    @Order(6)
-    @DisplayName("CognitiveScorer: 10K records × 128-dim — full 6-phase scoring under 20ms")
-    void cognitiveScorer_fullPipelineTiming() {
-        int dims = DIMS;
-        int count = 10_000;
-        CognitiveRecordLayout layout = new CognitiveRecordLayout(dims);
-        int stride = layout.stride();
-
-        // Build calibration
-        float[] mins = new float[dims];
-        float[] scales = new float[dims];
-        Arrays.fill(mins, -1.0f);
-        Arrays.fill(scales, 1.0f / 127.5f);
-
-        // Build query
-        Random rng = new Random(42);
-        float[] query = new float[dims];
-        for (int i = 0; i < dims; i++) query[i] = rng.nextFloat() * 2 - 1;
-
-        // Build segment with records
-        try (Arena arena = Arena.ofConfined()) {
-            long totalBytes = (long) count * stride;
-            MemorySegment seg = arena.allocate(totalBytes, 32);
-
-            for (int i = 0; i < count; i++) {
-                long offset = (long) i * stride;
-                CognitiveHeader header = CognitiveHeader.create(
-                        System.currentTimeMillis() - rng.nextInt(86_400_000),
-                        rng.nextLong(), 1.0f,
-                        0.3f + rng.nextFloat() * 0.7f,
-                        (short) rng.nextInt(100), MemoryType.EPISODIC);
-                layout.writeHeader(seg, offset, header);
-
-                // Write random quantized vector
-                for (int d = 0; d < dims; d++) {
-                    seg.set(java.lang.foreign.ValueLayout.JAVA_BYTE,
-                            layout.vectorOffset(offset) + d, (byte) rng.nextInt(256));
-                }
-            }
-
-            RecallOptions opts = RecallOptions.builder().topK(10).build();
-
-            // Warm up
-            for (int i = 0; i < 5; i++) {
-                CognitiveScorer.score(seg, count, layout, query, opts,
-                        System.currentTimeMillis(), 0L, mins, scales);
-            }
-
-            // Benchmark
-            long start = System.nanoTime();
-            List<ScoredRecord> results = CognitiveScorer.score(
-                    seg, count, layout, query, opts,
-                    System.currentTimeMillis(), 0L, mins, scales);
-            long elapsed = System.nanoTime() - start;
-
-            System.out.printf("CognitiveScorer: %d records × %d-dim in %,d µs → %d results%n",
-                    count, dims, elapsed / 1000, results.size());
-
-            assertThat(results).hasSize(10);
-            assertThat(results.getFirst().header()).isNotNull(); // P8: header present
-            assertThat(elapsed / 1_000_000).as("10K × 128d scoring < 20ms").isLessThan(20);
-        }
-    }
-
-    // ══════════════════════════════════════════════════════════════
-    // Full SpectorMemory ingest + recall throughput
-    // ══════════════════════════════════════════════════════════════
-
-    @Test
-    @Order(7)
-    @DisplayName("SpectorMemory: 1000 ingestions + 100 recalls in under 2 seconds")
-    void fullPipelineThroughput() throws Exception {
-        int dims = 64;
-        MockEmbeddingProvider embedder = new MockEmbeddingProvider(dims);
-
-        try (SpectorMemory memory = DefaultSpectorMemory.builder()
-                .dimensions(dims)
-                .embeddingProvider(embedder)
-                .persistenceMode(MemoryPersistenceMode.IN_MEMORY)
-                .workingCapacity(50)
-                .episodicPartitionCapacity(2000)
-                .semanticCapacity(500)
-                .proceduralCapacity(100)
-                .build()) {
-
-            // Ingest 1000 memories
-            long ingestStart = System.nanoTime();
-            for (int i = 0; i < 1000; i++) {
-                memory.remember("mem-" + i, "Memory content about topic " + (i % 50) + " with detail " + i,
-                        MemoryType.EPISODIC, MemorySource.OBSERVED,
-                        "tag-" + (i % 10), "cat-" + (i % 5)).get(5, TimeUnit.SECONDS);
-            }
-            long ingestElapsed = System.nanoTime() - ingestStart;
-
-            assertThat(memory.totalMemories()).isGreaterThanOrEqualTo(900); // dedup may reduce count
-
-            // Recall 100 times
-            long recallStart = System.nanoTime();
-            int totalResults = 0;
-            for (int i = 0; i < 100; i++) {
-                List<CognitiveResult> results = memory.recall("topic " + (i % 50),
-                        RecallOptions.builder().topK(5).build());
-                totalResults += results.size();
-            }
-            long recallElapsed = System.nanoTime() - recallStart;
-
-            double ingestMs = ingestElapsed / 1_000_000.0;
-            double recallMs = recallElapsed / 1_000_000.0;
-            double avgRecallMs = recallMs / 100;
-
-            System.out.printf("""
-                    Full Pipeline Benchmark (64-dim mock embeddings):
-                      Ingest: 1000 memories in %.0f ms (%.1f ms/memory)
-                      Recall: 100 queries in %.0f ms (%.2f ms/query, %d total results)
-                    """, ingestMs, ingestMs / 1000, recallMs, avgRecallMs, totalResults);
-
-            assertThat(totalResults).isGreaterThan(0);
-            assertThat(avgRecallMs).as("Avg recall < 50ms per query").isLessThan(50.0);
-        }
-    }
-
-    // ── Mock Provider ──
-
-    static class MockEmbeddingProvider implements EmbeddingProvider {
-        private final int dims;
-        MockEmbeddingProvider(int dims) { this.dims = dims; }
-
-        @Override
-        public EmbeddingResult embed(String text) {
-            Random rng = new Random(text.hashCode());
-            float[] vector = new float[dims];
-            float norm = 0;
-            for (int i = 0; i < dims; i++) {
-                vector[i] = (rng.nextFloat() - 0.5f) * 2.0f;
-                norm += vector[i] * vector[i];
-            }
-            norm = (float) Math.sqrt(norm);
-            if (norm > 0) for (int i = 0; i < dims; i++) vector[i] /= norm;
-            return new EmbeddingResult(vector, text.split("\\s+").length, "mock");
-        }
-
-        @Override public int dimensions() { return dims; }
-        @Override public String modelName() { return "mock-" + dims + "d"; }
-    }
-}
diff --git a/spector-memory/src/test/java/com/spectrayan/spector/memory/SpectorMemoryIntegrationTest.java b/spector-memory/src/test/java/com/spectrayan/spector/memory/SpectorMemoryIntegrationTest.java
deleted file mode 100644
index c1f8101..0000000
--- a/spector-memory/src/test/java/com/spectrayan/spector/memory/SpectorMemoryIntegrationTest.java
+++ /dev/null
@@ -1,299 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory;
-
-import com.spectrayan.spector.memory.amygdala.Valence;
-import com.spectrayan.spector.memory.cortex.MemorySource;
-import com.spectrayan.spector.memory.metamemory.MemoryInsight;
-import com.spectrayan.spector.embed.EmbeddingProvider;
-import com.spectrayan.spector.embed.EmbeddingResult;
-import org.junit.jupiter.api.AfterEach;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
-
-import java.time.Duration;
-import java.time.Instant;
-import java.util.List;
-import java.util.Random;
-import java.util.concurrent.TimeUnit;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-/**
- * Full end-to-end integration test for {@link SpectorMemory}.
- *
- * <p>Uses a deterministic mock {@link EmbeddingProvider} that produces
- * hash-based vectors for repeatable test results.</p>
- */
-class SpectorMemoryIntegrationTest {
-
-    private static final int DIMENSIONS = 32; // small for testing speed
-    private SpectorMemory memory;
-
-    @BeforeEach
-    void setUp() {
-        memory = DefaultSpectorMemory.builder()
-                .dimensions(DIMENSIONS)
-                .embeddingProvider(new MockEmbeddingProvider(DIMENSIONS))
-                .persistenceMode(MemoryPersistenceMode.IN_MEMORY)
-                .workingCapacity(20)
-                .episodicPartitionCapacity(100)
-                .semanticCapacity(100)
-                .proceduralCapacity(100)
-                .build();
-    }
-
-    @AfterEach
-    void tearDown() {
-        memory.close();
-    }
-
-    // ── V1: Core Pipeline ──
-
-    @Test
-    void rememberAndRecall() throws Exception {
-        memory.remember("pref-dark", "User prefers dark mode.",
-                MemoryType.EPISODIC, MemorySource.USER_STATED, "ui", "preferences").get(5, TimeUnit.SECONDS);
-        memory.remember("pref-java", "User prefers Java over Python.",
-                MemoryType.EPISODIC, MemorySource.USER_STATED, "language", "preferences").get(5, TimeUnit.SECONDS);
-        memory.remember("error-db", "Database lock timeout on table users.",
-                MemoryType.EPISODIC, MemorySource.OBSERVED, "error", "database").get(5, TimeUnit.SECONDS);
-
-        assertThat(memory.totalMemories()).isEqualTo(3);
-        assertThat(memory.memoryCount(MemoryType.EPISODIC)).isEqualTo(3);
-
-        // Recall should return results
-        List<CognitiveResult> results = memory.recall("user preferences");
-        assertThat(results).isNotEmpty();
-    }
-
-    @Test
-    void rememberMultipleTiers() throws Exception {
-        memory.remember("working-1", "In-progress reasoning.",
-                MemoryType.WORKING, "scratch").get(5, TimeUnit.SECONDS);
-        memory.remember("semantic-1", "Java is a programming language.",
-                MemoryType.SEMANTIC, MemorySource.OBSERVED, "java").get(5, TimeUnit.SECONDS);
-        memory.remember("procedural-1", "Always check null before accessing.",
-                MemoryType.PROCEDURAL, MemorySource.PROCEDURAL, "rule").get(5, TimeUnit.SECONDS);
-        memory.remember("episodic-1", "Deployed v2.1 to staging.",
-                MemoryType.EPISODIC, MemorySource.OBSERVED, "deployment").get(5, TimeUnit.SECONDS);
-
-        assertThat(memory.memoryCount(MemoryType.WORKING)).isEqualTo(1);
-        assertThat(memory.memoryCount(MemoryType.SEMANTIC)).isEqualTo(1);
-        assertThat(memory.memoryCount(MemoryType.PROCEDURAL)).isEqualTo(1);
-        assertThat(memory.memoryCount(MemoryType.EPISODIC)).isEqualTo(1);
-        assertThat(memory.totalMemories()).isEqualTo(4);
-    }
-
-    @Test
-    void forgetRemovesFromRecall() throws Exception {
-        memory.remember("to-forget", "This will be forgotten.",
-                MemoryType.EPISODIC, "temp").get(5, TimeUnit.SECONDS);
-        assertThat(memory.totalMemories()).isEqualTo(1);
-
-        memory.forget("to-forget");
-
-        // The memory should be tombstoned and excluded from results
-        List<CognitiveResult> results = memory.recall("forgotten");
-        assertThat(results).noneMatch(r -> "to-forget".equals(r.id()));
-    }
-
-    @Test
-    void scratchpadStoresInWorking() throws Exception {
-        memory.scratchpad("Thinking about the architecture...").get(5, TimeUnit.SECONDS);
-        assertThat(memory.memoryCount(MemoryType.WORKING)).isEqualTo(1);
-    }
-
-    // ── V2: Reinforcement & Suppression ──
-
-    @Test
-    void reinforceUpdatesValence() throws Exception {
-        memory.remember("to-reinforce", "This approach works well.",
-                MemoryType.EPISODIC, "test").get(5, TimeUnit.SECONDS);
-
-        // Reinforce with positive outcome
-        memory.reinforce("to-reinforce", Valence.STRONGLY_POSITIVE);
-
-        // Recall and verify valence was updated
-        List<CognitiveResult> results = memory.recall("approach works");
-        CognitiveResult reinforced = results.stream()
-                .filter(r -> "to-reinforce".equals(r.id()))
-                .findFirst()
-                .orElse(null);
-
-        if (reinforced != null) {
-            assertThat(reinforced.valence()).isGreaterThan((byte) 0);
-        }
-    }
-
-    @Test
-    void suppressExcludesFromRecall() throws Exception {
-        memory.remember("to-suppress", "Misleading information.",
-                MemoryType.EPISODIC, "test").get(5, TimeUnit.SECONDS);
-        memory.remember("keep-this", "Helpful information.",
-                MemoryType.EPISODIC, "test").get(5, TimeUnit.SECONDS);
-
-        memory.suppress("to-suppress", "led to wrong answer");
-
-        List<CognitiveResult> results = memory.recall("information");
-        assertThat(results).noneMatch(r -> "to-suppress".equals(r.id()));
-    }
-
-    @Test
-    void unsuppressAllowsRecall() throws Exception {
-        memory.remember("suppress-then-allow", "Toggle suppression test.",
-                MemoryType.EPISODIC, "test").get(5, TimeUnit.SECONDS);
-
-        memory.suppress("suppress-then-allow");
-        assertThat(memory.suppression().isSuppressed("suppress-then-allow")).isTrue();
-
-        memory.unsuppress("suppress-then-allow");
-        assertThat(memory.suppression().isSuppressed("suppress-then-allow")).isFalse();
-    }
-
-    // ── V2: Metamemory ──
-
-    @Test
-    void introspectReturnsInsight() throws Exception {
-        for (int i = 0; i < 5; i++) {
-            memory.remember("java-" + i, "Java fact number " + i,
-                    MemoryType.EPISODIC, MemorySource.OBSERVED, "java").get(5, TimeUnit.SECONDS);
-        }
-
-        MemoryInsight insight = memory.introspect("java");
-        assertThat(insight.totalMemories()).isGreaterThan(0);
-        assertThat(insight.recommendation()).isNotBlank();
-    }
-
-    // ── V3: Prospective Memory ──
-
-    @Test
-    void scheduleReminderAppearsInRecall() throws Exception {
-        memory.remember("base", "Background memory.",
-                MemoryType.EPISODIC, "test").get(5, TimeUnit.SECONDS);
-
-        // Schedule a reminder in the past (should trigger immediately)
-        memory.scheduleReminder("Check deployment status",
-                Instant.now().minus(Duration.ofMinutes(1)), "deployment");
-
-        List<CognitiveResult> results = memory.recall("anything");
-        boolean hasProspective = results.stream()
-                .anyMatch(r -> r.text().contains("Check deployment status"));
-        assertThat(hasProspective).isTrue();
-    }
-
-    // ── V2: Reflect ──
-
-    @Test
-    void reflectReturnsReport() throws Exception {
-        for (int i = 0; i < 5; i++) {
-            memory.remember("episodic-" + i, "Event " + i + " happened.",
-                    MemoryType.EPISODIC, MemorySource.OBSERVED, "events").get(5, TimeUnit.SECONDS);
-        }
-
-        ReflectReport report = memory.reflect();
-        assertThat(report).isNotNull();
-        assertThat(report.duration()).isNotNull();
-    }
-
-    // ── V2: WAL ──
-
-    @Test
-    void walTracksAllMutations() throws Exception {
-        memory.remember("wal-1", "First memory.",
-                MemoryType.EPISODIC, "test").get(5, TimeUnit.SECONDS);
-        memory.remember("wal-2", "Second memory.",
-                MemoryType.EPISODIC, "test").get(5, TimeUnit.SECONDS);
-        memory.forget("wal-1");
-        memory.reinforce("wal-2", Valence.POSITIVE);
-
-        // WAL should have: 2 REMEMBER + 1 FORGET + 1 REINFORCE = 4 events
-        assertThat(memory.wal().size()).isGreaterThanOrEqualTo(4);
-    }
-
-    // ── V2: Hebbian Co-Activation ──
-
-    @Test
-    void hebbianTracksCoActivation() throws Exception {
-        memory.remember("co-1", "Java performance tuning.",
-                MemoryType.EPISODIC, "java", "performance").get(5, TimeUnit.SECONDS);
-        memory.remember("co-2", "Java garbage collection.",
-                MemoryType.EPISODIC, "java", "gc").get(5, TimeUnit.SECONDS);
-
-        // Recall should trigger co-activation tracking
-        memory.recall("java performance gc");
-
-        // The co-activation tracker should have tracked something
-        // (depends on whether results were returned together)
-        assertThat(memory.coActivation()).isNotNull();
-    }
-
-    // ── V2: Habituation ──
-
-    @Test
-    void habituationPenalizesRepeatResults() throws Exception {
-        memory.remember("repeat-1", "Always returned memory.",
-                MemoryType.EPISODIC, "common").get(5, TimeUnit.SECONDS);
-
-        // First recall
-        List<CognitiveResult> first = memory.recall("common topic");
-        float firstScore = first.isEmpty() ? 0 : first.getFirst().score();
-
-        // Second recall — habituation should reduce score
-        List<CognitiveResult> second = memory.recall("common topic");
-        float secondScore = second.isEmpty() ? 0 : second.getFirst().score();
-
-        if (firstScore > 0 && secondScore > 0) {
-            assertThat(secondScore).isLessThanOrEqualTo(firstScore);
-        }
-    }
-
-    // ── Mock Provider ──
-
-    /**
-     * Deterministic mock that produces hash-based vectors.
-     * Same text always produces the same vector.
-     */
-    static class MockEmbeddingProvider implements EmbeddingProvider {
-
-        private final int dims;
-
-        MockEmbeddingProvider(int dims) {
-            this.dims = dims;
-        }
-
-        @Override
-        public EmbeddingResult embed(String text) {
-            // Deterministic: hash-based vector generation
-            Random rng = new Random(text.hashCode());
-            float[] vector = new float[dims];
-            for (int i = 0; i < dims; i++) {
-                vector[i] = (rng.nextFloat() - 0.5f) * 2.0f; // range [-1, 1]
-            }
-            // Normalize to unit length
-            float norm = 0f;
-            for (float v : vector) norm += v * v;
-            norm = (float) Math.sqrt(norm);
-            if (norm > 0) {
-                for (int i = 0; i < dims; i++) vector[i] /= norm;
-            }
-            return new EmbeddingResult(vector, text.split("\\s+").length, "mock-" + dims + "d");
-        }
-
-        @Override
-        public int dimensions() { return dims; }
-
-        @Override
-        public String modelName() { return "mock-" + dims + "d"; }
-    }
-}
diff --git a/spector-memory/src/test/java/com/spectrayan/spector/memory/amygdala/ValenceTrackerTest.java b/spector-memory/src/test/java/com/spectrayan/spector/memory/amygdala/ValenceTrackerTest.java
deleted file mode 100644
index 0e0cf1b..0000000
--- a/spector-memory/src/test/java/com/spectrayan/spector/memory/amygdala/ValenceTrackerTest.java
+++ /dev/null
@@ -1,74 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.amygdala;
-
-import com.spectrayan.spector.memory.MemoryType;
-import com.spectrayan.spector.memory.synapse.CognitiveRecordLayout;
-import com.spectrayan.spector.memory.synapse.CognitiveRecordLayout.CognitiveHeader;
-import com.spectrayan.spector.memory.synapse.SynapticHeaderConstants;
-import org.junit.jupiter.api.Test;
-
-import java.lang.foreign.Arena;
-import java.lang.foreign.MemorySegment;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-class ValenceTrackerTest {
-
-    private final CognitiveRecordLayout layout = new CognitiveRecordLayout(32);
-
-    @Test
-    void reinforceBlends() {
-        try (var arena = Arena.ofConfined()) {
-            MemorySegment seg = arena.allocate(layout.stride());
-            var header = CognitiveHeader.create(System.currentTimeMillis(), 0L, 1f, 1f, (short) 0, MemoryType.EPISODIC);
-            layout.writeHeader(seg, 0, header);
-
-            var tracker = new ValenceTracker(0.5f);
-            // Reinforce with strong positive
-            tracker.reinforce(seg, 0, layout, Valence.STRONGLY_POSITIVE);
-            byte v1 = layout.readValence(seg, 0);
-            assertThat(v1).isGreaterThan((byte) 0);
-
-            // Reinforce with negative — should blend down
-            tracker.reinforce(seg, 0, layout, Valence.STRONGLY_NEGATIVE);
-            byte v2 = layout.readValence(seg, 0);
-            assertThat(v2).isLessThan(v1);
-        }
-    }
-
-    @Test
-    void valenceClampsBounds() {
-        assertThat(Valence.clamp(200)).isEqualTo(Byte.MAX_VALUE);
-        assertThat(Valence.clamp(-200)).isEqualTo(Byte.MIN_VALUE);
-        assertThat(Valence.clamp(50)).isEqualTo((byte) 50);
-    }
-
-    @Test
-    void valencePolarity() {
-        assertThat(Valence.isPositive(Valence.STRONGLY_POSITIVE)).isTrue();
-        assertThat(Valence.isNegative(Valence.STRONGLY_NEGATIVE)).isTrue();
-        assertThat(Valence.isPositive(Valence.NEUTRAL)).isFalse();
-        assertThat(Valence.isNegative(Valence.NEUTRAL)).isFalse();
-    }
-
-    @Test
-    void blendConverges() {
-        // Repeated positive reinforcement should converge toward max
-        byte v = Valence.NEUTRAL;
-        for (int i = 0; i < 20; i++) {
-            v = Valence.blend(v, Valence.STRONGLY_POSITIVE, 0.3f);
-        }
-        assertThat(v).isGreaterThan((byte) 80);
-    }
-}
diff --git a/spector-memory/src/test/java/com/spectrayan/spector/memory/cortex/EpisodicMmapPersistenceTest.java b/spector-memory/src/test/java/com/spectrayan/spector/memory/cortex/EpisodicMmapPersistenceTest.java
deleted file mode 100644
index 30c3ef2..0000000
--- a/spector-memory/src/test/java/com/spectrayan/spector/memory/cortex/EpisodicMmapPersistenceTest.java
+++ /dev/null
@@ -1,245 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.cortex;
-
-import com.spectrayan.spector.memory.MemoryType;
-import com.spectrayan.spector.memory.synapse.CognitiveRecordLayout;
-import com.spectrayan.spector.memory.synapse.CognitiveRecordLayout.CognitiveHeader;
-import com.spectrayan.spector.memory.synapse.SynapticHeaderConstants;
-import org.junit.jupiter.api.AfterEach;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.io.TempDir;
-
-import java.io.IOException;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.util.List;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-/**
- * Tests for mmap-backed EpisodicMemoryStore persistence.
- */
-class EpisodicMmapPersistenceTest {
-
-    private static final int VEC_BYTES = 16;
-    private static final int CAPACITY = 100;
-
-    @TempDir
-    Path tempDir;
-
-    private Path storePath;
-
-    @BeforeEach
-    void setUp() {
-        storePath = tempDir.resolve("episodic");
-    }
-
-    // ── Basic Persistence ──
-
-    @Test
-    void appendAndRecoverAcrossRestart() {
-        // Write records to the store
-        try (EpisodicMemoryStore store = new EpisodicMemoryStore(storePath, VEC_BYTES, CAPACITY)) {
-            for (int i = 0; i < 50; i++) {
-                CognitiveHeader header = CognitiveHeader.create(
-                        System.currentTimeMillis(), i * 7L, 1.0f,
-                        (float) i / 10, (short) 0, MemoryType.EPISODIC);
-                byte[] vec = makeVec(i);
-                store.append(header, vec);
-            }
-            assertThat(store.totalRecords()).isEqualTo(50);
-        }
-
-        // Reopen — should recover all records from mmap files
-        try (EpisodicMemoryStore store2 = new EpisodicMemoryStore(storePath, VEC_BYTES, CAPACITY)) {
-            assertThat(store2.totalRecords()).isEqualTo(50);
-            assertThat(store2.partitionCount()).isEqualTo(1);
-
-            // Verify record content
-            EpisodicMemoryStore.EpisodicPartition partition = store2.partitions().getFirst();
-            CognitiveRecordLayout layout = partition.layout();
-            var segment = partition.segment();
-
-            // Check first record
-            long offset0 = partition.recordOffset(0);
-            assertThat(layout.readImportance(segment, offset0)).isEqualTo(0f);
-
-            // Check last record
-            long offset49 = partition.recordOffset(49);
-            assertThat(layout.readImportance(segment, offset49)).isEqualTo(4.9f);
-        }
-    }
-
-    @Test
-    void metadataHeaderPreservesCountAndTombstones() {
-        try (EpisodicMemoryStore store = new EpisodicMemoryStore(storePath, VEC_BYTES, CAPACITY)) {
-            for (int i = 0; i < 20; i++) {
-                CognitiveHeader header = CognitiveHeader.create(
-                        System.currentTimeMillis(), 0L, 1.0f, 1.0f, (short) 0, MemoryType.EPISODIC);
-                store.append(header, makeVec(i));
-            }
-
-            // Tombstone some records
-            EpisodicMemoryStore.EpisodicPartition partition = store.partitions().getFirst();
-            var segment = partition.segment();
-            var layout = partition.layout();
-            for (int i = 0; i < 5; i++) {
-                layout.tombstone(segment, partition.recordOffset(i));
-                partition.incrementTombstoneCount();
-            }
-
-            assertThat(partition.count()).isEqualTo(20);
-            assertThat(partition.tombstoneCount()).isEqualTo(5);
-        }
-
-        // Reopen and verify metadata
-        try (EpisodicMemoryStore store2 = new EpisodicMemoryStore(storePath, VEC_BYTES, CAPACITY)) {
-            EpisodicMemoryStore.EpisodicPartition partition = store2.partitions().getFirst();
-            assertThat(partition.count()).isEqualTo(20);
-            assertThat(partition.tombstoneCount()).isEqualTo(5);
-            assertThat(partition.tombstoneRatio()).isEqualTo(0.25f);
-        }
-    }
-
-    @Test
-    void appendAfterRecovery() {
-        try (EpisodicMemoryStore store = new EpisodicMemoryStore(storePath, VEC_BYTES, CAPACITY)) {
-            for (int i = 0; i < 10; i++) {
-                store.append(CognitiveHeader.create(
-                        System.currentTimeMillis(), 0L, 1.0f, 1.0f, (short) 0, MemoryType.EPISODIC), makeVec(i));
-            }
-        }
-
-        try (EpisodicMemoryStore store2 = new EpisodicMemoryStore(storePath, VEC_BYTES, CAPACITY)) {
-            assertThat(store2.totalRecords()).isEqualTo(10);
-
-            // Append more records
-            for (int i = 10; i < 20; i++) {
-                store2.append(CognitiveHeader.create(
-                        System.currentTimeMillis(), 0L, 1.0f, 2.0f, (short) 0, MemoryType.EPISODIC), makeVec(i));
-            }
-            assertThat(store2.totalRecords()).isEqualTo(20);
-        }
-
-        // Third open — verify all 20
-        try (EpisodicMemoryStore store3 = new EpisodicMemoryStore(storePath, VEC_BYTES, CAPACITY)) {
-            assertThat(store3.totalRecords()).isEqualTo(20);
-
-            EpisodicMemoryStore.EpisodicPartition partition = store3.partitions().getFirst();
-            var layout = partition.layout();
-            var segment = partition.segment();
-
-            // First 10 have importance 1.0, next 10 have importance 2.0
-            assertThat(layout.readImportance(segment, partition.recordOffset(5))).isEqualTo(1.0f);
-            assertThat(layout.readImportance(segment, partition.recordOffset(15))).isEqualTo(2.0f);
-        }
-    }
-
-    // ── Partition State ──
-
-    @Test
-    void partitionStatesLifecycle() {
-        try (EpisodicMemoryStore store = new EpisodicMemoryStore(storePath, VEC_BYTES, CAPACITY)) {
-            store.append(CognitiveHeader.create(
-                    System.currentTimeMillis(), 0L, 1.0f, 1.0f, (short) 0, MemoryType.EPISODIC), makeVec(0));
-
-            EpisodicMemoryStore.EpisodicPartition partition = store.partitions().getFirst();
-            assertThat(partition.state()).isEqualTo(EpisodicMemoryStore.PartitionState.ACTIVE);
-
-            partition.seal();
-            assertThat(partition.state()).isEqualTo(EpisodicMemoryStore.PartitionState.SEALED);
-
-            partition.setState(EpisodicMemoryStore.PartitionState.REFLECTABLE);
-            assertThat(partition.state()).isEqualTo(EpisodicMemoryStore.PartitionState.REFLECTABLE);
-        }
-    }
-
-    // ── Partition File Structure ──
-
-    @Test
-    void partitionFileCreatedOnDisk() throws IOException {
-        try (EpisodicMemoryStore store = new EpisodicMemoryStore(storePath, VEC_BYTES, CAPACITY)) {
-            store.append(CognitiveHeader.create(
-                    System.currentTimeMillis(), 0L, 1.0f, 1.0f, (short) 0, MemoryType.EPISODIC), makeVec(0));
-        }
-
-        // Verify partition file exists
-        try (var files = Files.list(storePath)) {
-            long memFiles = files.filter(p -> p.getFileName().toString().endsWith(".mem")).count();
-            assertThat(memFiles).isGreaterThanOrEqualTo(1);
-        }
-    }
-
-    @Test
-    void recordOffsetAccountsForMetadataHeader() {
-        try (EpisodicMemoryStore store = new EpisodicMemoryStore(storePath, VEC_BYTES, CAPACITY)) {
-            store.append(CognitiveHeader.create(
-                    System.currentTimeMillis(), 0L, 1.0f, 1.0f, (short) 0, MemoryType.EPISODIC), makeVec(0));
-
-            EpisodicMemoryStore.EpisodicPartition partition = store.partitions().getFirst();
-
-            // First record should be at offset 64 (METADATA_HEADER_BYTES)
-            long offset0 = partition.recordOffset(0);
-            assertThat(offset0).isEqualTo(EpisodicMemoryStore.EpisodicPartition.METADATA_HEADER_BYTES);
-
-            // Second record should be at offset 64 + stride
-            long offset1 = partition.recordOffset(1);
-            assertThat(offset1).isEqualTo(
-                    EpisodicMemoryStore.EpisodicPartition.METADATA_HEADER_BYTES + partition.layout().stride());
-        }
-    }
-
-    // ── Replace Partition (for compaction) ──
-
-    @Test
-    void replacePartitionSwapsAtomically() {
-        try (EpisodicMemoryStore store = new EpisodicMemoryStore(storePath, VEC_BYTES, CAPACITY)) {
-            // Create partition with 10 records
-            for (int i = 0; i < 10; i++) {
-                store.append(CognitiveHeader.create(
-                        System.currentTimeMillis(), 0L, 1.0f, (float) i, (short) 0, MemoryType.EPISODIC), makeVec(i));
-            }
-
-            EpisodicMemoryStore.EpisodicPartition old = store.partitions().getFirst();
-            String key = store.keyForPartition(old);
-            assertThat(key).isNotNull();
-
-            // Create a "compacted" replacement
-            Path compactedPath = storePath.resolve("episodic-" + key + "-compacted.mem");
-            EpisodicMemoryStore.EpisodicPartition replacement =
-                    new EpisodicMemoryStore.EpisodicPartition(compactedPath, store.layout(), 50, true);
-
-            // Copy only 5 records to the replacement
-            for (int i = 0; i < 5; i++) {
-                CognitiveHeader header = old.layout().readHeader(old.segment(), old.recordOffset(i));
-                replacement.append(header, makeVec(i));
-            }
-
-            boolean swapped = store.replacePartition(key, old, replacement);
-            assertThat(swapped).isTrue();
-            assertThat(store.totalRecords()).isEqualTo(5);
-        }
-    }
-
-    // ── Helpers ──
-
-    private byte[] makeVec(int seed) {
-        byte[] vec = new byte[VEC_BYTES];
-        for (int i = 0; i < VEC_BYTES; i++) {
-            vec[i] = (byte) ((seed + i) % 127);
-        }
-        return vec;
-    }
-}
diff --git a/spector-memory/src/test/java/com/spectrayan/spector/memory/cortex/MemoryPersistenceTest.java b/spector-memory/src/test/java/com/spectrayan/spector/memory/cortex/MemoryPersistenceTest.java
deleted file mode 100644
index c1fd84f..0000000
--- a/spector-memory/src/test/java/com/spectrayan/spector/memory/cortex/MemoryPersistenceTest.java
+++ /dev/null
@@ -1,215 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.cortex;
-
-import com.spectrayan.spector.memory.MemoryType;
-import com.spectrayan.spector.memory.index.MemoryIndex;
-import com.spectrayan.spector.memory.synapse.CognitiveRecordLayout.CognitiveHeader;
-
-import org.junit.jupiter.api.AfterEach;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.io.TempDir;
-
-import java.nio.file.Path;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-/**
- * Tests file-backed persistence for Working, Semantic, and Procedural
- * memory tier stores, plus MemoryIndex save/load round-trip.
- */
-class MemoryPersistenceTest {
-
-    private static final int VEC_BYTES = 32;
-    private static final int CAPACITY = 50;
-
-    @TempDir
-    Path tmpDir;
-
-    private CognitiveHeader createHeader(long timestamp, float importance) {
-        return CognitiveHeader.create(timestamp, 0xCAFEL, 1.0f, importance, (short) 0, MemoryType.WORKING);
-    }
-
-    private byte[] dummyVec(int len, byte fill) {
-        byte[] vec = new byte[len];
-        java.util.Arrays.fill(vec, fill);
-        return vec;
-    }
-
-    // ══════════════════════════════════════════════════════════════
-    // WORKING MEMORY STORE — round-trip persistence
-    // ══════════════════════════════════════════════════════════════
-
-    @Test
-    void workingStore_persistsAndRecoversCircularBuffer() {
-        Path file = tmpDir.resolve("working.mem");
-
-        // Write 5 records
-        try (var store = new WorkingMemoryStore(VEC_BYTES, CAPACITY, file)) {
-            for (int i = 0; i < 5; i++) {
-                store.put(createHeader(1000L + i, 0.5f + i * 0.1f), dummyVec(VEC_BYTES, (byte) (i + 1)));
-            }
-            assertThat(store.size()).isEqualTo(5);
-            assertThat(store.isPersistent()).isTrue();
-        }
-
-        // Reopen and verify count
-        try (var store = new WorkingMemoryStore(VEC_BYTES, CAPACITY, file)) {
-            assertThat(store.size()).isEqualTo(5);
-
-            // Write 2 more and verify they stack correctly
-            store.put(createHeader(2000L, 0.9f), dummyVec(VEC_BYTES, (byte) 99));
-            store.put(createHeader(2001L, 0.95f), dummyVec(VEC_BYTES, (byte) 100));
-            assertThat(store.size()).isEqualTo(7);
-        }
-
-        // Reopen again — count should be 7
-        try (var store = new WorkingMemoryStore(VEC_BYTES, CAPACITY, file)) {
-            assertThat(store.size()).isEqualTo(7);
-        }
-    }
-
-    @Test
-    void workingStore_circularBufferWraparound_survivesPersistence() {
-        Path file = tmpDir.resolve("working_wrap.mem");
-        int smallCap = 5;
-
-        // Fill and wrap — write 8 records into a 5-slot buffer
-        try (var store = new WorkingMemoryStore(VEC_BYTES, smallCap, file)) {
-            for (int i = 0; i < 8; i++) {
-                store.put(createHeader(1000L + i, 0.5f), dummyVec(VEC_BYTES, (byte) i));
-            }
-            assertThat(store.size()).isEqualTo(smallCap); // capped at capacity
-        }
-
-        // Reopen — count should still be 5 (capacity)
-        try (var store = new WorkingMemoryStore(VEC_BYTES, smallCap, file)) {
-            assertThat(store.size()).isEqualTo(smallCap);
-        }
-    }
-
-    // ══════════════════════════════════════════════════════════════
-    // SEMANTIC MEMORY STORE — round-trip persistence
-    // ══════════════════════════════════════════════════════════════
-
-    @Test
-    void semanticStore_persistsAndRecoversHeaders() {
-        Path file = tmpDir.resolve("semantic.mem");
-
-        // Write 3 headers
-        try (var store = new SemanticMemoryStore(VEC_BYTES, CAPACITY, file)) {
-            for (int i = 0; i < 3; i++) {
-                var header = CognitiveHeader.create(
-                        System.currentTimeMillis(), 0xBEEFL, 1.0f, 0.7f + i * 0.1f, (short) i, MemoryType.SEMANTIC);
-                store.store(header);
-            }
-            assertThat(store.size()).isEqualTo(3);
-        }
-
-        // Reopen and verify
-        try (var store = new SemanticMemoryStore(VEC_BYTES, CAPACITY, file)) {
-            assertThat(store.size()).isEqualTo(3);
-
-            // Read back first header and verify importance
-            var h0 = store.readHeader(0);
-            assertThat(h0.importance()).isCloseTo(0.7f, org.assertj.core.data.Offset.offset(0.01f));
-        }
-    }
-
-    // ══════════════════════════════════════════════════════════════
-    // PROCEDURAL MEMORY STORE — round-trip persistence
-    // ══════════════════════════════════════════════════════════════
-
-    @Test
-    void proceduralStore_persistsAndRecoversRecords() {
-        Path file = tmpDir.resolve("procedural.mem");
-
-        try (var store = new ProceduralMemoryStore(VEC_BYTES, CAPACITY, file)) {
-            for (int i = 0; i < 4; i++) {
-                store.append(createHeader(3000L + i, 1.0f), dummyVec(VEC_BYTES, (byte) (i + 10)));
-            }
-            assertThat(store.size()).isEqualTo(4);
-        }
-
-        try (var store = new ProceduralMemoryStore(VEC_BYTES, CAPACITY, file)) {
-            assertThat(store.size()).isEqualTo(4);
-        }
-    }
-
-    // ══════════════════════════════════════════════════════════════
-    // MEMORY INDEX — save / load round-trip
-    // ══════════════════════════════════════════════════════════════
-
-    @Test
-    void memoryIndex_saveAndLoad_preservesAllMaps() {
-        Path file = tmpDir.resolve("memory-index.mem");
-
-        MemoryIndex original = new MemoryIndex();
-
-        // Register 3 entries with different types and tags
-        original.register("mem-1",
-                new MemoryIndex.MemoryLocation(MemoryType.EPISODIC, 64L, 0),
-                "The cat sat on the mat", MemorySource.OBSERVED, new String[]{"animal", "location"});
-
-        original.register("mem-2",
-                new MemoryIndex.MemoryLocation(MemoryType.SEMANTIC, 128L, -1),
-                "Java 25 supports Panama FFM API", MemorySource.USER_STATED, new String[]{"java", "panama"});
-
-        original.register("mem-3",
-                new MemoryIndex.MemoryLocation(MemoryType.PROCEDURAL, 0L, -1),
-                "Use ScalarQuantizer for 8-bit encoding", MemorySource.PROCEDURAL, new String[]{});
-
-        // Save
-        original.save(file);
-
-        // Load
-        MemoryIndex loaded = MemoryIndex.load(file);
-
-        // Verify sizes
-        assertThat(loaded.size()).isEqualTo(3);
-
-        // Verify forward index
-        assertThat(loaded.locate("mem-1")).isNotNull();
-        assertThat(loaded.locate("mem-1").type()).isEqualTo(MemoryType.EPISODIC);
-        assertThat(loaded.locate("mem-1").offset()).isEqualTo(64L);
-        assertThat(loaded.locate("mem-1").partitionIndex()).isEqualTo(0);
-        assertThat(loaded.text("mem-1")).isEqualTo("The cat sat on the mat");
-        assertThat(loaded.source("mem-1")).isEqualTo(MemorySource.OBSERVED);
-        assertThat(loaded.tags("mem-1")).containsExactly("animal", "location");
-
-        assertThat(loaded.locate("mem-2").type()).isEqualTo(MemoryType.SEMANTIC);
-        assertThat(loaded.text("mem-2")).isEqualTo("Java 25 supports Panama FFM API");
-        assertThat(loaded.source("mem-2")).isEqualTo(MemorySource.USER_STATED);
-
-        assertThat(loaded.text("mem-3")).isEqualTo("Use ScalarQuantizer for 8-bit encoding");
-        assertThat(loaded.tags("mem-3")).isEmpty();
-
-        // Verify reverse index
-        assertThat(loaded.findIdByOffset(MemoryType.EPISODIC, 64L)).isEqualTo("mem-1");
-        assertThat(loaded.findIdByOffset(MemoryType.SEMANTIC, 128L)).isEqualTo("mem-2");
-        assertThat(loaded.findIdByOffset(MemoryType.PROCEDURAL, 0L)).isEqualTo("mem-3");
-    }
-
-    @Test
-    void memoryIndex_load_missingFile_returnsEmpty() {
-        MemoryIndex loaded = MemoryIndex.load(tmpDir.resolve("nonexistent.mem"));
-        assertThat(loaded.size()).isEqualTo(0);
-    }
-
-    @Test
-    void memoryIndex_load_nullPath_returnsEmpty() {
-        MemoryIndex loaded = MemoryIndex.load(null);
-        assertThat(loaded.size()).isEqualTo(0);
-    }
-}
diff --git a/spector-memory/src/test/java/com/spectrayan/spector/memory/cortex/WorkingMemoryStoreTest.java b/spector-memory/src/test/java/com/spectrayan/spector/memory/cortex/WorkingMemoryStoreTest.java
deleted file mode 100644
index 9cc095f..0000000
--- a/spector-memory/src/test/java/com/spectrayan/spector/memory/cortex/WorkingMemoryStoreTest.java
+++ /dev/null
@@ -1,113 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.cortex;
-
-import com.spectrayan.spector.memory.MemoryType;
-import com.spectrayan.spector.memory.synapse.CognitiveRecordLayout;
-import com.spectrayan.spector.memory.synapse.CognitiveRecordLayout.CognitiveHeader;
-import com.spectrayan.spector.memory.synapse.SynapticHeaderConstants;
-import com.spectrayan.spector.memory.synapse.SynapticTagEncoder;
-import org.junit.jupiter.api.AfterEach;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-/**
- * Tests for {@link WorkingMemoryStore} — volatile circular buffer.
- */
-class WorkingMemoryStoreTest {
-
-    private static final int VEC_BYTES = 32; // small vectors for testing
-    private WorkingMemoryStore store;
-
-    @BeforeEach
-    void setUp() {
-        store = new WorkingMemoryStore(VEC_BYTES, 5); // capacity of 5 for easy testing
-    }
-
-    @AfterEach
-    void tearDown() {
-        store.close();
-    }
-
-    @Test
-    void putAndSize() {
-        assertThat(store.size()).isZero();
-
-        store.put(createHeader("java"), new byte[VEC_BYTES]);
-        assertThat(store.size()).isEqualTo(1);
-
-        store.put(createHeader("python"), new byte[VEC_BYTES]);
-        assertThat(store.size()).isEqualTo(2);
-    }
-
-    @Test
-    void fifoEvictionWhenFull() {
-        // Fill to capacity
-        for (int i = 0; i < 5; i++) {
-            store.put(createHeader("tag-" + i), new byte[VEC_BYTES]);
-        }
-        assertThat(store.size()).isEqualTo(5);
-
-        // One more should evict oldest (FIFO, size stays at capacity)
-        store.put(createHeader("tag-overflow"), new byte[VEC_BYTES]);
-        assertThat(store.size()).isEqualTo(5); // stays at capacity
-    }
-
-    @Test
-    void scanReturnsMatchingOffsets() {
-        long javaTag = SynapticTagEncoder.encode("java");
-        long pythonTag = SynapticTagEncoder.encode("python");
-
-        store.put(createHeader("java"), new byte[VEC_BYTES]);
-        store.put(createHeader("python"), new byte[VEC_BYTES]);
-        store.put(createHeader("java", "performance"), new byte[VEC_BYTES]);
-
-        // Scan for "java" tag
-        long[] matches = store.scan(javaTag);
-        assertThat(matches.length).isGreaterThanOrEqualTo(2); // at least 2 java-tagged
-
-        // Scan with no filter (0 mask matches everything)
-        long[] all = store.scan(0L);
-        assertThat(all.length).isEqualTo(3);
-    }
-
-    @Test
-    void scanSkipsTombstones() {
-        store.put(createHeader("java"), new byte[VEC_BYTES]);
-        store.put(createHeader("python"), new byte[VEC_BYTES]);
-
-        // Tombstone the first record
-        store.layout().tombstone(store.segment(), 0);
-
-        long[] all = store.scan(0L);
-        assertThat(all.length).isEqualTo(1); // only the non-tombstoned one
-    }
-
-    @Test
-    void capacityIsCorrect() {
-        assertThat(store.capacity()).isEqualTo(5);
-    }
-
-    private CognitiveHeader createHeader(String... tags) {
-        return CognitiveHeader.create(
-                System.currentTimeMillis(),
-                SynapticTagEncoder.encode(tags),
-                1.0f,
-                1.0f,
-                (short) 0,
-                MemoryType.WORKING
-        );
-    }
-}
diff --git a/spector-memory/src/test/java/com/spectrayan/spector/memory/dopamine/FlashbulbPolicyTest.java b/spector-memory/src/test/java/com/spectrayan/spector/memory/dopamine/FlashbulbPolicyTest.java
deleted file mode 100644
index 48fd49e..0000000
--- a/spector-memory/src/test/java/com/spectrayan/spector/memory/dopamine/FlashbulbPolicyTest.java
+++ /dev/null
@@ -1,52 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.dopamine;
-
-import org.junit.jupiter.api.Test;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-class FlashbulbPolicyTest {
-
-    @Test
-    void belowThresholdReturnsNormal() {
-        var policy = new FlashbulbPolicy(3.0);
-        var decision = policy.evaluate(2.5);
-        assertThat(decision.isFlashbulb()).isFalse();
-        assertThat(decision.importance()).isEqualTo(-1f);
-        assertThat(decision.pinned()).isFalse();
-    }
-
-    @Test
-    void aboveThresholdTriggersFlashbulb() {
-        var policy = new FlashbulbPolicy(3.0);
-        var decision = policy.evaluate(4.0);
-        assertThat(decision.isFlashbulb()).isTrue();
-        assertThat(decision.importance()).isEqualTo(10.0f);
-        assertThat(decision.pinned()).isTrue();
-    }
-
-    @Test
-    void exactThresholdDoesNotTrigger() {
-        var policy = new FlashbulbPolicy(3.0);
-        var decision = policy.evaluate(3.0);
-        assertThat(decision.isFlashbulb()).isFalse();
-    }
-
-    @Test
-    void customThreshold() {
-        var policy = new FlashbulbPolicy(1.0);
-        assertThat(policy.evaluate(1.5).isFlashbulb()).isTrue();
-        assertThat(policy.evaluate(0.5).isFlashbulb()).isFalse();
-    }
-}
diff --git a/spector-memory/src/test/java/com/spectrayan/spector/memory/dopamine/SurpriseDetectorTest.java b/spector-memory/src/test/java/com/spectrayan/spector/memory/dopamine/SurpriseDetectorTest.java
deleted file mode 100644
index 88ae872..0000000
--- a/spector-memory/src/test/java/com/spectrayan/spector/memory/dopamine/SurpriseDetectorTest.java
+++ /dev/null
@@ -1,99 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.dopamine;
-
-import org.junit.jupiter.api.Test;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-/**
- * Tests for {@link SurpriseDetector} — dopamine-based importance assignment.
- */
-class SurpriseDetectorTest {
-
-    @Test
-    void duringWarmupReturnsDefaultImportance() {
-        var detector = new SurpriseDetector(20);
-
-        // First 19 samples should return default importance (1.0)
-        for (int i = 0; i < 19; i++) {
-            float importance = detector.computeImportance(0.5f + i * 0.01f);
-            assertThat(importance).isEqualTo(1.0f);
-        }
-    }
-
-    @Test
-    void afterWarmupUsesZScoreMapping() {
-        var detector = new SurpriseDetector(5);
-
-        // Warmup with 5 samples around distance 1.0
-        for (int i = 0; i < 5; i++) {
-            detector.computeImportance(1.0f + i * 0.01f);
-        }
-
-        // A value at the mean should get normal importance
-        float normalImportance = detector.computeImportance(1.02f);
-        assertThat(normalImportance).isEqualTo(0.5f);
-    }
-
-    @Test
-    void extremeOutlierGetsDopamineSpike() {
-        var detector = new SurpriseDetector(5);
-
-        // Warmup with tight cluster
-        for (int i = 0; i < 10; i++) {
-            detector.computeImportance(1.0f);
-        }
-
-        // Extreme outlier
-        float importance = detector.computeImportance(100.0f);
-        assertThat(importance).isGreaterThanOrEqualTo(5.0f);
-    }
-
-    @Test
-    void verySimilarValueGetsSuppressed() {
-        var detector = new SurpriseDetector(5);
-
-        // Build baseline around 10.0 with some spread
-        for (int i = 0; i < 20; i++) {
-            detector.computeImportance(10.0f + (float)(Math.random() * 2.0 - 1.0));
-        }
-
-        // A value well below the mean (very similar to existing memories)
-        float importance = detector.computeImportance(5.0f);
-        assertThat(importance).isLessThanOrEqualTo(0.5f);
-    }
-
-    @Test
-    void zScoreToImportanceMappingBoundaries() {
-        assertThat(SurpriseDetector.zScoreToImportance(-2.0)).isEqualTo(0.1f);
-        assertThat(SurpriseDetector.zScoreToImportance(-0.5)).isEqualTo(0.5f);
-        assertThat(SurpriseDetector.zScoreToImportance(0.0)).isEqualTo(0.5f);
-        assertThat(SurpriseDetector.zScoreToImportance(1.0)).isEqualTo(0.5f);
-        assertThat(SurpriseDetector.zScoreToImportance(1.5)).isEqualTo(2.0f);
-        assertThat(SurpriseDetector.zScoreToImportance(2.5)).isEqualTo(5.0f);
-        assertThat(SurpriseDetector.zScoreToImportance(4.0)).isEqualTo(10.0f);
-    }
-
-    @Test
-    void resetClearsBaseline() {
-        var detector = new SurpriseDetector(5);
-
-        for (int i = 0; i < 10; i++) {
-            detector.computeImportance(1.0f);
-        }
-
-        detector.reset();
-        assertThat(detector.stats().count()).isZero();
-    }
-}
diff --git a/spector-memory/src/test/java/com/spectrayan/spector/memory/dopamine/WelfordStatsTest.java b/spector-memory/src/test/java/com/spectrayan/spector/memory/dopamine/WelfordStatsTest.java
deleted file mode 100644
index 8489572..0000000
--- a/spector-memory/src/test/java/com/spectrayan/spector/memory/dopamine/WelfordStatsTest.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.dopamine;
-
-import org.junit.jupiter.api.Test;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.within;
-
-/**
- * Tests for {@link WelfordStats} — running mean/stddev.
- */
-class WelfordStatsTest {
-
-    @Test
-    void emptyStatsReturnZero() {
-        var stats = new WelfordStats();
-
-        assertThat(stats.mean()).isZero();
-        assertThat(stats.stddev()).isZero();
-        assertThat(stats.count()).isZero();
-    }
-
-    @Test
-    void singleValueGivesMeanNoStddev() {
-        var stats = new WelfordStats();
-        stats.update(5.0);
-
-        assertThat(stats.mean()).isCloseTo(5.0, within(1e-9));
-        assertThat(stats.stddev()).isZero(); // need at least 2 samples
-        assertThat(stats.count()).isEqualTo(1);
-    }
-
-    @Test
-    void knownInputProducesCorrectStats() {
-        var stats = new WelfordStats();
-        // Values: 2, 4, 4, 4, 5, 5, 7, 9
-        // Mean = 5.0, Population stddev = √4 = 2.0
-        double[] values = {2, 4, 4, 4, 5, 5, 7, 9};
-        for (double v : values) {
-            stats.update(v);
-        }
-
-        assertThat(stats.mean()).isCloseTo(5.0, within(1e-9));
-        assertThat(stats.stddev()).isCloseTo(2.0, within(1e-9));
-        assertThat(stats.count()).isEqualTo(8);
-    }
-
-    @Test
-    void zScoreCalculation() {
-        var stats = new WelfordStats();
-        double[] values = {2, 4, 4, 4, 5, 5, 7, 9};
-        for (double v : values) {
-            stats.update(v);
-        }
-
-        // Mean = 5.0, stddev = 2.0
-        assertThat(stats.zScore(5.0)).isCloseTo(0.0, within(1e-9));  // at mean
-        assertThat(stats.zScore(7.0)).isCloseTo(1.0, within(1e-9));  // 1 sigma above
-        assertThat(stats.zScore(3.0)).isCloseTo(-1.0, within(1e-9)); // 1 sigma below
-        assertThat(stats.zScore(11.0)).isCloseTo(3.0, within(1e-9)); // 3 sigma above
-    }
-
-    @Test
-    void zScoreWithZeroStddevReturnsZero() {
-        var stats = new WelfordStats();
-        stats.update(5.0);
-
-        assertThat(stats.zScore(10.0)).isZero();
-    }
-
-    @Test
-    void resetClearsAll() {
-        var stats = new WelfordStats();
-        stats.update(1.0);
-        stats.update(2.0);
-        stats.update(3.0);
-
-        stats.reset();
-
-        assertThat(stats.count()).isZero();
-        assertThat(stats.mean()).isZero();
-        assertThat(stats.stddev()).isZero();
-    }
-}
diff --git a/spector-memory/src/test/java/com/spectrayan/spector/memory/graph/EntityGraphTest.java b/spector-memory/src/test/java/com/spectrayan/spector/memory/graph/EntityGraphTest.java
deleted file mode 100644
index d98d0fd..0000000
--- a/spector-memory/src/test/java/com/spectrayan/spector/memory/graph/EntityGraphTest.java
+++ /dev/null
@@ -1,231 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.graph;
-
-import org.junit.jupiter.api.AfterEach;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.io.TempDir;
-
-import java.nio.file.Path;
-import java.util.List;
-import java.util.Set;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-/**
- * Tests for EntityGraph: entity management, relations, traversal, and persistence.
- */
-class EntityGraphTest {
-
-    @TempDir
-    Path tempDir;
-
-    private EntityGraph graph;
-
-    @BeforeEach
-    void setUp() {
-        graph = new EntityGraph(100, 500);
-    }
-
-    @AfterEach
-    void tearDown() {
-        graph.close();
-    }
-
-    @Test
-    void addEntityReturnsId() {
-        int id = graph.addEntity("Alice", EntityType.PERSON);
-        assertThat(id).isEqualTo(0);
-        assertThat(graph.entityCount()).isEqualTo(1);
-    }
-
-    @Test
-    void addDuplicateEntityReturnsExistingId() {
-        int id1 = graph.addEntity("Alice", EntityType.PERSON);
-        int id2 = graph.addEntity("alice", EntityType.PERSON); // case-insensitive
-        int id3 = graph.addEntity("ALICE", EntityType.PERSON);
-
-        assertThat(id1).isEqualTo(id2).isEqualTo(id3);
-        assertThat(graph.entityCount()).isEqualTo(1);
-    }
-
-    @Test
-    void findEntityCaseInsensitive() {
-        graph.addEntity("Project Alpha", EntityType.PROJECT);
-
-        assertThat(graph.findEntity("project alpha")).isEqualTo(0);
-        assertThat(graph.findEntity("PROJECT ALPHA")).isEqualTo(0);
-        assertThat(graph.findEntity("nonexistent")).isEqualTo(-1);
-    }
-
-    @Test
-    void entityTypePreserved() {
-        graph.addEntity("Alice", EntityType.PERSON);
-        graph.addEntity("Acme", EntityType.ORGANIZATION);
-
-        assertThat(graph.entityType(0)).isEqualTo(EntityType.PERSON);
-        assertThat(graph.entityType(1)).isEqualTo(EntityType.ORGANIZATION);
-    }
-
-    @Test
-    void addRelation() {
-        int alice = graph.addEntity("Alice", EntityType.PERSON);
-        int project = graph.addEntity("Project Alpha", EntityType.PROJECT);
-
-        graph.addRelation(alice, project, RelationType.MANAGES);
-
-        List<EntityGraph.EntityEdge> edges = graph.edges(alice);
-        assertThat(edges).hasSize(1);
-        assertThat(edges.get(0).targetEntityId()).isEqualTo(project);
-        assertThat(edges.get(0).relationType()).isEqualTo(RelationType.MANAGES);
-        assertThat(edges.get(0).weight()).isEqualTo(1.0f);
-    }
-
-    @Test
-    void duplicateRelationStrengthensWeight() {
-        int alice = graph.addEntity("Alice", EntityType.PERSON);
-        int project = graph.addEntity("Project Alpha", EntityType.PROJECT);
-
-        graph.addRelation(alice, project, RelationType.MANAGES);
-        graph.addRelation(alice, project, RelationType.MANAGES);
-
-        List<EntityGraph.EntityEdge> edges = graph.edges(alice);
-        assertThat(edges).hasSize(1);
-        assertThat(edges.get(0).weight()).isEqualTo(2.0f);
-    }
-
-    @Test
-    void linkEntityToMemory() {
-        int alice = graph.addEntity("Alice", EntityType.PERSON);
-
-        graph.linkEntityToMemory(alice, 42);
-        graph.linkEntityToMemory(alice, 99);
-        graph.linkEntityToMemory(alice, 42); // duplicate: ignored
-
-        int[] memories = graph.memoriesForEntity(alice);
-        assertThat(memories).containsExactly(42, 99);
-    }
-
-    @Test
-    void maxMemoryRefsEnforced() {
-        int alice = graph.addEntity("Alice", EntityType.PERSON);
-
-        for (int i = 0; i < EntityGraph.MAX_MEMORY_REFS + 5; i++) {
-            graph.linkEntityToMemory(alice, i);
-        }
-
-        int[] memories = graph.memoriesForEntity(alice);
-        assertThat(memories).hasSize(EntityGraph.MAX_MEMORY_REFS);
-    }
-
-    @Test
-    void bfsTraversal() {
-        int alice = graph.addEntity("Alice", EntityType.PERSON);
-        int project = graph.addEntity("Project Alpha", EntityType.PROJECT);
-        int bob = graph.addEntity("Bob", EntityType.PERSON);
-
-        graph.addRelation(alice, project, RelationType.MANAGES);
-        graph.addRelation(project, bob, RelationType.PART_OF);
-
-        // Traverse from alice: should reach project (hop 1) and bob (hop 2)
-        var results = graph.traverse(alice, null, 2);
-        assertThat(results).hasSize(2);
-        assertThat(results.get(0).entityId()).isEqualTo(project);
-        assertThat(results.get(0).hopDistance()).isEqualTo(1);
-        assertThat(results.get(1).entityId()).isEqualTo(bob);
-        assertThat(results.get(1).hopDistance()).isEqualTo(2);
-    }
-
-    @Test
-    void bfsTraversalWithFilter() {
-        int alice = graph.addEntity("Alice", EntityType.PERSON);
-        int project = graph.addEntity("Project Alpha", EntityType.PROJECT);
-        int bob = graph.addEntity("Bob", EntityType.PERSON);
-
-        graph.addRelation(alice, project, RelationType.MANAGES);
-        graph.addRelation(alice, bob, RelationType.RELATED_TO);
-
-        // Filter: only MANAGES edges
-        var results = graph.traverse(alice, RelationType.MANAGES, 2);
-        assertThat(results).hasSize(1);
-        assertThat(results.get(0).entityId()).isEqualTo(project);
-    }
-
-    @Test
-    void collectMemories() {
-        int alice = graph.addEntity("Alice", EntityType.PERSON);
-        int project = graph.addEntity("Project Alpha", EntityType.PROJECT);
-
-        graph.linkEntityToMemory(alice, 10);
-        graph.linkEntityToMemory(project, 20);
-        graph.addRelation(alice, project, RelationType.MANAGES);
-
-        Set<Integer> memories = graph.collectMemories(alice, null, 2);
-        assertThat(memories).containsExactlyInAnyOrder(10, 20);
-    }
-
-    @Test
-    void saveAndLoadPreservesGraph() {
-        int alice = graph.addEntity("Alice", EntityType.PERSON);
-        int project = graph.addEntity("Project Alpha", EntityType.PROJECT);
-        graph.addRelation(alice, project, RelationType.MANAGES);
-        graph.linkEntityToMemory(alice, 42);
-
-        Path file = tempDir.resolve("test.entity");
-        graph.save(file);
-        graph.close();
-
-        graph = EntityGraph.load(file, 100, 500);
-        assertThat(graph.entityCount()).isEqualTo(2);
-        assertThat(graph.findEntity("alice")).isEqualTo(0);
-        assertThat(graph.findEntity("project alpha")).isEqualTo(1);
-
-        // Relations preserved
-        var edges = graph.edges(0);
-        assertThat(edges).hasSize(1);
-        assertThat(edges.get(0).relationType()).isEqualTo(RelationType.MANAGES);
-
-        // Memory refs preserved
-        int[] memories = graph.memoriesForEntity(0);
-        assertThat(memories).containsExactly(42);
-    }
-
-    @Test
-    void loadNonExistentFileCreatesNew() {
-        Path file = tempDir.resolve("nonexistent.entity");
-        graph.close();
-        graph = EntityGraph.load(file, 50, 200);
-
-        assertThat(graph.entityCount()).isZero();
-    }
-
-    @Test
-    void boundsCheckDoesNotCrash() {
-        graph.addRelation(-1, 0, RelationType.OTHER); // ignored
-        graph.addRelation(0, 500, RelationType.OTHER); // ignored
-        graph.linkEntityToMemory(-1, 0); // ignored
-        assertThat(graph.edges(-1)).isEmpty();
-        assertThat(graph.memoriesForEntity(-1)).isEmpty();
-        assertThat(graph.entityType(-1)).isEqualTo(EntityType.OTHER);
-    }
-
-    @Test
-    void nameIndexSnapshot() {
-        graph.addEntity("Alice", EntityType.PERSON);
-        graph.addEntity("Bob", EntityType.PERSON);
-
-        var snapshot = graph.nameIndex();
-        assertThat(snapshot).containsKeys("alice", "bob");
-    }
-}
diff --git a/spector-memory/src/test/java/com/spectrayan/spector/memory/graph/LlmEntityExtractorTest.java b/spector-memory/src/test/java/com/spectrayan/spector/memory/graph/LlmEntityExtractorTest.java
deleted file mode 100644
index f49cf82..0000000
--- a/spector-memory/src/test/java/com/spectrayan/spector/memory/graph/LlmEntityExtractorTest.java
+++ /dev/null
@@ -1,227 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.graph;
-
-import com.spectrayan.spector.embed.TextGenerationProvider;
-
-import org.junit.jupiter.api.Test;
-
-import java.util.List;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-/**
- * Tests for LlmEntityExtractor response parsing and error handling.
- */
-class LlmEntityExtractorTest {
-
-    @Test
-    void parsesSimpleResponse() {
-        String response = """
-                ENTITY: Alice | PERSON
-                ENTITY: Project Alpha | PROJECT
-                RELATION: Alice | MANAGES | Project Alpha
-                """;
-
-        TextGenerationProvider mockProvider = new TextGenerationProvider() {
-            @Override
-            public String generate(String prompt) {
-                return response;
-            }
-            @Override
-            public boolean isAvailable() {
-                return true;
-            }
-            @Override
-            public String modelName() {
-                return "test-mock";
-            }
-        };
-
-        LlmEntityExtractor extractor = new LlmEntityExtractor(mockProvider);
-        List<ExtractedEntity> entities = extractor.extract("test-id", "Alice manages Project Alpha");
-
-        assertThat(entities).hasSize(2);
-        assertThat(entities.get(0).name()).isEqualTo("Alice");
-        assertThat(entities.get(0).type()).isEqualTo(EntityType.PERSON);
-        assertThat(entities.get(0).relations()).hasSize(1);
-        assertThat(entities.get(0).relations().get(0).relationType()).isEqualTo(RelationType.MANAGES);
-        assertThat(entities.get(0).relations().get(0).targetEntityName()).isEqualTo("Project Alpha");
-
-        assertThat(entities.get(1).name()).isEqualTo("Project Alpha");
-        assertThat(entities.get(1).type()).isEqualTo(EntityType.PROJECT);
-    }
-
-    @Test
-    void handlesEmptyResponse() {
-        TextGenerationProvider mockProvider = new TextGenerationProvider() {
-            @Override
-            public String generate(String prompt) {
-                return "";
-            }
-            @Override
-            public boolean isAvailable() {
-                return true;
-            }
-            @Override
-            public String modelName() {
-                return "test-mock";
-            }
-        };
-
-        LlmEntityExtractor extractor = new LlmEntityExtractor(mockProvider);
-        List<ExtractedEntity> entities = extractor.extract("test-id", "some text");
-
-        assertThat(entities).isEmpty();
-    }
-
-    @Test
-    void handlesNullProvider() {
-        LlmEntityExtractor extractor = new LlmEntityExtractor(null);
-
-        assertThat(extractor.isAvailable()).isFalse();
-        assertThat(extractor.extract("test", "text")).isEmpty();
-    }
-
-    @Test
-    void handlesUnavailableProvider() {
-        TextGenerationProvider mockProvider = new TextGenerationProvider() {
-            @Override
-            public String generate(String prompt) {
-                throw new RuntimeException("Should not be called");
-            }
-            @Override
-            public boolean isAvailable() {
-                return false;
-            }
-            @Override
-            public String modelName() {
-                return "test-mock";
-            }
-        };
-
-        LlmEntityExtractor extractor = new LlmEntityExtractor(mockProvider);
-        assertThat(extractor.extract("test", "text")).isEmpty();
-    }
-
-    @Test
-    void handlesProviderException() {
-        TextGenerationProvider mockProvider = new TextGenerationProvider() {
-            @Override
-            public String generate(String prompt) {
-                throw new RuntimeException("API failure");
-            }
-            @Override
-            public boolean isAvailable() {
-                return true;
-            }
-            @Override
-            public String modelName() {
-                return "test-mock";
-            }
-        };
-
-        LlmEntityExtractor extractor = new LlmEntityExtractor(mockProvider);
-        List<ExtractedEntity> entities = extractor.extract("test-id", "text");
-
-        assertThat(entities).isEmpty(); // graceful degradation
-    }
-
-    @Test
-    void parsesUnknownEntityType() {
-        String response = "ENTITY: Widget | GADGET\n";
-
-        TextGenerationProvider mockProvider = new TextGenerationProvider() {
-            @Override
-            public String generate(String prompt) {
-                return response;
-            }
-            @Override
-            public boolean isAvailable() {
-                return true;
-            }
-            @Override
-            public String modelName() {
-                return "test-mock";
-            }
-        };
-
-        LlmEntityExtractor extractor = new LlmEntityExtractor(mockProvider);
-        List<ExtractedEntity> entities = extractor.extract("test", "text");
-
-        assertThat(entities).hasSize(1);
-        assertThat(entities.get(0).type()).isEqualTo(EntityType.OTHER);
-    }
-
-    @Test
-    void respectsMaxEntitiesLimit() {
-        StringBuilder response = new StringBuilder();
-        for (int i = 0; i < 20; i++) {
-            response.append("ENTITY: Entity" + i + " | PERSON\n");
-        }
-
-        TextGenerationProvider mockProvider = new TextGenerationProvider() {
-            @Override
-            public String generate(String prompt) {
-                return response.toString();
-            }
-            @Override
-            public boolean isAvailable() {
-                return true;
-            }
-            @Override
-            public String modelName() {
-                return "test-mock";
-            }
-        };
-
-        LlmEntityExtractor extractor = new LlmEntityExtractor(mockProvider, 5, 10);
-        List<ExtractedEntity> entities = extractor.extract("test", "text");
-
-        assertThat(entities).hasSize(5);
-    }
-
-    @Test
-    void multipleRelationsForSameEntity() {
-        String response = """
-                ENTITY: Alice | PERSON
-                ENTITY: Bob | PERSON
-                ENTITY: Acme | ORGANIZATION
-                RELATION: Alice | MANAGES | Bob
-                RELATION: Alice | WORKS_ON | Acme
-                """;
-
-        TextGenerationProvider mockProvider = new TextGenerationProvider() {
-            @Override
-            public String generate(String prompt) {
-                return response;
-            }
-            @Override
-            public boolean isAvailable() {
-                return true;
-            }
-            @Override
-            public String modelName() {
-                return "test-mock";
-            }
-        };
-
-        LlmEntityExtractor extractor = new LlmEntityExtractor(mockProvider);
-        List<ExtractedEntity> entities = extractor.extract("test", "text");
-
-        assertThat(entities).hasSize(3);
-        // Alice should have 2 relations
-        var alice = entities.get(0);
-        assertThat(alice.relations()).hasSize(2);
-    }
-}
diff --git a/spector-memory/src/test/java/com/spectrayan/spector/memory/graph/NoOpEntityExtractorTest.java b/spector-memory/src/test/java/com/spectrayan/spector/memory/graph/NoOpEntityExtractorTest.java
deleted file mode 100644
index df7e0e7..0000000
--- a/spector-memory/src/test/java/com/spectrayan/spector/memory/graph/NoOpEntityExtractorTest.java
+++ /dev/null
@@ -1,41 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.graph;
-
-import org.junit.jupiter.api.Test;
-
-import java.util.List;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-/**
- * Tests for NoOpEntityExtractor.
- */
-class NoOpEntityExtractorTest {
-
-    @Test
-    void extractReturnsEmpty() {
-        List<ExtractedEntity> result = NoOpEntityExtractor.INSTANCE.extract("id", "some text");
-        assertThat(result).isEmpty();
-    }
-
-    @Test
-    void isAvailableReturnsTrue() {
-        assertThat(NoOpEntityExtractor.INSTANCE.isAvailable()).isTrue();
-    }
-
-    @Test
-    void singletonInstance() {
-        assertThat(NoOpEntityExtractor.INSTANCE).isSameAs(NoOpEntityExtractor.INSTANCE);
-    }
-}
diff --git a/spector-memory/src/test/java/com/spectrayan/spector/memory/habituation/HabituationPenaltyTest.java b/spector-memory/src/test/java/com/spectrayan/spector/memory/habituation/HabituationPenaltyTest.java
deleted file mode 100644
index 741b5e9..0000000
--- a/spector-memory/src/test/java/com/spectrayan/spector/memory/habituation/HabituationPenaltyTest.java
+++ /dev/null
@@ -1,84 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.habituation;
-
-import org.junit.jupiter.api.Test;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.within;
-
-class HabituationPenaltyTest {
-
-    @Test
-    void firstReturnGetsNoPenalty() {
-        var hab = new HabituationPenalty(0.2f);
-        float penalty = hab.recordAndComputePenalty("m1");
-        assertThat(penalty).isCloseTo(1.0f, within(0.001f));
-    }
-
-    @Test
-    void repeatedReturnsDecreasePenalty() {
-        var hab = new HabituationPenalty(0.2f);
-        float p1 = hab.recordAndComputePenalty("m1"); // 1st: 1.0
-        float p2 = hab.recordAndComputePenalty("m1"); // 2nd: 1/(1 + 1*0.2) ≈ 0.833
-        float p3 = hab.recordAndComputePenalty("m1"); // 3rd: 1/(1 + 2*0.2) ≈ 0.714
-
-        assertThat(p2).isLessThan(p1);
-        assertThat(p3).isLessThan(p2);
-    }
-
-    @Test
-    void differentMemoriesTrackIndependently() {
-        var hab = new HabituationPenalty();
-        hab.recordAndComputePenalty("m1");
-        hab.recordAndComputePenalty("m1");
-        hab.recordAndComputePenalty("m1");
-
-        float m2Penalty = hab.recordAndComputePenalty("m2");
-        assertThat(m2Penalty).isCloseTo(1.0f, within(0.001f)); // m2 is fresh
-    }
-
-    @Test
-    void currentPenaltyWithoutRecording() {
-        var hab = new HabituationPenalty();
-        assertThat(hab.currentPenalty("m1")).isCloseTo(1.0f, within(0.001f)); // never seen
-
-        hab.recordAndComputePenalty("m1");
-        hab.recordAndComputePenalty("m1");
-        float penalty = hab.currentPenalty("m1");
-        assertThat(penalty).isLessThan(1.0f);
-    }
-
-    @Test
-    void clearResetsAll() {
-        var hab = new HabituationPenalty();
-        hab.recordAndComputePenalty("m1");
-        hab.recordAndComputePenalty("m2");
-        hab.clear();
-        assertThat(hab.trackedCount()).isZero();
-    }
-
-    @Test
-    void highDecayRatePenalizesMoreAggressively() {
-        var slow = new HabituationPenalty(0.1f);
-        var fast = new HabituationPenalty(0.5f);
-
-        // After 5 returns
-        for (int i = 0; i < 5; i++) {
-            slow.recordAndComputePenalty("m1");
-            fast.recordAndComputePenalty("m1");
-        }
-
-        assertThat(fast.currentPenalty("m1")).isLessThan(slow.currentPenalty("m1"));
-    }
-}
diff --git a/spector-memory/src/test/java/com/spectrayan/spector/memory/habituation/InhibitionOfReturnTest.java b/spector-memory/src/test/java/com/spectrayan/spector/memory/habituation/InhibitionOfReturnTest.java
deleted file mode 100644
index 706146e..0000000
--- a/spector-memory/src/test/java/com/spectrayan/spector/memory/habituation/InhibitionOfReturnTest.java
+++ /dev/null
@@ -1,126 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.habituation;
-
-import org.junit.jupiter.api.Test;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-/**
- * Tests for Inhibition of Return (IOR) — TTL-based refractory period.
- *
- * <p>Validates that recently recalled memories receive a penalty that
- * linearly recovers from {@code inhibitionFloor} to 1.0 over the TTL.</p>
- */
-class InhibitionOfReturnTest {
-
-    @Test
-    void noRecallHistory_returnsFullMultiplier() {
-        HabituationPenalty penalty = new HabituationPenalty(0.2f, 300_000L, 0.1f);
-        float result = penalty.computeInhibitionOfReturn("unknown-memory", System.currentTimeMillis());
-        assertThat(result).isEqualTo(1.0f);
-    }
-
-    @Test
-    void justRecalled_returnsFloor() {
-        HabituationPenalty penalty = new HabituationPenalty(0.2f, 300_000L, 0.1f);
-        long now = System.currentTimeMillis();
-
-        penalty.recordRecall("mem-1", now);
-        float result = penalty.computeInhibitionOfReturn("mem-1", now);
-
-        assertThat(result).isEqualTo(0.1f);
-    }
-
-    @Test
-    void halfwayThroughTtl_returnsHalfRecovery() {
-        HabituationPenalty penalty = new HabituationPenalty(0.2f, 300_000L, 0.1f);
-        long recallTime = 1_000_000L;
-        long halfwayTime = recallTime + 150_000L; // 2.5 minutes into 5 minute TTL
-
-        penalty.recordRecall("mem-1", recallTime);
-        float result = penalty.computeInhibitionOfReturn("mem-1", halfwayTime);
-
-        // Expected: 0.1 + 0.9 * (150_000 / 300_000) = 0.1 + 0.45 = 0.55
-        assertThat(result).isCloseTo(0.55f, org.assertj.core.data.Offset.offset(0.01f));
-    }
-
-    @Test
-    void afterTtlExpires_returnsFullAndCleansUp() {
-        HabituationPenalty penalty = new HabituationPenalty(0.2f, 300_000L, 0.1f);
-        long recallTime = 1_000_000L;
-        long afterTtl = recallTime + 300_001L; // just past 5 minutes
-
-        penalty.recordRecall("mem-1", recallTime);
-        assertThat(penalty.iorTrackedCount()).isEqualTo(1);
-
-        float result = penalty.computeInhibitionOfReturn("mem-1", afterTtl);
-
-        assertThat(result).isEqualTo(1.0f);
-        assertThat(penalty.iorTrackedCount()).isEqualTo(0); // expired entry cleaned up
-    }
-
-    @Test
-    void customTtlAndFloor_respected() {
-        // Short TTL (10 seconds), higher floor (0.3)
-        HabituationPenalty penalty = new HabituationPenalty(0.2f, 10_000L, 0.3f);
-        long now = 1_000_000L;
-
-        penalty.recordRecall("mem-1", now);
-
-        // Immediately after: should be 0.3 (the floor)
-        assertThat(penalty.computeInhibitionOfReturn("mem-1", now)).isEqualTo(0.3f);
-
-        // 5 seconds in (halfway): 0.3 + 0.7 * 0.5 = 0.65
-        float midway = penalty.computeInhibitionOfReturn("mem-1", now + 5_000L);
-        assertThat(midway).isCloseTo(0.65f, org.assertj.core.data.Offset.offset(0.01f));
-
-        // After TTL: fully recovered
-        assertThat(penalty.computeInhibitionOfReturn("mem-1", now + 10_001L)).isEqualTo(1.0f);
-    }
-
-    @Test
-    void clearResetsIorTimestamps() {
-        HabituationPenalty penalty = new HabituationPenalty();
-        long now = System.currentTimeMillis();
-
-        penalty.recordRecall("mem-1", now);
-        penalty.recordRecall("mem-2", now);
-        assertThat(penalty.iorTrackedCount()).isEqualTo(2);
-
-        penalty.clear();
-        assertThat(penalty.iorTrackedCount()).isEqualTo(0);
-
-        // After clear, no penalty applied
-        assertThat(penalty.computeInhibitionOfReturn("mem-1", now)).isEqualTo(1.0f);
-    }
-
-    @Test
-    void multipleMemories_trackedIndependently() {
-        HabituationPenalty penalty = new HabituationPenalty(0.2f, 300_000L, 0.1f);
-        long t0 = 1_000_000L;
-
-        penalty.recordRecall("mem-1", t0);
-        penalty.recordRecall("mem-2", t0 + 100_000L); // recalled 100s later
-
-        // At t0 + 150_000 (2.5 min):
-        // mem-1: 150s into 300s = 0.1 + 0.9*(150/300) = 0.55
-        // mem-2: 50s into 300s  = 0.1 + 0.9*(50/300) = 0.25
-        long queryTime = t0 + 150_000L;
-        float mem1Penalty = penalty.computeInhibitionOfReturn("mem-1", queryTime);
-        float mem2Penalty = penalty.computeInhibitionOfReturn("mem-2", queryTime);
-
-        assertThat(mem1Penalty).isCloseTo(0.55f, org.assertj.core.data.Offset.offset(0.01f));
-        assertThat(mem2Penalty).isCloseTo(0.25f, org.assertj.core.data.Offset.offset(0.01f));
-    }
-}
diff --git a/spector-memory/src/test/java/com/spectrayan/spector/memory/hebbian/CoActivationTrackerPersistenceTest.java b/spector-memory/src/test/java/com/spectrayan/spector/memory/hebbian/CoActivationTrackerPersistenceTest.java
deleted file mode 100644
index 6f746d7..0000000
--- a/spector-memory/src/test/java/com/spectrayan/spector/memory/hebbian/CoActivationTrackerPersistenceTest.java
+++ /dev/null
@@ -1,138 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.hebbian;
-
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.io.TempDir;
-
-import java.nio.file.Path;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-/**
- * Tests for {@link CoActivationTracker} off-heap persistence (save/load).
- */
-class CoActivationTrackerPersistenceTest {
-
-    @TempDir
-    Path tempDir;
-
-    @Test
-    void saveAndLoadPreservesCoActivations() {
-        Path file = tempDir.resolve("coax.bin");
-
-        try (var tracker = new CoActivationTracker(1000, 2000)) {
-            tracker.recordCoActivation("java", "performance");
-            tracker.recordCoActivation("java", "performance");
-            tracker.recordCoActivation("java", "gc");
-            assertThat(tracker.pairCount()).isEqualTo(2);
-
-            tracker.save(file);
-        }
-
-        try (var loaded = CoActivationTracker.load(file, 1000, 2000)) {
-            assertThat(loaded.pairCount()).isEqualTo(2);
-            assertThat(loaded.getCoActivation("java", "performance")).isEqualTo(2);
-            assertThat(loaded.getCoActivation("java", "gc")).isEqualTo(1);
-            assertThat(loaded.getCoActivation("java", "python")).isZero();
-        }
-    }
-
-    @Test
-    void saveAndLoadPreservesStdpEdges() {
-        Path file = tempDir.resolve("coax-stdp.bin");
-
-        try (var tracker = new CoActivationTracker(1000, 2000)) {
-            tracker.recordSequentialActivation("java", "gc", 1000L, 2000L);
-            assertThat(tracker.edgeCount()).isGreaterThan(0);
-
-            var edge = tracker.getEdge("java", "gc");
-            assertThat(edge).isNotNull();
-            float originalWeight = edge.weight();
-
-            tracker.save(file);
-
-            try (var loaded = CoActivationTracker.load(file, 1000, 2000)) {
-                assertThat(loaded.edgeCount()).isEqualTo(tracker.edgeCount());
-                var loadedEdge = loaded.getEdge("java", "gc");
-                assertThat(loadedEdge).isNotNull();
-                assertThat(loadedEdge.weight()).isEqualTo(originalWeight);
-                assertThat(loadedEdge.activationCount()).isEqualTo(1);
-            }
-        }
-    }
-
-    @Test
-    void loadMissingFileCreatesNew() {
-        Path missing = tempDir.resolve("nonexistent.bin");
-        try (var tracker = CoActivationTracker.load(missing, 500, 1000)) {
-            assertThat(tracker.pairCount()).isZero();
-            assertThat(tracker.edgeCount()).isZero();
-        }
-    }
-
-    @Test
-    void saveAndLoadPreservesAssociatedTags() {
-        Path file = tempDir.resolve("coax-assoc.bin");
-
-        try (var tracker = new CoActivationTracker(1000, 2000)) {
-            for (int i = 0; i < 5; i++) tracker.recordCoActivation("java", "performance");
-            for (int i = 0; i < 3; i++) tracker.recordCoActivation("java", "gc");
-            tracker.recordCoActivation("java", "concurrency");
-
-            tracker.save(file);
-        }
-
-        try (var loaded = CoActivationTracker.load(file, 1000, 2000)) {
-            var associated = loaded.getAssociatedTags("java", 3);
-            assertThat(associated).hasSize(3);
-            assertThat(associated.getFirst()).isEqualTo("performance");
-        }
-    }
-
-    @Test
-    void resetClearsOffHeapData() {
-        try (var tracker = new CoActivationTracker(1000, 2000)) {
-            tracker.recordCoActivation("java", "python", "rust");
-            assertThat(tracker.pairCount()).isGreaterThan(0);
-
-            tracker.reset();
-            assertThat(tracker.pairCount()).isZero();
-            assertThat(tracker.edgeCount()).isZero();
-        }
-    }
-
-    @Test
-    void canonicalPairOrderPreserved() {
-        try (var tracker = new CoActivationTracker(1000, 2000)) {
-            tracker.recordCoActivation("java", "python");
-            // Reverse order should access same pair
-            assertThat(tracker.getCoActivation("python", "java")).isEqualTo(1);
-        }
-    }
-
-    @Test
-    void predictiveStrengthFromStdp() {
-        try (var tracker = new CoActivationTracker(1000, 2000)) {
-            tracker.recordSequentialActivation("search", "relevance", 1000L, 1500L);
-
-            float strength = tracker.getPredictiveStrength(
-                    java.util.List.of("search"), new String[]{"relevance"});
-            assertThat(strength).isGreaterThan(0.0f);
-
-            float avgStrength = tracker.getAveragePredictiveStrength(
-                    java.util.List.of("search"), new String[]{"relevance"});
-            assertThat(avgStrength).isGreaterThan(0.0f);
-        }
-    }
-}
diff --git a/spector-memory/src/test/java/com/spectrayan/spector/memory/hebbian/CoActivationTrackerTest.java b/spector-memory/src/test/java/com/spectrayan/spector/memory/hebbian/CoActivationTrackerTest.java
deleted file mode 100644
index 0c94e2a..0000000
--- a/spector-memory/src/test/java/com/spectrayan/spector/memory/hebbian/CoActivationTrackerTest.java
+++ /dev/null
@@ -1,73 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.hebbian;
-
-import org.junit.jupiter.api.Test;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-class CoActivationTrackerTest {
-
-    @Test
-    void initialCountIsZero() {
-        var tracker = new CoActivationTracker();
-        assertThat(tracker.getCoActivation("java", "python")).isZero();
-    }
-
-    @Test
-    void recordCoActivationIncrements() {
-        var tracker = new CoActivationTracker();
-        tracker.recordCoActivation("java", "performance");
-        assertThat(tracker.getCoActivation("java", "performance")).isEqualTo(1);
-
-        tracker.recordCoActivation("java", "performance");
-        assertThat(tracker.getCoActivation("java", "performance")).isEqualTo(2);
-    }
-
-    @Test
-    void pairKeyIsCanonical() {
-        var tracker = new CoActivationTracker();
-        tracker.recordCoActivation("java", "python");
-        // Reverse order should access same pair
-        assertThat(tracker.getCoActivation("python", "java")).isEqualTo(1);
-    }
-
-    @Test
-    void getAssociatedTagsReturnsSorted() {
-        var tracker = new CoActivationTracker();
-        for (int i = 0; i < 5; i++) tracker.recordCoActivation("java", "performance");
-        for (int i = 0; i < 3; i++) tracker.recordCoActivation("java", "gc");
-        tracker.recordCoActivation("java", "concurrency");
-
-        var associated = tracker.getAssociatedTags("java", 3);
-        assertThat(associated).hasSize(3);
-        assertThat(associated.getFirst()).isEqualTo("performance"); // highest count
-    }
-
-    @Test
-    void singleTagDoesNotRecord() {
-        var tracker = new CoActivationTracker();
-        tracker.recordCoActivation("java");
-        assertThat(tracker.pairCount()).isZero();
-    }
-
-    @Test
-    void resetClearsAll() {
-        var tracker = new CoActivationTracker();
-        tracker.recordCoActivation("java", "python", "rust");
-        assertThat(tracker.pairCount()).isGreaterThan(0);
-
-        tracker.reset();
-        assertThat(tracker.pairCount()).isZero();
-    }
-}
diff --git a/spector-memory/src/test/java/com/spectrayan/spector/memory/hebbian/HebbianGraphPersistenceTest.java b/spector-memory/src/test/java/com/spectrayan/spector/memory/hebbian/HebbianGraphPersistenceTest.java
deleted file mode 100644
index 897fe8e..0000000
--- a/spector-memory/src/test/java/com/spectrayan/spector/memory/hebbian/HebbianGraphPersistenceTest.java
+++ /dev/null
@@ -1,167 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.hebbian;
-
-import org.junit.jupiter.api.AfterEach;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.io.TempDir;
-
-import java.nio.file.Path;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-/**
- * Tests for HebbianGraph persistence (save/load).
- */
-class HebbianGraphPersistenceTest {
-
-    @TempDir
-    Path tempDir;
-
-    private HebbianGraph graph;
-
-    @BeforeEach
-    void setUp() {
-        graph = new HebbianGraph(100);
-    }
-
-    @AfterEach
-    void tearDown() {
-        graph.close();
-    }
-
-    @Test
-    void saveAndLoadPreservesEdges() {
-        graph.strengthen(0, 1, 2.0f);
-        graph.strengthen(0, 2, 5.0f);
-        graph.strengthen(3, 4, 1.0f);
-
-        Path file = tempDir.resolve("test.graph");
-        graph.save(file);
-        graph.close();
-
-        // Load
-        graph = HebbianGraph.load(file, 100);
-        assertThat(graph.degree(0)).isEqualTo(2);
-        assertThat(graph.degree(1)).isEqualTo(1);
-        assertThat(graph.degree(3)).isEqualTo(1);
-        assertThat(graph.degree(4)).isEqualTo(1);
-
-        // Verify weights preserved
-        var neighbors = graph.neighbors(0);
-        assertThat(neighbors).hasSize(2);
-        assertThat(neighbors.get(0).weight()).isEqualTo(5.0f); // node 2 (strongest)
-        assertThat(neighbors.get(1).weight()).isEqualTo(2.0f); // node 1
-    }
-
-    @Test
-    void loadNonExistentFileCreatesNew() {
-        Path file = tempDir.resolve("nonexistent.graph");
-        graph.close();
-        graph = HebbianGraph.load(file, 50);
-
-        assertThat(graph.capacity()).isEqualTo(50);
-        assertThat(graph.degree(0)).isZero();
-    }
-
-    @Test
-    void loadCorruptedFileCreatesNew() throws Exception {
-        // Write garbage to file
-        Path file = tempDir.resolve("corrupt.graph");
-        java.nio.file.Files.write(file, new byte[]{0, 1, 2, 3});
-
-        graph.close();
-        graph = HebbianGraph.load(file, 75);
-        assertThat(graph.capacity()).isEqualTo(75);
-        assertThat(graph.degree(0)).isZero();
-    }
-
-    @Test
-    void saveAndLoadPreservesCapacity() {
-        Path file = tempDir.resolve("cap.graph");
-        graph.save(file);
-        graph.close();
-
-        graph = HebbianGraph.load(file, 200); // defaultCapacity ignored when file exists
-        assertThat(graph.capacity()).isEqualTo(100); // original capacity preserved
-    }
-
-    @Test
-    void saveAndLoadRoundTripWithDecayedEdges() {
-        // Add edges and decay
-        graph.strengthen(0, 1, 1.0f);
-        graph.strengthen(0, 2, 0.001f); // very weak edge
-        graph.decayEdges(0.5f);
-
-        Path file = tempDir.resolve("decay.graph");
-        graph.save(file);
-        graph.close();
-
-        graph = HebbianGraph.load(file, 100);
-        // Edge 0→2 should have been removed by decay (0.001 × 0.5 = 0.0005 < 0.01 threshold)
-        assertThat(graph.degree(0)).isEqualTo(1);
-        // Edge 0→1 should be preserved but decayed
-        var neighbors = graph.neighbors(0);
-        assertThat(neighbors).hasSize(1);
-        assertThat(neighbors.get(0).weight()).isEqualTo(0.5f);
-    }
-
-    @Test
-    void totalEdgesCorrect() {
-        graph.strengthen(0, 1, 1.0f);
-        graph.strengthen(2, 3, 1.0f);
-        // Each strengthen creates 2 edges (bidirectional)
-        assertThat(graph.totalEdges()).isEqualTo(4);
-    }
-
-    @Test
-    void savingCreatesParentDirectories() {
-        Path nested = tempDir.resolve("a/b/c/test.graph");
-        graph.strengthen(0, 1, 1.0f);
-        graph.save(nested);
-        graph.close();
-
-        graph = HebbianGraph.load(nested, 100);
-        assertThat(graph.degree(0)).isEqualTo(1);
-    }
-
-    @Test
-    void spreadingActivationPersistence() {
-        // Build a chain: 0 ↔ 1 ↔ 2
-        graph.strengthen(0, 1, 3.0f);
-        graph.strengthen(1, 2, 2.0f);
-
-        Path file = tempDir.resolve("spread.graph");
-        graph.save(file);
-        graph.close();
-
-        graph = HebbianGraph.load(file, 100);
-        // Spreading activation from 0 should reach 2
-        var activated = graph.activateNeighbors(0, 2);
-        assertThat(activated).hasSizeGreaterThanOrEqualTo(2);
-        // Node 1 should be first (direct, stronger)
-        assertThat(activated.get(0).neighborIndex()).isEqualTo(1);
-    }
-
-    @Test
-    void boundsCheckDoesNotCrash() {
-        graph.strengthen(-1, 0, 1.0f); // out of bounds: ignored
-        graph.strengthen(0, 1000, 1.0f); // out of bounds: ignored
-        graph.strengthen(0, 0, 1.0f); // self-loop: ignored
-        assertThat(graph.degree(0)).isZero();
-        assertThat(graph.degree(-1)).isZero();
-        assertThat(graph.degree(1000)).isZero();
-        assertThat(graph.neighbors(-1)).isEmpty();
-    }
-}
diff --git a/spector-memory/src/test/java/com/spectrayan/spector/memory/hebbian/HebbianGraphTest.java b/spector-memory/src/test/java/com/spectrayan/spector/memory/hebbian/HebbianGraphTest.java
deleted file mode 100644
index 650819d..0000000
--- a/spector-memory/src/test/java/com/spectrayan/spector/memory/hebbian/HebbianGraphTest.java
+++ /dev/null
@@ -1,86 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.hebbian;
-
-import org.junit.jupiter.api.AfterEach;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-class HebbianGraphTest {
-
-    private HebbianGraph graph;
-
-    @BeforeEach
-    void setUp() {
-        graph = new HebbianGraph(100);
-    }
-
-    @AfterEach
-    void tearDown() {
-        graph.close();
-    }
-
-    @Test
-    void initialDegreeIsZero() {
-        assertThat(graph.degree(0)).isZero();
-    }
-
-    @Test
-    void strengthenCreatesBidirectionalEdge() {
-        graph.strengthen(0, 1, 1.0f);
-        assertThat(graph.degree(0)).isEqualTo(1);
-        assertThat(graph.degree(1)).isEqualTo(1);
-    }
-
-    @Test
-    void repeatedStrengthenIncreasesWeight() {
-        graph.strengthen(0, 1, 1.0f);
-        graph.strengthen(0, 1, 2.0f);
-
-        var neighbors = graph.neighbors(0);
-        assertThat(neighbors).hasSize(1);
-        assertThat(neighbors.getFirst().weight()).isEqualTo(3.0f);
-    }
-
-    @Test
-    void neighborsSortedByDescendingWeight() {
-        graph.strengthen(0, 1, 1.0f);
-        graph.strengthen(0, 2, 5.0f);
-        graph.strengthen(0, 3, 3.0f);
-
-        var neighbors = graph.neighbors(0);
-        assertThat(neighbors).hasSize(3);
-        assertThat(neighbors.get(0).weight()).isEqualTo(5.0f); // node 2
-        assertThat(neighbors.get(1).weight()).isEqualTo(3.0f); // node 3
-        assertThat(neighbors.get(2).weight()).isEqualTo(1.0f); // node 1
-    }
-
-    @Test
-    void maxDegreeEnforced() {
-        // Fill node 0 to MAX_DEGREE
-        for (int i = 1; i <= HebbianGraph.MAX_DEGREE; i++) {
-            graph.strengthen(0, i, 1.0f);
-        }
-        assertThat(graph.degree(0)).isEqualTo(HebbianGraph.MAX_DEGREE);
-
-        // Adding one more with higher weight should replace weakest
-        graph.strengthen(0, HebbianGraph.MAX_DEGREE + 1, 10.0f);
-        assertThat(graph.degree(0)).isEqualTo(HebbianGraph.MAX_DEGREE);
-
-        // The new strong edge should be present
-        var neighbors = graph.neighbors(0);
-        assertThat(neighbors.getFirst().weight()).isEqualTo(10.0f);
-    }
-}
diff --git a/spector-memory/src/test/java/com/spectrayan/spector/memory/hebbian/StdpTest.java b/spector-memory/src/test/java/com/spectrayan/spector/memory/hebbian/StdpTest.java
deleted file mode 100644
index de10eb2..0000000
--- a/spector-memory/src/test/java/com/spectrayan/spector/memory/hebbian/StdpTest.java
+++ /dev/null
@@ -1,185 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.hebbian;
-
-import org.junit.jupiter.api.Test;
-
-import java.util.List;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-/**
- * Tests for STDP (Spike-Timing-Dependent Plasticity) in {@link CoActivationTracker}.
- */
-class StdpTest {
-
-    @Test
-    void causalEdge_strengthens() {
-        var tracker = new CoActivationTracker();
-        // A fires before B → A→B edge strengthened
-        tracker.recordSequentialActivation("java", "gc", 1000L, 2000L);
-
-        var edge = tracker.getEdge("java", "gc");
-        assertThat(edge).isNotNull();
-        assertThat(edge.weight()).isGreaterThan(0.0f);
-        assertThat(edge.activationCount()).isEqualTo(1);
-    }
-
-    @Test
-    void antiCausalEdge_weakened() {
-        var tracker = new CoActivationTracker();
-        // Pre-seed with moderate weight
-        tracker.recordSequentialActivation("gc", "java", 1000L, 2000L);
-        float initialWeight = tracker.getEdge("gc", "java").weight();
-
-        // Now A→B fires, which should weaken B→A (anti-causal)
-        tracker.recordSequentialActivation("java", "gc", 3000L, 4000L);
-
-        // The gc→java edge should be weaker or stay at 0
-        var antiEdge = tracker.getEdge("gc", "java");
-        assertThat(antiEdge).isNotNull();
-        // Anti-causal: weight decrease (ΔW = -A_minus × exp(-Δt/τ))
-        // Since gc→java was already established, the anti-causal from java→gc
-        // fires a negative delta on gc→java via the reversed direction
-        // But in this case gc→java was established in step 1, and java→gc in step 2
-        // The anti-causal in step 2 is for "gc→java" direction, applied as negative
-    }
-
-    @Test
-    void repeatedCausal_strengthensProgressively() {
-        var tracker = new CoActivationTracker();
-        tracker.recordSequentialActivation("java", "gc", 1000L, 2000L);
-        float w1 = tracker.getEdge("java", "gc").weight();
-
-        tracker.recordSequentialActivation("java", "gc", 5000L, 6000L);
-        float w2 = tracker.getEdge("java", "gc").weight();
-
-        assertThat(w2).isGreaterThan(w1);
-    }
-
-    @Test
-    void closerTiming_strongerPotentiation() {
-        var tracker1 = new CoActivationTracker();
-        var tracker2 = new CoActivationTracker();
-
-        // Close temporal proximity (100ms apart)
-        tracker1.recordSequentialActivation("java", "gc", 1000L, 1100L);
-
-        // Far temporal proximity (20 seconds apart)
-        tracker2.recordSequentialActivation("java", "gc", 1000L, 21000L);
-
-        assertThat(tracker1.getEdge("java", "gc").weight())
-                .isGreaterThan(tracker2.getEdge("java", "gc").weight());
-    }
-
-    @Test
-    void selfLoop_ignored() {
-        var tracker = new CoActivationTracker();
-        tracker.recordSequentialActivation("java", "java", 1000L, 2000L);
-        assertThat(tracker.edgeCount()).isZero();
-    }
-
-    @Test
-    void reverseOrdering_ignored() {
-        var tracker = new CoActivationTracker();
-        tracker.recordSequentialActivation("java", "gc", 2000L, 1000L); // timeAfter < timeBefore
-        assertThat(tracker.edgeCount()).isZero();
-    }
-
-    @Test
-    void predictiveStrength_returnsCausalWeight() {
-        var tracker = new CoActivationTracker();
-        tracker.recordSequentialActivation("java", "gc", 1000L, 2000L);
-        tracker.recordSequentialActivation("java", "gc", 3000L, 4000L);
-
-        float strength = tracker.getPredictiveStrength(
-                List.of("java"), new String[]{"gc"});
-        assertThat(strength).isGreaterThan(0.0f);
-    }
-
-    @Test
-    void predictiveStrength_noCausalLink_returnsZero() {
-        var tracker = new CoActivationTracker();
-        float strength = tracker.getPredictiveStrength(
-                List.of("python"), new String[]{"rust"});
-        assertThat(strength).isEqualTo(0.0f);
-    }
-
-    @Test
-    void predictiveStrength_nullSafety() {
-        var tracker = new CoActivationTracker();
-        assertThat(tracker.getPredictiveStrength(null, new String[]{"gc"})).isEqualTo(0.0f);
-        assertThat(tracker.getPredictiveStrength(List.of("java"), null)).isEqualTo(0.0f);
-        assertThat(tracker.getPredictiveStrength(List.of(), new String[]{"gc"})).isEqualTo(0.0f);
-    }
-
-    @Test
-    void recordSequentialActivations_processesConsecutivePairs() {
-        var tracker = new CoActivationTracker();
-        tracker.recordSequentialActivations(
-                List.of("java", "gc", "performance"),
-                List.of(1000L, 2000L, 3000L));
-
-        // java→gc should exist
-        assertThat(tracker.getEdge("java", "gc")).isNotNull();
-        assertThat(tracker.getEdge("java", "gc").weight()).isGreaterThan(0);
-
-        // gc→performance should exist
-        assertThat(tracker.getEdge("gc", "performance")).isNotNull();
-        assertThat(tracker.getEdge("gc", "performance").weight()).isGreaterThan(0);
-    }
-
-    @Test
-    void edgeCount_tracksDirectedEdges() {
-        var tracker = new CoActivationTracker();
-        assertThat(tracker.edgeCount()).isZero();
-
-        tracker.recordSequentialActivation("java", "gc", 1000L, 2000L);
-        // Creates both java→gc (causal) and gc→java (anti-causal) edges
-        assertThat(tracker.edgeCount()).isEqualTo(2);
-    }
-
-    @Test
-    void reset_clearsEdges() {
-        var tracker = new CoActivationTracker();
-        tracker.recordSequentialActivation("java", "gc", 1000L, 2000L);
-        assertThat(tracker.edgeCount()).isGreaterThan(0);
-
-        tracker.reset();
-        assertThat(tracker.edgeCount()).isZero();
-        assertThat(tracker.pairCount()).isZero();
-    }
-
-    @Test
-    void averagePredictiveStrength_computesMean() {
-        var tracker = new CoActivationTracker();
-        tracker.recordSequentialActivation("java", "gc", 1000L, 2000L);
-        tracker.recordSequentialActivation("java", "performance", 1000L, 2000L);
-
-        float avg = tracker.getAveragePredictiveStrength(
-                List.of("java"), new String[]{"gc", "performance"});
-        assertThat(avg).isGreaterThan(0.0f);
-    }
-
-    @Test
-    void weightClamping_doesNotExceedMax() {
-        var tracker = new CoActivationTracker();
-        // Many rapid successive activations
-        for (int i = 0; i < 100; i++) {
-            tracker.recordSequentialActivation("java", "gc", 1000L + i, 1001L + i);
-        }
-
-        var edge = tracker.getEdge("java", "gc");
-        assertThat(edge.weight()).isLessThanOrEqualTo(1.0f);
-    }
-}
diff --git a/spector-memory/src/test/java/com/spectrayan/spector/memory/hippocampus/ReflectDaemonClusteringTest.java b/spector-memory/src/test/java/com/spectrayan/spector/memory/hippocampus/ReflectDaemonClusteringTest.java
deleted file mode 100644
index f2c073d..0000000
--- a/spector-memory/src/test/java/com/spectrayan/spector/memory/hippocampus/ReflectDaemonClusteringTest.java
+++ /dev/null
@@ -1,293 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.hippocampus;
-
-import com.spectrayan.spector.memory.MemoryType;
-import com.spectrayan.spector.memory.ReflectReport;
-import com.spectrayan.spector.memory.cortex.EpisodicMemoryStore;
-import com.spectrayan.spector.memory.cortex.EpisodicMemoryStore.EpisodicPartition;
-import com.spectrayan.spector.memory.cortex.SemanticMemoryStore;
-import com.spectrayan.spector.memory.synapse.CognitiveRecordLayout;
-import com.spectrayan.spector.memory.synapse.CognitiveRecordLayout.CognitiveHeader;
-import com.spectrayan.spector.memory.synapse.SynapticHeaderConstants;
-import com.spectrayan.spector.memory.cortex.CentroidRouter;
-import com.spectrayan.spector.embed.EmbeddingProvider;
-import com.spectrayan.spector.embed.EmbeddingResult;
-import com.spectrayan.spector.embed.TextGenerationProvider;
-import com.spectrayan.spector.embed.GenerationOptions;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.io.TempDir;
-
-import java.nio.file.Path;
-import java.util.Random;
-import java.util.function.Function;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-/**
- * Tests for IVF centroid clustering in ReflectDaemon (V3.1).
- */
-class ReflectDaemonClusteringTest {
-
-    private static final int DIMS = 16;
-    private static final int VEC_BYTES = DIMS; // INT8 quantization
-    private static final int CAPACITY = 200;
-
-    @TempDir
-    Path tempDir;
-
-    private Path storePath;
-    private CentroidRouter centroidRouter;
-    private MockEmbeddingProvider embeddingProvider;
-
-    @BeforeEach
-    void setUp() {
-        storePath = tempDir.resolve("episodic");
-        centroidRouter = new CentroidRouter(DIMS);
-        embeddingProvider = new MockEmbeddingProvider(DIMS);
-    }
-
-    // ── V3.1: Centroid-Based Clustering ──
-
-    @Test
-    void clustersBycentroidIdAndPromotes() {
-        try (EpisodicMemoryStore episodicStore = new EpisodicMemoryStore(storePath, VEC_BYTES, CAPACITY);
-             SemanticMemoryStore semanticStore = new SemanticMemoryStore(VEC_BYTES, 100)) {
-
-            // Create 20 memories across 3 centroids (ids: 1, 2, 3)
-            // Cluster 1: 8 records (above min=5)
-            // Cluster 2: 7 records (above min=5)
-            // Cluster 3: 3 records (below min=5 — should NOT promote)
-            // Unassigned (centroid 0): 2 records
-            int[] centroidAssignments = {
-                    1, 1, 1, 1, 1, 1, 1, 1,  // 8 records for centroid 1
-                    2, 2, 2, 2, 2, 2, 2,     // 7 records for centroid 2
-                    3, 3, 3,                   // 3 records for centroid 3
-                    0, 0                       // 2 unassigned
-            };
-
-            for (int i = 0; i < centroidAssignments.length; i++) {
-                CognitiveHeader header = new CognitiveHeader(
-                        System.currentTimeMillis(),
-                        (long) (i + 1) * 7, // synaptic tags
-                        1.0f,                // exactNorm
-                        2.0f,                // importance (> 1.0 so V1 fallback would also promote)
-                        0,                   // recallCount
-                        (short) centroidAssignments[i],  // centroid ID
-                        (byte) 0,
-                        SynapticHeaderConstants.withMemoryType((byte) 0, MemoryType.EPISODIC.ordinal())
-                );
-                episodicStore.append(header, makeVec(i));
-            }
-
-            assertThat(episodicStore.totalRecords()).isEqualTo(20);
-            assertThat(semanticStore.size()).isEqualTo(0);
-
-            // Run reflection with centroid router (V3.1 path)
-            ReflectDaemon daemon = new ReflectDaemon(
-                    CircadianPolicy.DEFAULT, centroidRouter, null, embeddingProvider);
-
-            ReflectReport report = daemon.runCycle(episodicStore, semanticStore);
-
-            // Should promote 2 clusters (centroid 1 and 2, both ≥ 5 records)
-            // Centroid 3 has only 3 records — below threshold
-            // Centroid 0 has only 2 records — below threshold
-            assertThat(report.consolidatedCount()).isEqualTo(2);
-            assertThat(semanticStore.size()).isEqualTo(2);
-        }
-    }
-
-    @Test
-    void withTextGenerationProviderSynthesizes() {
-        try (EpisodicMemoryStore episodicStore = new EpisodicMemoryStore(storePath, VEC_BYTES, CAPACITY);
-             SemanticMemoryStore semanticStore = new SemanticMemoryStore(VEC_BYTES, 100)) {
-
-            // Create 6 memories in the same centroid
-            for (int i = 0; i < 6; i++) {
-                CognitiveHeader header = new CognitiveHeader(
-                        System.currentTimeMillis(),
-                        0xFFL, 1.0f, 1.5f,
-                        0, // recallCount
-                        (short) 5, // centroid 5
-                        (byte) 0,
-                        SynapticHeaderConstants.withMemoryType((byte) 0, MemoryType.EPISODIC.ordinal())
-                );
-                episodicStore.append(header, makeVec(i));
-            }
-
-            // Mock TextGenerationProvider
-            MockTextGenerationProvider mockLlm = new MockTextGenerationProvider();
-
-            // Text lookup function
-            Function<Long, String> textLookup = offset -> "Memory text for offset " + offset;
-
-            ReflectDaemon daemon = new ReflectDaemon(
-                    CircadianPolicy.DEFAULT, centroidRouter, mockLlm, embeddingProvider);
-
-            ReflectReport report = daemon.runCycle(episodicStore, semanticStore, textLookup);
-
-            // Should promote 1 cluster via LLM synthesis
-            assertThat(report.consolidatedCount()).isEqualTo(1);
-            assertThat(semanticStore.size()).isEqualTo(1);
-
-            // LLM should have been called
-            assertThat(mockLlm.callCount).isGreaterThan(0);
-        }
-    }
-
-    @Test
-    void withoutCentroidRouterUsesV1Fallback() {
-        try (EpisodicMemoryStore episodicStore = new EpisodicMemoryStore(storePath, VEC_BYTES, CAPACITY);
-             SemanticMemoryStore semanticStore = new SemanticMemoryStore(VEC_BYTES, 100)) {
-
-            // Create 5 memories with importance ≥ 1.0
-            for (int i = 0; i < 5; i++) {
-                CognitiveHeader header = new CognitiveHeader(
-                        System.currentTimeMillis(),
-                        0L, 1.0f, 2.0f, // importance = 2.0 (above threshold)
-                        0, (short) 0, (byte) 0,
-                        SynapticHeaderConstants.withMemoryType((byte) 0, MemoryType.EPISODIC.ordinal())
-                );
-                episodicStore.append(header, makeVec(i));
-            }
-
-            // V1 mode — no centroid router
-            ReflectDaemon daemon = new ReflectDaemon(CircadianPolicy.DEFAULT);
-
-            ReflectReport report = daemon.runCycle(episodicStore, semanticStore);
-
-            // V1 should promote 1 (the highest-importance record)
-            assertThat(report.consolidatedCount()).isEqualTo(1);
-            assertThat(semanticStore.size()).isEqualTo(1);
-        }
-    }
-
-    @Test
-    void marksClusterMembersAsConsolidated() {
-        try (EpisodicMemoryStore episodicStore = new EpisodicMemoryStore(storePath, VEC_BYTES, CAPACITY);
-             SemanticMemoryStore semanticStore = new SemanticMemoryStore(VEC_BYTES, 100)) {
-
-            // Create 6 memories in centroid 1
-            for (int i = 0; i < 6; i++) {
-                CognitiveHeader header = new CognitiveHeader(
-                        System.currentTimeMillis(),
-                        0L, 1.0f, 1.0f,
-                        0, (short) 1, (byte) 0,
-                        SynapticHeaderConstants.withMemoryType((byte) 0, MemoryType.EPISODIC.ordinal())
-                );
-                episodicStore.append(header, makeVec(i));
-            }
-
-            ReflectDaemon daemon = new ReflectDaemon(
-                    CircadianPolicy.DEFAULT, centroidRouter, null, embeddingProvider);
-
-            daemon.runCycle(episodicStore, semanticStore);
-
-            // All 6 should be marked as consolidated
-            EpisodicPartition partition = episodicStore.partitions().getFirst();
-            var layout = partition.layout();
-            var segment = partition.segment();
-
-            for (int i = 0; i < 6; i++) {
-                long offset = partition.recordOffset(i);
-                byte flags = layout.readFlags(segment, offset);
-                assertThat(SynapticHeaderConstants.isConsolidated(flags))
-                        .as("Record %d should be consolidated", i)
-                        .isTrue();
-            }
-        }
-    }
-
-    @Test
-    void secondReflectDoesNotReprocessConsolidated() {
-        try (EpisodicMemoryStore episodicStore = new EpisodicMemoryStore(storePath, VEC_BYTES, CAPACITY);
-             SemanticMemoryStore semanticStore = new SemanticMemoryStore(VEC_BYTES, 100)) {
-
-            // 6 memories in centroid 1
-            for (int i = 0; i < 6; i++) {
-                CognitiveHeader header = new CognitiveHeader(
-                        System.currentTimeMillis(),
-                        0L, 1.0f, 1.0f,
-                        0, (short) 1, (byte) 0,
-                        SynapticHeaderConstants.withMemoryType((byte) 0, MemoryType.EPISODIC.ordinal())
-                );
-                episodicStore.append(header, makeVec(i));
-            }
-
-            ReflectDaemon daemon = new ReflectDaemon(
-                    CircadianPolicy.DEFAULT, centroidRouter, null, embeddingProvider);
-
-            ReflectReport report1 = daemon.runCycle(episodicStore, semanticStore);
-            assertThat(report1.consolidatedCount()).isEqualTo(1);
-
-            // Second reflect — records are already consolidated, nothing new
-            ReflectReport report2 = daemon.runCycle(episodicStore, semanticStore);
-            assertThat(report2.consolidatedCount()).isEqualTo(0);
-        }
-    }
-
-    // ── Mock Providers ──
-
-    static class MockEmbeddingProvider implements EmbeddingProvider {
-        private final int dims;
-
-        MockEmbeddingProvider(int dims) { this.dims = dims; }
-
-        @Override
-        public EmbeddingResult embed(String text) {
-            Random rng = new Random(text.hashCode());
-            float[] vec = new float[dims];
-            float norm = 0f;
-            for (int i = 0; i < dims; i++) {
-                vec[i] = (rng.nextFloat() - 0.5f) * 2.0f;
-                norm += vec[i] * vec[i];
-            }
-            norm = (float) Math.sqrt(norm);
-            if (norm > 0) {
-                for (int i = 0; i < dims; i++) vec[i] /= norm;
-            }
-            return new EmbeddingResult(vec, text.split("\\s+").length, "mock-" + dims + "d");
-        }
-
-        @Override public int dimensions() { return dims; }
-        @Override public String modelName() { return "mock-" + dims + "d"; }
-    }
-
-    static class MockTextGenerationProvider implements TextGenerationProvider {
-        int callCount = 0;
-
-        @Override
-        public String generate(String prompt) {
-            callCount++;
-            return "Synthesized fact from " + callCount + " call(s).";
-        }
-
-        @Override
-        public String generate(String prompt, GenerationOptions options) {
-            return generate(prompt);
-        }
-
-        @Override public String modelName() { return "mock-llm"; }
-    }
-
-    // ── Helpers ──
-
-    private byte[] makeVec(int seed) {
-        byte[] vec = new byte[VEC_BYTES];
-        for (int i = 0; i < VEC_BYTES; i++) {
-            vec[i] = (byte) ((seed + i) % 127);
-        }
-        return vec;
-    }
-}
diff --git a/spector-memory/src/test/java/com/spectrayan/spector/memory/hippocampus/TombstoneCompactorRebuildTest.java b/spector-memory/src/test/java/com/spectrayan/spector/memory/hippocampus/TombstoneCompactorRebuildTest.java
deleted file mode 100644
index b4a6e50..0000000
--- a/spector-memory/src/test/java/com/spectrayan/spector/memory/hippocampus/TombstoneCompactorRebuildTest.java
+++ /dev/null
@@ -1,271 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.hippocampus;
-
-import com.spectrayan.spector.memory.MemoryType;
-import com.spectrayan.spector.memory.cortex.EpisodicMemoryStore;
-import com.spectrayan.spector.memory.cortex.EpisodicMemoryStore.EpisodicPartition;
-import com.spectrayan.spector.memory.synapse.CognitiveRecordLayout;
-import com.spectrayan.spector.memory.synapse.CognitiveRecordLayout.CognitiveHeader;
-import com.spectrayan.spector.memory.synapse.SynapticHeaderConstants;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.io.TempDir;
-
-import java.lang.foreign.MemorySegment;
-import java.nio.file.Path;
-import java.util.Map;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-/**
- * Tests for TombstoneCompactor partition rebuild (V3.6).
- */
-class TombstoneCompactorRebuildTest {
-
-    private static final int VEC_BYTES = 16;
-    private static final int CAPACITY = 200;
-    private static final float TOMBSTONE_THRESHOLD = 0.30f;
-
-    @TempDir
-    Path tempDir;
-
-    private Path storePath;
-    private TombstoneCompactor compactor;
-
-    @BeforeEach
-    void setUp() {
-        storePath = tempDir.resolve("episodic");
-        compactor = new TombstoneCompactor(TOMBSTONE_THRESHOLD);
-    }
-
-    @Test
-    void compactRemovesTombstonedRecords() {
-        try (EpisodicMemoryStore store = new EpisodicMemoryStore(storePath, VEC_BYTES, CAPACITY)) {
-            // Add 100 records
-            for (int i = 0; i < 100; i++) {
-                CognitiveHeader header = CognitiveHeader.create(
-                        System.currentTimeMillis(), (long) i, 1.0f,
-                        (float) i / 10, (short) 0, MemoryType.EPISODIC);
-                store.append(header, makeVec(i));
-            }
-
-            EpisodicPartition partition = store.partitions().getFirst();
-            CognitiveRecordLayout layout = partition.layout();
-            MemorySegment segment = partition.segment();
-
-            // Tombstone 40 records (indices 0-39)
-            for (int i = 0; i < 40; i++) {
-                layout.tombstone(segment, partition.recordOffset(i));
-                partition.incrementTombstoneCount();
-            }
-
-            assertThat(partition.count()).isEqualTo(100);
-            assertThat(partition.tombstoneCount()).isEqualTo(40);
-            assertThat(partition.tombstoneRatio()).isEqualTo(0.40f);
-            assertThat(compactor.shouldCompact(partition)).isTrue();
-
-            // Compact
-            String key = store.keyForPartition(partition);
-            EpisodicPartition compacted = compactor.compact(partition, storePath, key);
-
-            assertThat(compacted).isNotNull();
-            assertThat(compacted.count()).isEqualTo(60); // 100 - 40 tombstoned
-            assertThat(compacted.tombstoneCount()).isEqualTo(0);
-
-            // Verify compacted partition has correct data (records 40-99 from original)
-            CognitiveRecordLayout compactedLayout = compacted.layout();
-            MemorySegment compactedSegment = compacted.segment();
-
-            // First live record in compacted should have importance of index 40 → 4.0f
-            float firstImportance = compactedLayout.readImportance(
-                    compactedSegment, compacted.recordOffset(0));
-            assertThat(firstImportance).isEqualTo(4.0f);
-
-            // Last record should have importance of index 99 → 9.9f
-            float lastImportance = compactedLayout.readImportance(
-                    compactedSegment, compacted.recordOffset(59));
-            assertThat(lastImportance).isEqualTo(9.9f);
-
-            compacted.close();
-        }
-    }
-
-    @Test
-    void compactPreservesVectorPayload() {
-        try (EpisodicMemoryStore store = new EpisodicMemoryStore(storePath, VEC_BYTES, CAPACITY)) {
-            // Add 10 records with distinctive vectors
-            for (int i = 0; i < 10; i++) {
-                CognitiveHeader header = CognitiveHeader.create(
-                        System.currentTimeMillis(), 0L, 1.0f, 1.0f, (short) 0, MemoryType.EPISODIC);
-                store.append(header, makeVec(i * 100)); // distinctive seed
-            }
-
-            EpisodicPartition partition = store.partitions().getFirst();
-            CognitiveRecordLayout layout = partition.layout();
-            MemorySegment segment = partition.segment();
-
-            // Tombstone records 0, 2, 4 (keep 1, 3, 5, 6, 7, 8, 9)
-            for (int idx : new int[]{0, 2, 4}) {
-                layout.tombstone(segment, partition.recordOffset(idx));
-                partition.incrementTombstoneCount();
-            }
-
-            String key = store.keyForPartition(partition);
-            EpisodicPartition compacted = compactor.compact(partition, storePath, key);
-
-            assertThat(compacted).isNotNull();
-            assertThat(compacted.count()).isEqualTo(7);
-
-            // Verify vector of first record (was index 1 in original → seed = 100)
-            byte[] expectedVec = makeVec(100);
-            byte[] actualVec = new byte[VEC_BYTES];
-            MemorySegment.copy(compacted.segment(),
-                    compacted.layout().vectorOffset(compacted.recordOffset(0)),
-                    MemorySegment.ofArray(actualVec), 0, VEC_BYTES);
-            assertThat(actualVec).isEqualTo(expectedVec);
-
-            compacted.close();
-        }
-    }
-
-    @Test
-    void buildOffsetRemapProducesCorrectMapping() {
-        try (EpisodicMemoryStore store = new EpisodicMemoryStore(storePath, VEC_BYTES, CAPACITY)) {
-            for (int i = 0; i < 10; i++) {
-                CognitiveHeader header = CognitiveHeader.create(
-                        System.currentTimeMillis(), 0L, 1.0f, 1.0f, (short) 0, MemoryType.EPISODIC);
-                store.append(header, makeVec(i));
-            }
-
-            EpisodicPartition partition = store.partitions().getFirst();
-            CognitiveRecordLayout layout = partition.layout();
-
-            // Tombstone records 3, 5, 7
-            for (int idx : new int[]{3, 5, 7}) {
-                layout.tombstone(partition.segment(), partition.recordOffset(idx));
-                partition.incrementTombstoneCount();
-            }
-
-            String key = store.keyForPartition(partition);
-            EpisodicPartition compacted = compactor.compact(partition, storePath, key);
-
-            Map<Long, Long> remap = compactor.buildOffsetRemap(partition, compacted);
-
-            // Should have 7 entries (10 - 3 tombstoned)
-            assertThat(remap).hasSize(7);
-
-            // Record 0 → should map to compacted record 0
-            assertThat(remap).containsKey(partition.recordOffset(0));
-            assertThat(remap.get(partition.recordOffset(0))).isEqualTo(compacted.recordOffset(0));
-
-            // Record 3 → should NOT be in remap (tombstoned)
-            assertThat(remap).doesNotContainKey(partition.recordOffset(3));
-
-            // Record 4 → should map to compacted record 3 (shifted after tombstone at 3)
-            assertThat(remap).containsKey(partition.recordOffset(4));
-            assertThat(remap.get(partition.recordOffset(4))).isEqualTo(compacted.recordOffset(3));
-
-            compacted.close();
-        }
-    }
-
-    @Test
-    void replacePartitionSwapsInStore() {
-        try (EpisodicMemoryStore store = new EpisodicMemoryStore(storePath, VEC_BYTES, CAPACITY)) {
-            for (int i = 0; i < 20; i++) {
-                CognitiveHeader header = CognitiveHeader.create(
-                        System.currentTimeMillis(), 0L, 1.0f, 1.0f, (short) 0, MemoryType.EPISODIC);
-                store.append(header, makeVec(i));
-            }
-
-            EpisodicPartition partition = store.partitions().getFirst();
-            CognitiveRecordLayout layout = partition.layout();
-
-            // Tombstone 10 records
-            for (int i = 0; i < 10; i++) {
-                layout.tombstone(partition.segment(), partition.recordOffset(i));
-                partition.incrementTombstoneCount();
-            }
-
-            String key = store.keyForPartition(partition);
-            assertThat(store.totalRecords()).isEqualTo(20);
-
-            // Compact
-            EpisodicPartition compacted = compactor.compact(partition, storePath, key);
-            assertThat(compacted).isNotNull();
-
-            // Swap
-            boolean swapped = store.replacePartition(key, partition, compacted);
-            assertThat(swapped).isTrue();
-            assertThat(store.totalRecords()).isEqualTo(10);
-            assertThat(store.partitionCount()).isEqualTo(1);
-        }
-    }
-
-    @Test
-    void compactWithAllTombstonedReturnsNull() {
-        try (EpisodicMemoryStore store = new EpisodicMemoryStore(storePath, VEC_BYTES, CAPACITY)) {
-            for (int i = 0; i < 5; i++) {
-                store.append(CognitiveHeader.create(
-                        System.currentTimeMillis(), 0L, 1.0f, 1.0f, (short) 0, MemoryType.EPISODIC), makeVec(i));
-            }
-
-            EpisodicPartition partition = store.partitions().getFirst();
-            for (int i = 0; i < 5; i++) {
-                partition.layout().tombstone(partition.segment(), partition.recordOffset(i));
-                partition.incrementTombstoneCount();
-            }
-
-            String key = store.keyForPartition(partition);
-            EpisodicPartition compacted = compactor.compact(partition, storePath, key);
-            assertThat(compacted).isNull();
-        }
-    }
-
-    @Test
-    void shouldCompactRespectThreshold() {
-        try (EpisodicMemoryStore store = new EpisodicMemoryStore(storePath, VEC_BYTES, CAPACITY)) {
-            for (int i = 0; i < 10; i++) {
-                store.append(CognitiveHeader.create(
-                        System.currentTimeMillis(), 0L, 1.0f, 1.0f, (short) 0, MemoryType.EPISODIC), makeVec(i));
-            }
-
-            EpisodicPartition partition = store.partitions().getFirst();
-
-            // 2/10 = 20% < 30% threshold — should NOT compact
-            for (int i = 0; i < 2; i++) {
-                partition.layout().tombstone(partition.segment(), partition.recordOffset(i));
-                partition.incrementTombstoneCount();
-            }
-            assertThat(compactor.shouldCompact(partition)).isFalse();
-
-            // Tombstone 2 more → 4/10 = 40% > 30% — should compact
-            for (int i = 2; i < 4; i++) {
-                partition.layout().tombstone(partition.segment(), partition.recordOffset(i));
-                partition.incrementTombstoneCount();
-            }
-            assertThat(compactor.shouldCompact(partition)).isTrue();
-        }
-    }
-
-    // ── Helpers ──
-
-    private byte[] makeVec(int seed) {
-        byte[] vec = new byte[VEC_BYTES];
-        for (int i = 0; i < VEC_BYTES; i++) {
-            vec[i] = (byte) ((seed + i) % 127);
-        }
-        return vec;
-    }
-}
diff --git a/spector-memory/src/test/java/com/spectrayan/spector/memory/index/MemoryIndexTest.java b/spector-memory/src/test/java/com/spectrayan/spector/memory/index/MemoryIndexTest.java
deleted file mode 100644
index b4179b9..0000000
--- a/spector-memory/src/test/java/com/spectrayan/spector/memory/index/MemoryIndexTest.java
+++ /dev/null
@@ -1,298 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.index;
-
-import com.spectrayan.spector.memory.MemoryType;
-import com.spectrayan.spector.memory.cortex.MemorySource;
-import com.spectrayan.spector.memory.index.MemoryIndex.MemoryLocation;
-
-import org.junit.jupiter.api.*;
-import static org.assertj.core.api.Assertions.*;
-
-import java.util.concurrent.*;
-import java.util.concurrent.atomic.AtomicInteger;
-
-/**
- * Detailed unit tests for {@link MemoryIndex} — specifically the O(1) reverse index
- * (P1 optimization) and concurrent safety.
- */
-@DisplayName("MemoryIndex — Reverse Index + Concurrent Safety")
-class MemoryIndexTest {
-
-    private MemoryIndex index;
-
-    @BeforeEach
-    void setUp() {
-        index = new MemoryIndex();
-    }
-
-    // ══════════════════════════════════════════════════════════════
-    // P1: O(1) Reverse Lookup
-    // ══════════════════════════════════════════════════════════════
-
-    @Test
-    @DisplayName("findIdByOffset returns correct ID for registered memory")
-    void findIdByOffset_returnsCorrectId() {
-        index.register("mem-1",
-                new MemoryLocation(MemoryType.EPISODIC, 1024L, 0),
-                "Hello world", MemorySource.OBSERVED, new String[]{"greeting"});
-
-        assertThat(index.findIdByOffset(MemoryType.EPISODIC, 1024L)).isEqualTo("mem-1");
-    }
-
-    @Test
-    @DisplayName("findIdByOffset returns null for unknown offset")
-    void findIdByOffset_returnsNullForUnknown() {
-        assertThat(index.findIdByOffset(MemoryType.EPISODIC, 9999L)).isNull();
-    }
-
-    @Test
-    @DisplayName("findIdByOffset distinguishes memory types at same offset")
-    void findIdByOffset_distinguishesTypes() {
-        index.register("working-0",
-                new MemoryLocation(MemoryType.WORKING, 0L, -1),
-                "working", MemorySource.OBSERVED, new String[]{});
-        index.register("episodic-0",
-                new MemoryLocation(MemoryType.EPISODIC, 0L, 0),
-                "episodic", MemorySource.OBSERVED, new String[]{});
-        index.register("semantic-0",
-                new MemoryLocation(MemoryType.SEMANTIC, 0L, -1),
-                "semantic", MemorySource.OBSERVED, new String[]{});
-        index.register("procedural-0",
-                new MemoryLocation(MemoryType.PROCEDURAL, 0L, -1),
-                "procedural", MemorySource.OBSERVED, new String[]{});
-
-        assertThat(index.findIdByOffset(MemoryType.WORKING, 0L)).isEqualTo("working-0");
-        assertThat(index.findIdByOffset(MemoryType.EPISODIC, 0L)).isEqualTo("episodic-0");
-        assertThat(index.findIdByOffset(MemoryType.SEMANTIC, 0L)).isEqualTo("semantic-0");
-        assertThat(index.findIdByOffset(MemoryType.PROCEDURAL, 0L)).isEqualTo("procedural-0");
-    }
-
-    @Test
-    @DisplayName("findTextByOffset returns correct text via reverse index")
-    void findTextByOffset_returnsText() {
-        index.register("mem-abc",
-                new MemoryLocation(MemoryType.SEMANTIC, 512L, -1),
-                "Java is great", MemorySource.OBSERVED, new String[]{"java"});
-
-        assertThat(index.findTextByOffset(MemoryType.SEMANTIC, 512L)).isEqualTo("Java is great");
-    }
-
-    @Test
-    @DisplayName("findTextByOffset returns null for missing offset")
-    void findTextByOffset_nullForMissing() {
-        assertThat(index.findTextByOffset(MemoryType.SEMANTIC, 999L)).isNull();
-    }
-
-    // ══════════════════════════════════════════════════════════════
-    // Remove cleans reverse index
-    // ══════════════════════════════════════════════════════════════
-
-    @Test
-    @DisplayName("remove cleans both forward and reverse index")
-    void remove_cleansBothIndexes() {
-        index.register("mem-1",
-                new MemoryLocation(MemoryType.EPISODIC, 100L, 0),
-                "hello", MemorySource.OBSERVED, new String[]{});
-
-        assertThat(index.findIdByOffset(MemoryType.EPISODIC, 100L)).isEqualTo("mem-1");
-        assertThat(index.locate("mem-1")).isNotNull();
-
-        index.remove("mem-1");
-
-        assertThat(index.findIdByOffset(MemoryType.EPISODIC, 100L)).isNull();
-        assertThat(index.locate("mem-1")).isNull();
-        assertThat(index.text("mem-1")).isEmpty();
-    }
-
-    @Test
-    @DisplayName("remove of non-existent ID is safe")
-    void remove_nonExistentIsSafe() {
-        assertThatCode(() -> index.remove("does-not-exist")).doesNotThrowAnyException();
-    }
-
-    // ══════════════════════════════════════════════════════════════
-    // Forward index operations
-    // ══════════════════════════════════════════════════════════════
-
-    @Test
-    @DisplayName("register and lookup all metadata fields")
-    void register_allMetadata() {
-        String[] tags = {"java", "performance"};
-        index.register("mem-x",
-                new MemoryLocation(MemoryType.PROCEDURAL, 256L, -1),
-                "Always check nulls", MemorySource.PROCEDURAL, tags);
-
-        assertThat(index.locate("mem-x").type()).isEqualTo(MemoryType.PROCEDURAL);
-        assertThat(index.locate("mem-x").offset()).isEqualTo(256L);
-        assertThat(index.text("mem-x")).isEqualTo("Always check nulls");
-        assertThat(index.source("mem-x")).isEqualTo(MemorySource.PROCEDURAL);
-        assertThat(index.tags("mem-x")).containsExactly("java", "performance");
-    }
-
-    @Test
-    @DisplayName("source defaults to OBSERVED for unknown IDs")
-    void source_defaultForUnknown() {
-        assertThat(index.source("unknown")).isEqualTo(MemorySource.OBSERVED);
-    }
-
-    @Test
-    @DisplayName("tags default to empty array for unknown IDs")
-    void tags_defaultForUnknown() {
-        assertThat(index.tags("unknown")).isEmpty();
-    }
-
-    @Test
-    @DisplayName("size reflects registered entries")
-    void size_tracksEntries() {
-        assertThat(index.size()).isZero();
-        index.register("a", new MemoryLocation(MemoryType.WORKING, 0, -1),
-                "a", MemorySource.OBSERVED, new String[]{});
-        assertThat(index.size()).isEqualTo(1);
-        index.register("b", new MemoryLocation(MemoryType.WORKING, 64, -1),
-                "b", MemorySource.OBSERVED, new String[]{});
-        assertThat(index.size()).isEqualTo(2);
-        index.remove("a");
-        assertThat(index.size()).isEqualTo(1);
-    }
-
-    // ══════════════════════════════════════════════════════════════
-    // Concurrent safety
-    // ══════════════════════════════════════════════════════════════
-
-    @Test
-    @DisplayName("concurrent register + findIdByOffset is thread-safe")
-    void concurrentRegisterAndLookup() throws Exception {
-        int threads = 8;
-        int perThread = 5_000;
-        ExecutorService pool = Executors.newFixedThreadPool(threads);
-        CountDownLatch latch = new CountDownLatch(threads);
-        AtomicInteger errors = new AtomicInteger(0);
-
-        for (int t = 0; t < threads; t++) {
-            final int threadId = t;
-            pool.submit(() -> {
-                try {
-                    for (int i = 0; i < perThread; i++) {
-                        String id = "t" + threadId + "-m" + i;
-                        long offset = (long) (threadId * perThread + i) * 64;
-                        index.register(id,
-                                new MemoryLocation(MemoryType.EPISODIC, offset, 0),
-                                "text-" + id, MemorySource.OBSERVED, new String[]{});
-                    }
-                    // Verify own entries
-                    for (int i = 0; i < perThread; i++) {
-                        long offset = (long) (threadId * perThread + i) * 64;
-                        String found = index.findIdByOffset(MemoryType.EPISODIC, offset);
-                        if (found == null) errors.incrementAndGet();
-                    }
-                } finally {
-                    latch.countDown();
-                }
-            });
-        }
-
-        latch.await(30, TimeUnit.SECONDS);
-        pool.shutdown();
-
-        assertThat(index.size()).isEqualTo(threads * perThread);
-        assertThat(errors.get()).as("All lookups should find their entry").isZero();
-    }
-
-    @Test
-    @DisplayName("concurrent register + remove is thread-safe")
-    void concurrentRegisterAndRemove() throws Exception {
-        int count = 10_000;
-        // Pre-populate
-        for (int i = 0; i < count; i++) {
-            index.register("mem-" + i,
-                    new MemoryLocation(MemoryType.EPISODIC, (long) i * 64, 0),
-                    "t-" + i, MemorySource.OBSERVED, new String[]{});
-        }
-
-        ExecutorService pool = Executors.newFixedThreadPool(4);
-        CountDownLatch latch = new CountDownLatch(2);
-
-        // Thread 1: remove even entries
-        pool.submit(() -> {
-            try {
-                for (int i = 0; i < count; i += 2) {
-                    index.remove("mem-" + i);
-                }
-            } finally { latch.countDown(); }
-        });
-
-        // Thread 2: lookup all entries
-        pool.submit(() -> {
-            try {
-                for (int i = 0; i < count; i++) {
-                    index.findIdByOffset(MemoryType.EPISODIC, (long) i * 64); // should not throw
-                }
-            } finally { latch.countDown(); }
-        });
-
-        latch.await(30, TimeUnit.SECONDS);
-        pool.shutdown();
-
-        // After removal: odd entries should remain, even entries gone
-        for (int i = 0; i < count; i += 2) {
-            assertThat(index.locate("mem-" + i)).isNull();
-        }
-        for (int i = 1; i < count; i += 2) {
-            assertThat(index.locate("mem-" + i)).isNotNull();
-        }
-    }
-
-    // ══════════════════════════════════════════════════════════════
-    // Edge cases
-    // ══════════════════════════════════════════════════════════════
-
-    @Test
-    @DisplayName("large offsets (near Long.MAX_VALUE) handled correctly")
-    void largeOffsets() {
-        long bigOffset = 0x0000_FFFF_FFFF_FFF0L; // near 48-bit max
-        index.register("big",
-                new MemoryLocation(MemoryType.SEMANTIC, bigOffset, -1),
-                "big offset", MemorySource.OBSERVED, new String[]{});
-
-        assertThat(index.findIdByOffset(MemoryType.SEMANTIC, bigOffset)).isEqualTo("big");
-    }
-
-    @Test
-    @DisplayName("zero offset is valid and distinguishable across types")
-    void zeroOffset() {
-        index.register("w0", new MemoryLocation(MemoryType.WORKING, 0, -1),
-                "w", MemorySource.OBSERVED, new String[]{});
-        index.register("e0", new MemoryLocation(MemoryType.EPISODIC, 0, 0),
-                "e", MemorySource.OBSERVED, new String[]{});
-
-        assertThat(index.findIdByOffset(MemoryType.WORKING, 0)).isEqualTo("w0");
-        assertThat(index.findIdByOffset(MemoryType.EPISODIC, 0)).isEqualTo("e0");
-    }
-
-    @Test
-    @DisplayName("re-registering same ID updates reverse index")
-    void reRegisterUpdatesReverseIndex() {
-        index.register("mem-1",
-                new MemoryLocation(MemoryType.EPISODIC, 100L, 0),
-                "v1", MemorySource.OBSERVED, new String[]{});
-        assertThat(index.findIdByOffset(MemoryType.EPISODIC, 100L)).isEqualTo("mem-1");
-
-        // Re-register at different offset
-        index.register("mem-1",
-                new MemoryLocation(MemoryType.EPISODIC, 200L, 0),
-                "v2", MemorySource.OBSERVED, new String[]{});
-        assertThat(index.findIdByOffset(MemoryType.EPISODIC, 200L)).isEqualTo("mem-1");
-        assertThat(index.text("mem-1")).isEqualTo("v2");
-    }
-}
diff --git a/spector-memory/src/test/java/com/spectrayan/spector/memory/inhibition/SuppressionOffsetTest.java b/spector-memory/src/test/java/com/spectrayan/spector/memory/inhibition/SuppressionOffsetTest.java
deleted file mode 100644
index 1ebc198..0000000
--- a/spector-memory/src/test/java/com/spectrayan/spector/memory/inhibition/SuppressionOffsetTest.java
+++ /dev/null
@@ -1,99 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.inhibition;
-
-import org.junit.jupiter.api.Test;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-/**
- * Tests for offset-indexed suppression in {@link SuppressionSet}.
- */
-class SuppressionOffsetTest {
-
-    @Test
-    void registerOffset_enablesOffsetLookup() {
-        SuppressionSet set = new SuppressionSet();
-
-        set.registerOffset(1, 1024L);
-        assertThat(set.isSuppressedByOffset(1, 1024L)).isTrue();
-        assertThat(set.isSuppressedByOffset(1, 2048L)).isFalse();
-    }
-
-    @Test
-    void differentTypes_atSameOffset_trackedSeparately() {
-        SuppressionSet set = new SuppressionSet();
-
-        set.registerOffset(0, 512L); // e.g., WORKING type
-        set.registerOffset(1, 512L); // e.g., EPISODIC type at same offset
-
-        assertThat(set.isSuppressedByOffset(0, 512L)).isTrue();
-        assertThat(set.isSuppressedByOffset(1, 512L)).isTrue();
-        assertThat(set.isSuppressedByOffset(2, 512L)).isFalse(); // different type
-    }
-
-    @Test
-    void clear_removesOffsets() {
-        SuppressionSet set = new SuppressionSet();
-
-        set.suppress("mem-1");
-        set.registerOffset(1, 1024L);
-
-        set.clear();
-
-        assertThat(set.isSuppressed("mem-1")).isFalse();
-        assertThat(set.isSuppressedByOffset(1, 1024L)).isFalse();
-    }
-
-    @Test
-    void largeOffsets_packedCorrectly() {
-        SuppressionSet set = new SuppressionSet();
-
-        // Test with a large offset that uses many bits
-        long largeOffset = 0x0000_ABCD_1234_5678L;
-        set.registerOffset(3, largeOffset);
-
-        assertThat(set.isSuppressedByOffset(3, largeOffset)).isTrue();
-        assertThat(set.isSuppressedByOffset(3, largeOffset + 1)).isFalse();
-    }
-
-    @Test
-    void multipleOffsets_trackedIndependently() {
-        SuppressionSet set = new SuppressionSet();
-
-        set.registerOffset(1, 0L);
-        set.registerOffset(1, 64L);
-        set.registerOffset(1, 128L);
-
-        assertThat(set.isSuppressedByOffset(1, 0L)).isTrue();
-        assertThat(set.isSuppressedByOffset(1, 64L)).isTrue();
-        assertThat(set.isSuppressedByOffset(1, 128L)).isTrue();
-        assertThat(set.isSuppressedByOffset(1, 192L)).isFalse();
-    }
-
-    @Test
-    void stringAndOffsetSuppression_independent() {
-        SuppressionSet set = new SuppressionSet();
-
-        // String-based suppression
-        set.suppress("mem-1");
-        assertThat(set.isSuppressed("mem-1")).isTrue();
-
-        // Offset-based — not yet registered
-        assertThat(set.isSuppressedByOffset(1, 1024L)).isFalse();
-
-        // Register offset
-        set.registerOffset(1, 1024L);
-        assertThat(set.isSuppressedByOffset(1, 1024L)).isTrue();
-    }
-}
diff --git a/spector-memory/src/test/java/com/spectrayan/spector/memory/inhibition/SuppressionSetTest.java b/spector-memory/src/test/java/com/spectrayan/spector/memory/inhibition/SuppressionSetTest.java
deleted file mode 100644
index e59dfbf..0000000
--- a/spector-memory/src/test/java/com/spectrayan/spector/memory/inhibition/SuppressionSetTest.java
+++ /dev/null
@@ -1,66 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.inhibition;
-
-import org.junit.jupiter.api.Test;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-class SuppressionSetTest {
-
-    @Test
-    void newSetIsEmpty() {
-        var set = new SuppressionSet();
-        assertThat(set.size()).isZero();
-        assertThat(set.isSuppressed("memory-1")).isFalse();
-    }
-
-    @Test
-    void suppressAndCheck() {
-        var set = new SuppressionSet();
-        set.suppress("memory-1", "incorrect answer");
-        assertThat(set.isSuppressed("memory-1")).isTrue();
-        assertThat(set.size()).isEqualTo(1);
-    }
-
-    @Test
-    void unsuppressRemoves() {
-        var set = new SuppressionSet();
-        set.suppress("memory-1");
-        set.unsuppress("memory-1");
-        assertThat(set.isSuppressed("memory-1")).isFalse();
-        assertThat(set.size()).isZero();
-    }
-
-    @Test
-    void clearRemovesAll() {
-        var set = new SuppressionSet();
-        set.suppress("m1");
-        set.suppress("m2");
-        set.suppress("m3");
-        assertThat(set.size()).isEqualTo(3);
-
-        set.clear();
-        assertThat(set.size()).isZero();
-    }
-
-    @Test
-    void suppressedIdsReturnsUnmodifiableView() {
-        var set = new SuppressionSet();
-        set.suppress("m1");
-        set.suppress("m2");
-
-        var ids = set.suppressedIds();
-        assertThat(ids).containsExactlyInAnyOrder("m1", "m2");
-    }
-}
diff --git a/spector-memory/src/test/java/com/spectrayan/spector/memory/metamemory/MemoryIntrospectorTest.java b/spector-memory/src/test/java/com/spectrayan/spector/memory/metamemory/MemoryIntrospectorTest.java
deleted file mode 100644
index 038d949..0000000
--- a/spector-memory/src/test/java/com/spectrayan/spector/memory/metamemory/MemoryIntrospectorTest.java
+++ /dev/null
@@ -1,96 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.metamemory;
-
-import com.spectrayan.spector.memory.CognitiveResult;
-import com.spectrayan.spector.memory.MemoryType;
-import com.spectrayan.spector.memory.cortex.MemorySource;
-import org.junit.jupiter.api.Test;
-
-import java.util.List;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-class MemoryIntrospectorTest {
-
-    private final MemoryIntrospector introspector = new MemoryIntrospector();
-
-    @Test
-    void emptyResultsProduceEmptyInsight() {
-        var insight = introspector.analyze("kubernetes", List.of());
-        assertThat(insight.isKnown()).isFalse();
-        assertThat(insight.totalMemories()).isZero();
-        assertThat(insight.confidence()).isZero();
-        assertThat(insight.recommendation()).contains("No memories found");
-    }
-
-    @Test
-    void nullResultsProduceEmptyInsight() {
-        var insight = introspector.analyze("topic", null);
-        assertThat(insight.isKnown()).isFalse();
-    }
-
-    @Test
-    void highConfidenceWithManyReinforcedMemories() {
-        var results = List.of(
-                makeResult(5.0f, 1.0f, (short) 3, (byte) 50),
-                makeResult(3.0f, 2.0f, (short) 5, (byte) 30),
-                makeResult(4.0f, 3.0f, (short) 2, (byte) 40),
-                makeResult(6.0f, 0.5f, (short) 4, (byte) 60),
-                makeResult(7.0f, 1.0f, (short) 6, (byte) 20),
-                makeResult(5.0f, 2.0f, (short) 3, (byte) 50),
-                makeResult(4.0f, 0.5f, (short) 1, (byte) 30),
-                makeResult(8.0f, 1.0f, (short) 2, (byte) 70),
-                makeResult(3.0f, 3.0f, (short) 4, (byte) 40),
-                makeResult(5.0f, 0.5f, (short) 3, (byte) 50)
-        );
-
-        var insight = introspector.analyze("java-performance", results);
-        assertThat(insight.isKnown()).isTrue();
-        assertThat(insight.confidence()).isGreaterThan(0.3f);
-        assertThat(insight.totalMemories()).isEqualTo(10);
-    }
-
-    @Test
-    void staleKnowledgeDetected() {
-        var results = List.of(
-                makeResult(2.0f, 100f, (short) 0, (byte) 0)  // 100 days old
-        );
-
-        var insight = introspector.analyze("old-topic", results);
-        assertThat(insight.staleness()).isGreaterThan(0.7f);
-        // With just 1 memory, confidence is low → recommendation mentions "sparse"
-        // Staleness is still correctly detected via the staleness field
-        assertThat(insight.isStale()).isTrue();
-    }
-
-    @Test
-    void lowConfidenceWithFewMemories() {
-        var results = List.of(
-                makeResult(0.5f, 1.0f, (short) 0, (byte) 0)
-        );
-
-        var insight = introspector.analyze("obscure-topic", results);
-        assertThat(insight.confidence()).isLessThan(0.3f);
-        assertThat(insight.recommendation()).contains("sparse");
-    }
-
-    private CognitiveResult makeResult(float importance, float ageDays,
-                                        short recallCount, byte valence) {
-        return new CognitiveResult(
-                "test-id", "test text", 0.8f, importance, ageDays,
-                recallCount, valence, MemoryType.SEMANTIC, MemorySource.OBSERVED,
-                new String[]{"test"}, 0.7f, 0.8f
-        );
-    }
-}
diff --git a/spector-memory/src/test/java/com/spectrayan/spector/memory/neurodivergent/HyperfocusStateTest.java b/spector-memory/src/test/java/com/spectrayan/spector/memory/neurodivergent/HyperfocusStateTest.java
deleted file mode 100644
index 96c5ed1..0000000
--- a/spector-memory/src/test/java/com/spectrayan/spector/memory/neurodivergent/HyperfocusStateTest.java
+++ /dev/null
@@ -1,105 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.neurodivergent;
-
-import com.spectrayan.spector.memory.synapse.SynapticTagEncoder;
-import org.junit.jupiter.api.Test;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-/**
- * Tests for {@link HyperfocusState} — TTL management and agent self-extension.
- */
-class HyperfocusStateTest {
-
-    @Test
-    void inactive_byDefault() {
-        var state = new HyperfocusState();
-        assertThat(state.isActive()).isFalse();
-        assertThat(state.mask()).isZero();
-        assertThat(state.remainingMs()).isZero();
-    }
-
-    @Test
-    void activate_becomesActive() {
-        var state = new HyperfocusState();
-        long mask = SynapticTagEncoder.encode("database", "deadlock");
-        state.activate(mask);
-        assertThat(state.isActive()).isTrue();
-        assertThat(state.mask()).isEqualTo(mask);
-        assertThat(state.remainingMs()).isGreaterThan(0L);
-    }
-
-    @Test
-    void activate_fromTagStrings() {
-        var state = new HyperfocusState();
-        state.activateFromTags("java", "concurrency");
-        assertThat(state.isActive()).isTrue();
-        long expectedMask = SynapticTagEncoder.encode("java", "concurrency");
-        assertThat(state.mask()).isEqualTo(expectedMask);
-    }
-
-    @Test
-    void deactivate_resetsState() {
-        var state = new HyperfocusState();
-        state.activateFromTags("topic");
-        assertThat(state.isActive()).isTrue();
-
-        state.deactivate();
-        assertThat(state.isActive()).isFalse();
-        assertThat(state.mask()).isZero();
-    }
-
-    @Test
-    void extend_addsToTtl() {
-        var state = new HyperfocusState(1000L); // 1 second TTL
-        state.activate(0xFFL, 1000L);
-        long before = state.remainingMs();
-
-        state.extend(5000L); // extend by 5 seconds
-        long after = state.remainingMs();
-        assertThat(after).isGreaterThan(before);
-    }
-
-    @Test
-    void extend_defaultTtl() {
-        var state = new HyperfocusState(5000L);
-        state.activate(0xFFL, 1000L);
-        state.extend(); // extends by defaultTtlMs (5000L)
-        assertThat(state.remainingMs()).isGreaterThan(4000L);
-    }
-
-    @Test
-    void extend_noOpWhenInactive() {
-        var state = new HyperfocusState();
-        state.extend(5000L); // should be safe, no-op
-        assertThat(state.isActive()).isFalse();
-    }
-
-    @Test
-    void customTtl_used() {
-        var state = new HyperfocusState(60_000L); // 1 minute
-        assertThat(state.defaultTtlMs()).isEqualTo(60_000L);
-    }
-
-    @Test
-    void expiration_returnsZeroMaskAfterTtl() throws InterruptedException {
-        var state = new HyperfocusState(50L); // 50ms TTL
-        state.activate(0xFFL, 50L);
-        assertThat(state.isActive()).isTrue();
-
-        Thread.sleep(100); // wait for expiration
-        assertThat(state.isActive()).isFalse();
-        assertThat(state.mask()).isZero();
-    }
-}
diff --git a/spector-memory/src/test/java/com/spectrayan/spector/memory/neurodivergent/IcnuFusionTest.java b/spector-memory/src/test/java/com/spectrayan/spector/memory/neurodivergent/IcnuFusionTest.java
deleted file mode 100644
index 6981536..0000000
--- a/spector-memory/src/test/java/com/spectrayan/spector/memory/neurodivergent/IcnuFusionTest.java
+++ /dev/null
@@ -1,145 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.neurodivergent;
-
-import org.junit.jupiter.api.Test;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.data.Offset.offset;
-
-/**
- * Tests for {@link IngestionHints} and {@link IcnuWeights} — ICNU fusion formula.
- */
-class IcnuFusionTest {
-
-    // ── IngestionHints tests ──
-
-    @Test
-    void hints_clampsToUnitRange() {
-        var hints = new IngestionHints(2.0f, -1.0f, 0.5f);
-        assertThat(hints.interest()).isEqualTo(1.0f);
-        assertThat(hints.challenge()).isEqualTo(0.0f);
-        assertThat(hints.urgency()).isEqualTo(0.5f);
-    }
-
-    @Test
-    void hints_noneIsEmpty() {
-        assertThat(IngestionHints.NONE.isEmpty()).isTrue();
-    }
-
-    @Test
-    void hints_nonZeroIsNotEmpty() {
-        var hints = new IngestionHints(0.5f, 0f, 0f);
-        assertThat(hints.isEmpty()).isFalse();
-    }
-
-    // ── IcnuWeights tests ──
-
-    @Test
-    void defaultWeights_sumToOne() {
-        var w = IcnuWeights.DEFAULT;
-        float sum = w.interest() + w.challenge() + w.novelty() + w.urgency();
-        assertThat(sum).isCloseTo(1.0f, offset(0.001f));
-    }
-
-    @Test
-    void weights_normalizeOnConstruction() {
-        var w = new IcnuWeights(1f, 1f, 1f, 1f);
-        assertThat(w.interest()).isCloseTo(0.25f, offset(0.001f));
-        assertThat(w.novelty()).isCloseTo(0.25f, offset(0.001f));
-    }
-
-    @Test
-    void fuse_allMax_producesHighImportance() {
-        // Sigmoid gating: allMax stimulus is ~0.6 (I×N interaction), gated → ~0.96
-        var w = IcnuWeights.DEFAULT;
-        float importance = w.fuse(1.0f, 1.0f, 1.0f, 1.0f);
-        // With sigmoid, importance should be high but not exactly 10.0
-        assertThat(importance).isGreaterThan(8.0f);
-    }
-
-    @Test
-    void fuse_allMax_linearMode_producesExactMax() {
-        // LINEAR mode (steepness=0) should produce exact max
-        var w = IcnuWeights.LINEAR;
-        float importance = w.fuse(1.0f, 1.0f, 1.0f, 1.0f);
-        assertThat(importance).isCloseTo(10.0f, offset(0.01f));
-    }
-
-    @Test
-    void fuse_allZero_producesLowImportance() {
-        // Sigmoid gating: allZero stimulus is 0, gated → sigmoid(-k×θ) ≈ 0.17
-        var w = IcnuWeights.DEFAULT;
-        float importance = w.fuse(0f, 0f, 0f, 0f);
-        // With sigmoid, importance should be low but slightly above MIN (0.05)
-        assertThat(importance).isLessThan(2.0f);
-        assertThat(importance).isGreaterThanOrEqualTo(0.05f);
-    }
-
-    @Test
-    void fuse_allZero_linearMode_producesExactMin() {
-        // LINEAR mode (steepness=0) should produce exact min
-        var w = IcnuWeights.LINEAR;
-        float importance = w.fuse(0f, 0f, 0f, 0f);
-        assertThat(importance).isCloseTo(0.05f, offset(0.01f));
-    }
-
-    @Test
-    void fuse_noveltyOnlyMode_ignoresHints() {
-        // NOVELTY_ONLY has interest=0, so I×N = 0×novelty = 0
-        // Only urgency (which is also 0) contributes. Sigmoid gates the result.
-        var w = IcnuWeights.NOVELTY_ONLY;
-        // noveltyNorm=0.5, but with I=0, I×N=0. No signal gets through sigmoid.
-        float lowNovelty = w.fuse(1.0f, 1.0f, 0.2f, 1.0f);
-        float highNovelty = w.fuse(1.0f, 1.0f, 0.9f, 1.0f);
-        // Higher novelty should still produce higher importance (via I×N)
-        // But since interest=0, both should be similar (sigmoid-gated noise)
-        // The key insight: novelty-only is now sigmoid-gated, producing near-threshold output
-        assertThat(lowNovelty).isGreaterThanOrEqualTo(0.05f);
-        assertThat(highNovelty).isGreaterThanOrEqualTo(0.05f);
-    }
-
-    @Test
-    void fuse_sigmoid_thresholdEffect() {
-        // Below threshold (0.2), importance should be low
-        // Above threshold, importance should be high
-        var w = IcnuWeights.DEFAULT;
-        float belowThreshold = w.fuse(0.1f, 0.1f, 0.1f, 0.1f);
-        float aboveThreshold = w.fuse(0.9f, 0.9f, 0.9f, 0.9f);
-        assertThat(aboveThreshold).isGreaterThan(belowThreshold * 2);
-    }
-
-    @Test
-    void fuse_withEmptyHints_fallsBackToNoveltyOnly() {
-        var w = IcnuWeights.DEFAULT;
-        float withHints = w.fuse(IngestionHints.NONE, 0.5f);
-        float noveltyOnly = IcnuWeights.NOVELTY_ONLY.fuse(0f, 0f, 0.5f, 0f);
-        assertThat(withHints).isCloseTo(noveltyOnly, offset(0.01f));
-    }
-
-    @Test
-    void fuse_ordering_novelHighUrgent_beats_novelLowUrgent() {
-        var w = IcnuWeights.DEFAULT;
-        float highUrgent = w.fuse(0.8f, 0.5f, 0.9f, 0.9f);
-        float lowUrgent  = w.fuse(0.8f, 0.5f, 0.9f, 0.1f);
-        assertThat(highUrgent).isGreaterThan(lowUrgent);
-    }
-
-    @Test
-    void fuse_ordering_novel_beats_routine() {
-        var w = IcnuWeights.DEFAULT;
-        float novel   = w.fuse(0.5f, 0.5f, 0.9f, 0.5f);
-        float routine = w.fuse(0.5f, 0.5f, 0.1f, 0.5f);
-        assertThat(novel).isGreaterThan(routine);
-    }
-}
diff --git a/spector-memory/src/test/java/com/spectrayan/spector/memory/neurodivergent/LateralEvaluatorTest.java b/spector-memory/src/test/java/com/spectrayan/spector/memory/neurodivergent/LateralEvaluatorTest.java
deleted file mode 100644
index ce817c0..0000000
--- a/spector-memory/src/test/java/com/spectrayan/spector/memory/neurodivergent/LateralEvaluatorTest.java
+++ /dev/null
@@ -1,104 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.neurodivergent;
-
-import org.junit.jupiter.api.Test;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-/**
- * Tests for {@link LateralEvaluator} — lateral retrieval evaluation and auto-tuning.
- */
-class LateralEvaluatorTest {
-
-    @Test
-    void emptyMetrics_whenNoResults() {
-        var eval = new LateralEvaluator();
-        var metrics = eval.metrics();
-        assertThat(metrics.sampleSize()).isZero();
-        assertThat(metrics.utilityRate()).isZero();
-    }
-
-    @Test
-    void lateralEnabled_byDefault() {
-        var eval = new LateralEvaluator();
-        assertThat(eval.isLateralEnabled()).isTrue();
-    }
-
-    @Test
-    void metrics_computeCorrectly() {
-        var eval = new LateralEvaluator(1.2f, 10); // small window for testing
-        // Return 10 lateral results, reinforce 3, suppress 2
-        for (int i = 0; i < 10; i++) eval.recordLateralReturn();
-        for (int i = 0; i < 3; i++) eval.recordLateralReinforcement();
-        for (int i = 0; i < 2; i++) eval.recordLateralSuppression();
-
-        var metrics = eval.metrics();
-        // After 10 returns (= evaluation window), the checkAndTune should have reset
-        // because the first reinforcement after 10 returns triggers evaluation.
-        // LUR = 1/10 = 0.1, which triggers tightening, then reset.
-        // After reset, we get remaining reinforcements counted from scratch.
-        // This test verifies the evaluator doesn't crash and stays enabled.
-        assertThat(eval.isLateralEnabled()).isTrue();
-    }
-
-    @Test
-    void autoDisable_whenLurBelowThreshold() {
-        var eval = new LateralEvaluator(1.2f, 10); // small window
-        // 10 returns, 0 reinforcements → LUR = 0.0
-        for (int i = 0; i < 10; i++) eval.recordLateralReturn();
-        // First suppression triggers evaluation
-        eval.recordLateralSuppression(); // LUR = 0/10 = 0 → auto-disable
-        assertThat(eval.isLateralEnabled()).isFalse();
-    }
-
-    @Test
-    void reEnable_afterManualOverride() {
-        var eval = new LateralEvaluator(1.2f, 10);
-        for (int i = 0; i < 10; i++) eval.recordLateralReturn();
-        eval.recordLateralSuppression(); // triggers auto-disable
-        assertThat(eval.isLateralEnabled()).isFalse();
-
-        eval.enableLateral();
-        assertThat(eval.isLateralEnabled()).isTrue();
-    }
-
-    @Test
-    void threshold_tightened_whenLurMarginal() {
-        var eval = new LateralEvaluator(1.2f, 20);
-        // 20 returns, 1 reinforcement → LUR = 1/20 = 0.05 → auto-disable
-        for (int i = 0; i < 20; i++) eval.recordLateralReturn();
-        eval.recordLateralReinforcement(); // LUR = 1/20 = 0.05 → auto-disable
-        // 0.05 is at the boundary — should auto-disable (< 0.05 is strictly disabled)
-        // Let's test with slightly higher LUR
-        eval.reset();
-        for (int i = 0; i < 20; i++) eval.recordLateralReturn();
-        // 2 reinforcements → LUR = 2/20 = 0.1 → borderline tightening
-        eval.recordLateralReinforcement();
-        eval.recordLateralReinforcement(); // LUR ≈ 0.1 → triggers tighten check
-        // After tightening, threshold should be higher
-        assertThat(eval.currentDistanceThreshold()).isGreaterThanOrEqualTo(1.2f);
-    }
-
-    @Test
-    void reset_clearsCountersAndReEnables() {
-        var eval = new LateralEvaluator(1.2f, 10);
-        for (int i = 0; i < 10; i++) eval.recordLateralReturn();
-        eval.recordLateralSuppression();
-        assertThat(eval.isLateralEnabled()).isFalse();
-
-        eval.reset();
-        assertThat(eval.isLateralEnabled()).isTrue();
-        assertThat(eval.metrics().sampleSize()).isZero();
-    }
-}
diff --git a/spector-memory/src/test/java/com/spectrayan/spector/memory/neurodivergent/NeurodivergentProfileTest.java b/spector-memory/src/test/java/com/spectrayan/spector/memory/neurodivergent/NeurodivergentProfileTest.java
deleted file mode 100644
index 61238ae..0000000
--- a/spector-memory/src/test/java/com/spectrayan/spector/memory/neurodivergent/NeurodivergentProfileTest.java
+++ /dev/null
@@ -1,167 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.neurodivergent;
-
-import com.spectrayan.spector.memory.CognitiveProfile;
-import com.spectrayan.spector.memory.CognitiveResult;
-import com.spectrayan.spector.memory.CognitiveResult.RetrievalMode;
-import com.spectrayan.spector.memory.MemoryType;
-import com.spectrayan.spector.memory.RecallOptions;
-import com.spectrayan.spector.memory.cortex.MemorySource;
-import org.junit.jupiter.api.Test;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.data.Offset.offset;
-
-/**
- * Tests for neurodivergent cognitive profiles — HYPERFOCUS, SYSTEMATIZER, DIVERGENT.
- */
-class NeurodivergentProfileTest {
-
-    // ── CognitiveProfile.HYPERFOCUS ──
-
-    @Test
-    void hyperfocus_pureSimilarityScoring() {
-        assertThat(CognitiveProfile.HYPERFOCUS.alpha()).isEqualTo(1.0f);
-        assertThat(CognitiveProfile.HYPERFOCUS.beta()).isEqualTo(0.0f);
-    }
-
-    @Test
-    void hyperfocus_applySetsBoost() {
-        RecallOptions opts = RecallOptions.builder()
-                .profile(CognitiveProfile.HYPERFOCUS)
-                .build();
-        assertThat(opts.alpha()).isEqualTo(1.0f);
-        assertThat(opts.beta()).isEqualTo(0.0f);
-        assertThat(opts.hyperfocusBoost()).isEqualTo(1.5f);
-    }
-
-    @Test
-    void hyperfocus_noPin() {
-        assertThat(CognitiveProfile.HYPERFOCUS.pinSourceEpisodes()).isFalse();
-    }
-
-    // ── CognitiveProfile.SYSTEMATIZER ──
-
-    @Test
-    void systematizer_importanceDominated() {
-        assertThat(CognitiveProfile.SYSTEMATIZER.beta())
-                .isGreaterThan(CognitiveProfile.SYSTEMATIZER.alpha());
-    }
-
-    @Test
-    void systematizer_pinsSourceEpisodes() {
-        assertThat(CognitiveProfile.SYSTEMATIZER.pinSourceEpisodes()).isTrue();
-    }
-
-    // ── CognitiveProfile.DIVERGENT ──
-
-    @Test
-    void divergent_enablesLateralMode() {
-        RecallOptions opts = RecallOptions.builder()
-                .profile(CognitiveProfile.DIVERGENT)
-                .build();
-        assertThat(opts.lateralMode()).isTrue();
-    }
-
-    @Test
-    void divergent_similarityBiased() {
-        assertThat(CognitiveProfile.DIVERGENT.alpha())
-                .isGreaterThan(CognitiveProfile.DIVERGENT.beta());
-    }
-
-    @Test
-    void divergent_noPin() {
-        assertThat(CognitiveProfile.DIVERGENT.pinSourceEpisodes()).isFalse();
-    }
-
-    // ── RecallOptions neurodivergent fields ──
-
-    @Test
-    void hyperfocusMask_encodesFromTags() {
-        RecallOptions opts = RecallOptions.builder()
-                .hyperfocusMask("database", "deadlock")
-                .build();
-        assertThat(opts.hyperfocusMask()).isNotZero();
-    }
-
-    @Test
-    void lateralMode_defaults() {
-        RecallOptions opts = RecallOptions.DEFAULT;
-        assertThat(opts.lateralMode()).isFalse();
-        assertThat(opts.lateralDistanceThreshold()).isCloseTo(1.2f, offset(0.01f));
-        assertThat(opts.lateralMaxResults()).isGreaterThan(0);
-        assertThat(opts.lateralMinTagOverlap()).isCloseTo(0.5f, offset(0.01f));
-    }
-
-    @Test
-    void lateralMaxResults_autoCalculated() {
-        RecallOptions opts = RecallOptions.builder()
-                .topK(15)
-                .build();
-        assertThat(opts.lateralMaxResults()).isEqualTo(5); // 15/3 = 5
-    }
-
-    @Test
-    void lateralMaxResults_explicitOverride() {
-        RecallOptions opts = RecallOptions.builder()
-                .topK(15)
-                .lateralMaxResults(7)
-                .build();
-        assertThat(opts.lateralMaxResults()).isEqualTo(7);
-    }
-
-    // ── RetrievalMode & CognitiveResult ──
-
-    @Test
-    void retrievalMode_standardByDefault() {
-        var result = new CognitiveResult(
-                "test-id", "text", 0.8f, 1.0f, 0f,
-                0, (byte) 0, MemoryType.EPISODIC, MemorySource.OBSERVED,
-                new String[]{"tag"}, 1.0f, 1.0f);
-        assertThat(result.retrievalMode()).isEqualTo(RetrievalMode.STANDARD);
-        assertThat(result.isLateral()).isFalse();
-        assertThat(result.isHyperfocused()).isFalse();
-    }
-
-    @Test
-    void retrievalMode_lateral() {
-        var result = new CognitiveResult(
-                "test-id", "text", 0.5f, 1.0f, 0f,
-                0, (byte) 0, MemoryType.SEMANTIC, MemorySource.OBSERVED,
-                new String[]{"cross-domain"}, 1.0f, 1.0f, RetrievalMode.LATERAL);
-        assertThat(result.isLateral()).isTrue();
-        assertThat(result.isHyperfocused()).isFalse();
-    }
-
-    @Test
-    void retrievalMode_hyperfocus() {
-        var result = new CognitiveResult(
-                "test-id", "text", 0.9f, 1.0f, 90f,
-                0, (byte) 0, MemoryType.EPISODIC, MemorySource.OBSERVED,
-                new String[]{"focus"}, 1.0f, 1.0f, RetrievalMode.HYPERFOCUS);
-        assertThat(result.isHyperfocused()).isTrue();
-        assertThat(result.isLateral()).isFalse();
-    }
-
-    // ── Alpha + Beta normalization for all profiles ──
-
-    @Test
-    void allProfiles_alphaAndBeta_sumToOne() {
-        for (CognitiveProfile profile : CognitiveProfile.values()) {
-            float sum = profile.alpha() + profile.beta();
-            assertThat(sum).as("alpha + beta for %s", profile)
-                    .isCloseTo(1.0f, offset(0.001f));
-        }
-    }
-}
diff --git a/spector-memory/src/test/java/com/spectrayan/spector/memory/prospective/ProspectiveSchedulerTest.java b/spector-memory/src/test/java/com/spectrayan/spector/memory/prospective/ProspectiveSchedulerTest.java
deleted file mode 100644
index 63f8f04..0000000
--- a/spector-memory/src/test/java/com/spectrayan/spector/memory/prospective/ProspectiveSchedulerTest.java
+++ /dev/null
@@ -1,90 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.prospective;
-
-import org.junit.jupiter.api.Test;
-
-import java.time.Duration;
-import java.time.Instant;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-class ProspectiveSchedulerTest {
-
-    @Test
-    void scheduleAndCollectDue() {
-        var scheduler = new ProspectiveScheduler();
-        Instant past = Instant.now().minus(Duration.ofMinutes(5));
-        scheduler.schedule("Check build status", past, "ci", "build");
-
-        var due = scheduler.collectDue();
-        assertThat(due).hasSize(1);
-        assertThat(due.getFirst().text()).isEqualTo("Check build status");
-        assertThat(scheduler.pendingCount()).isZero(); // removed after collection
-    }
-
-    @Test
-    void futureReminderNotDueYet() {
-        var scheduler = new ProspectiveScheduler();
-        Instant future = Instant.now().plus(Duration.ofHours(1));
-        scheduler.schedule("Future reminder", future, "later");
-
-        var due = scheduler.collectDue();
-        assertThat(due).isEmpty();
-        assertThat(scheduler.pendingCount()).isEqualTo(1);
-    }
-
-    @Test
-    void collectDueAtSpecificTime() {
-        var scheduler = new ProspectiveScheduler();
-        Instant target = Instant.parse("2026-12-01T10:00:00Z");
-        scheduler.schedule("Year-end review", target, "review");
-
-        // Not due yet
-        var beforeDue = scheduler.collectDueAt(Instant.parse("2026-11-01T10:00:00Z"));
-        assertThat(beforeDue).isEmpty();
-
-        // Now it's due
-        var afterDue = scheduler.collectDueAt(Instant.parse("2026-12-02T10:00:00Z"));
-        assertThat(afterDue).hasSize(1);
-    }
-
-    @Test
-    void scheduleAfterConvenience() {
-        var scheduler = new ProspectiveScheduler();
-        var reminder = scheduler.scheduleAfter("Check in 30min", Duration.ofMinutes(30), "followup");
-
-        assertThat(reminder.id()).startsWith("prospective-");
-        assertThat(reminder.triggerAt()).isAfter(Instant.now());
-        assertThat(scheduler.pendingCount()).isEqualTo(1);
-    }
-
-    @Test
-    void cancelAllClearsPending() {
-        var scheduler = new ProspectiveScheduler();
-        scheduler.scheduleAfter("r1", Duration.ofHours(1), "a");
-        scheduler.scheduleAfter("r2", Duration.ofHours(2), "b");
-
-        scheduler.cancelAll();
-        assertThat(scheduler.pendingCount()).isZero();
-    }
-
-    @Test
-    void reminderIsDue() {
-        var past = new Reminder("id", "text", Instant.now().minusSeconds(10), 0L, Instant.now());
-        assertThat(past.isDue()).isTrue();
-
-        var future = new Reminder("id", "text", Instant.now().plusSeconds(60), 0L, Instant.now());
-        assertThat(future.isDue()).isFalse();
-    }
-}
diff --git a/spector-memory/src/test/java/com/spectrayan/spector/memory/synapse/CognitiveRecordLayoutTest.java b/spector-memory/src/test/java/com/spectrayan/spector/memory/synapse/CognitiveRecordLayoutTest.java
deleted file mode 100644
index 552a753..0000000
--- a/spector-memory/src/test/java/com/spectrayan/spector/memory/synapse/CognitiveRecordLayoutTest.java
+++ /dev/null
@@ -1,185 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.synapse;
-
-import com.spectrayan.spector.memory.MemoryType;
-import org.junit.jupiter.api.Test;
-
-import java.lang.foreign.Arena;
-import java.lang.foreign.MemorySegment;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-/**
- * Tests for {@link CognitiveRecordLayout} — versioned header read/write.
- */
-class CognitiveRecordLayoutTest {
-
-    private static final int VECTOR_BYTES = 768; // 768 bytes for quantized vector
-    private final CognitiveRecordLayout layout = new CognitiveRecordLayout(VECTOR_BYTES);
-
-    @Test
-    void strideIs32PlusVectorBytes() {
-        assertThat(layout.stride()).isEqualTo(64 + VECTOR_BYTES);
-    }
-
-    @Test
-    void vectorOffsetIs32() {
-        assertThat(layout.vectorOffset(0)).isEqualTo(64);
-        assertThat(layout.vectorOffset(832)).isEqualTo(896);
-    }
-
-    @Test
-    void writeAndReadHeaderRoundtrip() {
-        try (var arena = Arena.ofConfined()) {
-            MemorySegment segment = arena.allocate(layout.stride());
-
-            long timestamp = System.currentTimeMillis();
-            long tags = SynapticTagEncoder.encode("java", "performance");
-            var header = new CognitiveRecordLayout.CognitiveHeader(
-                    timestamp, tags, 1.5f, 0.8f, 7,
-                    (short) 42, (byte) -50, (byte) 0x12
-            );
-
-            layout.writeHeader(segment, 0, header);
-            var readBack = layout.readHeader(segment, 0);
-
-            assertThat(readBack.timestampMs()).isEqualTo(timestamp);
-            assertThat(readBack.synapticTags()).isEqualTo(tags);
-            assertThat(readBack.exactNorm()).isEqualTo(1.5f);
-            assertThat(readBack.importance()).isEqualTo(0.8f);
-            assertThat(readBack.centroidId()).isEqualTo((short) 42);
-            assertThat(readBack.recallCount()).isEqualTo(7);
-            assertThat(readBack.valence()).isEqualTo((byte) -50);
-            assertThat(readBack.flags()).isEqualTo((byte) 0x12);
-        }
-    }
-
-    @Test
-    void fieldLevelAccessors() {
-        try (var arena = Arena.ofConfined()) {
-            MemorySegment segment = arena.allocate(layout.stride());
-
-            long timestamp = 12345L;
-            long tags = 0xDEAD_BEEF_CAFE_BABEL;
-            var header = CognitiveRecordLayout.CognitiveHeader.create(
-                    timestamp, tags, 2.0f, 5.0f, (short) 99, MemoryType.SEMANTIC
-            );
-
-            layout.writeHeader(segment, 0, header);
-
-            assertThat(layout.readTimestamp(segment, 0)).isEqualTo(timestamp);
-            assertThat(layout.readSynapticTags(segment, 0)).isEqualTo(tags);
-            assertThat(layout.readImportance(segment, 0)).isEqualTo(5.0f);
-            assertThat(layout.readRecallCount(segment, 0)).isZero();
-            assertThat(layout.readValence(segment, 0)).isZero();
-        }
-    }
-
-    @Test
-    void incrementRecallCountIsAtomic() {
-        try (var arena = Arena.ofConfined()) {
-            MemorySegment segment = arena.allocate(layout.stride());
-
-            var header = CognitiveRecordLayout.CognitiveHeader.create(
-                    System.currentTimeMillis(), 0L, 1.0f, 1.0f, (short) 0, MemoryType.EPISODIC
-            );
-            layout.writeHeader(segment, 0, header);
-
-            // Initial recall count = 0
-            assertThat(layout.readRecallCount(segment, 0)).isZero();
-
-            // Increment and check return value (old value)
-            int old1 = layout.incrementRecallCount(segment, 0);
-            assertThat(old1).isZero();
-            assertThat(layout.readRecallCount(segment, 0)).isEqualTo(1);
-
-            // Increment again
-            int old2 = layout.incrementRecallCount(segment, 0);
-            assertThat(old2).isEqualTo(1);
-            assertThat(layout.readRecallCount(segment, 0)).isEqualTo(2);
-        }
-    }
-
-    @Test
-    void tombstoneSetsFlagBit() {
-        try (var arena = Arena.ofConfined()) {
-            MemorySegment segment = arena.allocate(layout.stride());
-
-            var header = CognitiveRecordLayout.CognitiveHeader.create(
-                    System.currentTimeMillis(), 0L, 1.0f, 1.0f, (short) 0, MemoryType.EPISODIC
-            );
-            layout.writeHeader(segment, 0, header);
-
-            assertThat(SynapticHeaderConstants.isTombstoned(layout.readFlags(segment, 0))).isFalse();
-
-            layout.tombstone(segment, 0);
-
-            assertThat(SynapticHeaderConstants.isTombstoned(layout.readFlags(segment, 0))).isTrue();
-        }
-    }
-
-    @Test
-    void markConsolidatedSetsFlagBit() {
-        try (var arena = Arena.ofConfined()) {
-            MemorySegment segment = arena.allocate(layout.stride());
-
-            var header = CognitiveRecordLayout.CognitiveHeader.create(
-                    System.currentTimeMillis(), 0L, 1.0f, 1.0f, (short) 0, MemoryType.EPISODIC
-            );
-            layout.writeHeader(segment, 0, header);
-
-            layout.markConsolidated(segment, 0);
-
-            assertThat(SynapticHeaderConstants.isConsolidated(layout.readFlags(segment, 0))).isTrue();
-        }
-    }
-
-    @Test
-    void memoryTypeEncodedInFlags() {
-        try (var arena = Arena.ofConfined()) {
-            MemorySegment segment = arena.allocate(layout.stride());
-
-            for (MemoryType type : MemoryType.values()) {
-                var header = CognitiveRecordLayout.CognitiveHeader.create(
-                        System.currentTimeMillis(), 0L, 1.0f, 1.0f, (short) 0, type
-                );
-                layout.writeHeader(segment, 0, header);
-
-                byte flags = layout.readFlags(segment, 0);
-                assertThat(SynapticHeaderConstants.memoryTypeOrdinal(flags))
-                        .as("MemoryType %s", type)
-                        .isEqualTo(type.ordinal());
-            }
-        }
-    }
-
-    @Test
-    void mergeSynapticTagsORsExisting() {
-        try (var arena = Arena.ofConfined()) {
-            MemorySegment segment = arena.allocate(layout.stride());
-
-            long initialTags = SynapticTagEncoder.encode("java");
-            var header = CognitiveRecordLayout.CognitiveHeader.create(
-                    System.currentTimeMillis(), initialTags, 1.0f, 1.0f, (short) 0, MemoryType.SEMANTIC
-            );
-            layout.writeHeader(segment, 0, header);
-
-            long additionalTags = SynapticTagEncoder.encode("performance");
-            layout.mergeSynapticTags(segment, 0, additionalTags);
-
-            long merged = layout.readSynapticTags(segment, 0);
-            assertThat(merged).isEqualTo(initialTags | additionalTags);
-        }
-    }
-}
diff --git a/spector-memory/src/test/java/com/spectrayan/spector/memory/synapse/DecayStrategyTest.java b/spector-memory/src/test/java/com/spectrayan/spector/memory/synapse/DecayStrategyTest.java
deleted file mode 100644
index dd71dab..0000000
--- a/spector-memory/src/test/java/com/spectrayan/spector/memory/synapse/DecayStrategyTest.java
+++ /dev/null
@@ -1,123 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.synapse;
-
-import org.junit.jupiter.api.Test;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-/**
- * Tests for {@link DecayStrategy} — bucket-based decay with reconsolidation.
- */
-class DecayStrategyTest {
-
-    @Test
-    void freshMemoryGetsBucketZero() {
-        long now = System.currentTimeMillis();
-        int bucket = DecayStrategy.ageToBucket(now - 1000, now); // 1 second old
-
-        assertThat(bucket).isZero();
-        assertThat(DecayStrategy.decay(bucket)).isEqualTo(1.0f);
-    }
-
-    @Test
-    void twoHourOldMemoryGetsBucketOne() {
-        long now = System.currentTimeMillis();
-        long twoHoursAgo = now - 2 * 3_600_000L;
-        int bucket = DecayStrategy.ageToBucket(twoHoursAgo, now);
-
-        assertThat(bucket).isEqualTo(1);
-        assertThat(DecayStrategy.decay(bucket)).isEqualTo(0.95f);
-    }
-
-    @Test
-    void oneDayOldMemoryGetsBucketTwo() {
-        long now = System.currentTimeMillis();
-        long halfDayAgo = now - 12 * 3_600_000L;
-        int bucket = DecayStrategy.ageToBucket(halfDayAgo, now);
-
-        assertThat(bucket).isEqualTo(2);
-        assertThat(DecayStrategy.decay(bucket)).isEqualTo(0.85f);
-    }
-
-    @Test
-    void veryOldMemoryGetsMaxBucket() {
-        long now = System.currentTimeMillis();
-        long sixMonthsAgo = now - 180L * 86_400_000L;
-        int bucket = DecayStrategy.ageToBucket(sixMonthsAgo, now);
-
-        assertThat(bucket).isEqualTo(DecayStrategy.MAX_BUCKET);
-        assertThat(DecayStrategy.decay(bucket)).isEqualTo(0.05f);
-    }
-
-    @Test
-    void futureTimestampTreatedAsFresh() {
-        long now = System.currentTimeMillis();
-        long future = now + 100_000;
-        int bucket = DecayStrategy.ageToBucket(future, now);
-
-        assertThat(bucket).isZero();
-    }
-
-    @Test
-    void reconsolidationShiftsBucketFresher() {
-        // A memory in bucket 6 (1-3 months old) — using 6 for clearer bit-shift demo
-        int rawBucket = 6;
-
-        // No recalls → stays at bucket 6
-        assertThat(DecayStrategy.adjustForReconsolidation(rawBucket, (short) 0)).isEqualTo(6);
-
-        // 1 recall → bucket >> 1 = 3 (halves perceived age)
-        assertThat(DecayStrategy.adjustForReconsolidation(rawBucket, (short) 1)).isEqualTo(3);
-
-        // 2 recalls → bucket >> 2 = 1 (quarter perceived age)
-        assertThat(DecayStrategy.adjustForReconsolidation(rawBucket, (short) 2)).isEqualTo(1);
-
-        // 3 recalls → bucket >> 3 = 0 (effectively fresh)
-        assertThat(DecayStrategy.adjustForReconsolidation(rawBucket, (short) 3)).isEqualTo(0);
-
-        // 5+ recalls → capped at shift 5, bucket >> 5 = 0
-        assertThat(DecayStrategy.adjustForReconsolidation(rawBucket, (short) 10)).isZero();
-    }
-
-    @Test
-    void reconsolidationNeverGoesBelowZero() {
-        int rawBucket = 1;
-        short manyRecalls = 100;
-
-        assertThat(DecayStrategy.adjustForReconsolidation(rawBucket, manyRecalls)).isZero();
-    }
-
-    @Test
-    void computeDecayIntegratesAllSteps() {
-        long now = System.currentTimeMillis();
-        long twoDaysAgo = now - 2 * 86_400_000L;
-
-        // Without recalls: bucket 3, decay = 0.70
-        float decayNoRecalls = DecayStrategy.computeDecay(twoDaysAgo, now, (short) 0);
-        assertThat(decayNoRecalls).isEqualTo(0.70f);
-
-        // With 1 recall: bucket shifts from 3 >> 1 = 1, decay = 0.95
-        float decayWithRecalls = DecayStrategy.computeDecay(twoDaysAgo, now, (short) 1);
-        assertThat(decayWithRecalls).isEqualTo(0.95f);
-    }
-
-    @Test
-    void decayBucketsAreMonotonicallyDecreasing() {
-        for (int i = 1; i < DecayStrategy.DECAY_BUCKETS.length; i++) {
-            assertThat(DecayStrategy.DECAY_BUCKETS[i])
-                    .as("Bucket %d should be less than bucket %d", i, i - 1)
-                    .isLessThan(DecayStrategy.DECAY_BUCKETS[i - 1]);
-        }
-    }
-}
diff --git a/spector-memory/src/test/java/com/spectrayan/spector/memory/synapse/SynapticTagEncoderTest.java b/spector-memory/src/test/java/com/spectrayan/spector/memory/synapse/SynapticTagEncoderTest.java
deleted file mode 100644
index 6ab628f..0000000
--- a/spector-memory/src/test/java/com/spectrayan/spector/memory/synapse/SynapticTagEncoderTest.java
+++ /dev/null
@@ -1,120 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.synapse;
-
-import org.junit.jupiter.api.Test;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-/**
- * Tests for {@link SynapticTagEncoder} — 64-bit inline Bloom filter.
- */
-class SynapticTagEncoderTest {
-
-    @Test
-    void singleTagProducesNonZeroBits() {
-        long filter = SynapticTagEncoder.encodeTag("java");
-        assertThat(filter).isNotZero();
-        assertThat(Long.bitCount(filter)).isBetween(1, 3); // k=3 hash functions
-    }
-
-    @Test
-    void multipleTagsEncodeViaOR() {
-        long single1 = SynapticTagEncoder.encodeTag("java");
-        long single2 = SynapticTagEncoder.encodeTag("performance");
-        long combined = SynapticTagEncoder.encode("java", "performance");
-
-        assertThat(combined).isEqualTo(single1 | single2);
-    }
-
-    @Test
-    void matchesReturnsTrueForSubsetTags() {
-        long record = SynapticTagEncoder.encode("java", "performance", "coding");
-        long query = SynapticTagEncoder.encode("java", "coding");
-
-        assertThat(SynapticTagEncoder.matches(record, query)).isTrue();
-    }
-
-    @Test
-    void matchesReturnsFalseForNonSubsetTags() {
-        long record = SynapticTagEncoder.encode("java", "performance");
-        long query = SynapticTagEncoder.encode("python", "ml");
-
-        // May or may not match depending on hash collisions, but usually doesn't
-        // This test verifies the mechanism works for clearly disjoint tag sets
-        // Note: Bloom filters can have false positives, so we test with a known non-match
-        long emptyRecord = 0L;
-        assertThat(SynapticTagEncoder.matches(emptyRecord, query)).isFalse();
-    }
-
-    @Test
-    void emptyQueryMatchesEverything() {
-        long record = SynapticTagEncoder.encode("java", "performance");
-        long emptyQuery = 0L;
-
-        assertThat(SynapticTagEncoder.matches(record, emptyQuery)).isTrue();
-    }
-
-    @Test
-    void mergeORsCombinesFilters() {
-        long a = SynapticTagEncoder.encode("java");
-        long b = SynapticTagEncoder.encode("python");
-        long merged = SynapticTagEncoder.merge(a, b);
-
-        assertThat(merged).isEqualTo(a | b);
-        assertThat(SynapticTagEncoder.matches(merged, a)).isTrue();
-        assertThat(SynapticTagEncoder.matches(merged, b)).isTrue();
-    }
-
-    @Test
-    void bitCountReflectsTagDensity() {
-        long sparse = SynapticTagEncoder.encode("java");
-        long dense = SynapticTagEncoder.encode("java", "python", "rust", "go", "kotlin");
-
-        assertThat(SynapticTagEncoder.bitCount(dense))
-                .isGreaterThanOrEqualTo(SynapticTagEncoder.bitCount(sparse));
-    }
-
-    @Test
-    void deterministicEncoding() {
-        long a = SynapticTagEncoder.encodeTag("java");
-        long b = SynapticTagEncoder.encodeTag("java");
-
-        assertThat(a).isEqualTo(b);
-    }
-
-    @Test
-    void falsePositiveRateIsAcceptable() {
-        // Encode 20 tags into a single record's filter
-        String[] tags = new String[20];
-        for (int i = 0; i < 20; i++) {
-            tags[i] = "tag-" + i;
-        }
-        long filter = SynapticTagEncoder.encode(tags);
-
-        // Test 1000 random non-existent tags for false positives
-        int falsePositives = 0;
-        for (int i = 100; i < 1100; i++) {
-            long testMask = SynapticTagEncoder.encodeTag("nonexistent-" + i);
-            if (SynapticTagEncoder.matches(filter, testMask)) {
-                falsePositives++;
-            }
-        }
-
-        // With 20 tags and k=3 (60 bit positions out of 64), saturation is near-total.
-        // Better hash independence distributes bits more uniformly, which can slightly
-        // increase FPR at high saturation. Allow up to 25% for this extreme case.
-        double fpr = falsePositives / 1000.0;
-        assertThat(fpr).as("False positive rate with 20 tags").isLessThan(0.25);
-    }
-}
diff --git a/spector-memory/src/test/java/com/spectrayan/spector/memory/synapse/WeightedTagScoringTest.java b/spector-memory/src/test/java/com/spectrayan/spector/memory/synapse/WeightedTagScoringTest.java
deleted file mode 100644
index c5c32f8..0000000
--- a/spector-memory/src/test/java/com/spectrayan/spector/memory/synapse/WeightedTagScoringTest.java
+++ /dev/null
@@ -1,117 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.synapse;
-
-import org.junit.jupiter.api.Test;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-/**
- * Tests for weighted tag relevance scoring.
- *
- * <p>Validates that {@link SynapticTagEncoder#overlapRatio} computes correct
- * partial match ratios and that the scoring behavior integrates properly.</p>
- */
-class WeightedTagScoringTest {
-
-    @Test
-    void fullMatch_returnsOne() {
-        long record = SynapticTagEncoder.encode("java", "performance");
-        long query = SynapticTagEncoder.encode("java", "performance");
-
-        float overlap = SynapticTagEncoder.overlapRatio(record, query);
-        assertThat(overlap).isEqualTo(1.0f);
-    }
-
-    @Test
-    void noMatch_returnsZero() {
-        // Use a guaranteed no-match: record with zero bits set
-        // (Bloom filters can have false positives between different tag sets)
-        long query = SynapticTagEncoder.encode("java", "performance");
-
-        float overlap = SynapticTagEncoder.overlapRatio(0L, query);
-        assertThat(overlap).isEqualTo(0.0f);
-    }
-
-    @Test
-    void partialMatch_returnsProportional() {
-        // Encode with 3 tags, query with subset
-        long record = SynapticTagEncoder.encode("java", "performance", "coding");
-        long querySubset = SynapticTagEncoder.encode("java");
-        long queryFull = SynapticTagEncoder.encode("java", "performance", "coding");
-
-        float subsetOverlap = SynapticTagEncoder.overlapRatio(record, querySubset);
-        float fullOverlap = SynapticTagEncoder.overlapRatio(record, queryFull);
-
-        // Subset should have overlap > 0 but < 1.0
-        assertThat(subsetOverlap).isGreaterThan(0.0f);
-        assertThat(subsetOverlap).isLessThanOrEqualTo(1.0f);
-
-        // Full overlap should be 1.0
-        assertThat(fullOverlap).isEqualTo(1.0f);
-
-        // Full match should score higher or equal
-        assertThat(fullOverlap).isGreaterThanOrEqualTo(subsetOverlap);
-    }
-
-    @Test
-    void emptyQueryMask_returnsOne() {
-        long record = SynapticTagEncoder.encode("java", "performance");
-        float overlap = SynapticTagEncoder.overlapRatio(record, 0L);
-        assertThat(overlap).isEqualTo(1.0f);
-    }
-
-    @Test
-    void emptyRecord_withQuery_returnsZero() {
-        long query = SynapticTagEncoder.encode("java");
-        float overlap = SynapticTagEncoder.overlapRatio(0L, query);
-        assertThat(overlap).isEqualTo(0.0f);
-    }
-
-    @Test
-    void boostFormula_correctMath() {
-        // Simulate the scoring formula used in CognitiveScorer Phase 6
-        float baseScore = 0.8f;
-        float tagRelevanceBoost = 0.3f;
-
-        // Full match: score * (1.0 + 1.0 * 0.3) = 0.8 * 1.3 = 1.04
-        float fullMatchScore = baseScore * (1.0f + 1.0f * tagRelevanceBoost);
-        assertThat(fullMatchScore).isCloseTo(1.04f, org.assertj.core.data.Offset.offset(0.001f));
-
-        // Half match: score * (1.0 + 0.5 * 0.3) = 0.8 * 1.15 = 0.92
-        float halfMatchScore = baseScore * (1.0f + 0.5f * tagRelevanceBoost);
-        assertThat(halfMatchScore).isCloseTo(0.92f, org.assertj.core.data.Offset.offset(0.001f));
-
-        // No boost (tagRelevanceBoost = 0): score * 1.0 = 0.8
-        float noBoostScore = baseScore * (1.0f + 1.0f * 0.0f);
-        assertThat(noBoostScore).isEqualTo(baseScore);
-
-        // Verify ordering
-        assertThat(fullMatchScore).isGreaterThan(halfMatchScore);
-        assertThat(halfMatchScore).isGreaterThan(noBoostScore);
-    }
-
-    @Test
-    void overlapWithSupersetQuery_isPartial() {
-        // Record has 2 tags, query has 3 (superset)
-        long record = SynapticTagEncoder.encode("java", "coding");
-        long query = SynapticTagEncoder.encode("java", "coding", "performance");
-
-        float overlap = SynapticTagEncoder.overlapRatio(record, query);
-
-        // Record matches java+coding bits from query but not performance bits
-        // So overlap should be < 1.0 (partial match from query's perspective)
-        assertThat(overlap).isGreaterThan(0.0f);
-        assertThat(overlap).isLessThanOrEqualTo(1.0f);
-    }
-}
diff --git a/spector-memory/src/test/java/com/spectrayan/spector/memory/sync/MemoryWalAndCloudSyncTest.java b/spector-memory/src/test/java/com/spectrayan/spector/memory/sync/MemoryWalAndCloudSyncTest.java
deleted file mode 100644
index bf280d4..0000000
--- a/spector-memory/src/test/java/com/spectrayan/spector/memory/sync/MemoryWalAndCloudSyncTest.java
+++ /dev/null
@@ -1,137 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.sync;
-
-import org.junit.jupiter.api.Test;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-class MemoryWalTest {
-
-    @Test
-    void appendAssignsMonotonicSequence() {
-        var wal = new MemoryWal();
-        var e1 = wal.appendRemember("m1", new byte[]{1, 2, 3});
-        var e2 = wal.appendRemember("m2", new byte[]{4, 5, 6});
-        var e3 = wal.appendForget("m1");
-
-        assertThat(e1.sequence()).isEqualTo(1);
-        assertThat(e2.sequence()).isEqualTo(2);
-        assertThat(e3.sequence()).isEqualTo(3);
-        assertThat(wal.highWaterMark()).isEqualTo(3);
-    }
-
-    @Test
-    void replayFromSequence() {
-        var wal = new MemoryWal();
-        wal.appendRemember("m1", null);
-        wal.appendRemember("m2", null);
-        wal.appendRemember("m3", null);
-
-        var afterFirst = wal.replay(1);
-        assertThat(afterFirst).hasSize(2);
-        assertThat(afterFirst.getFirst().memoryId()).isEqualTo("m2");
-    }
-
-    @Test
-    void replayAllFromZero() {
-        var wal = new MemoryWal();
-        wal.appendRemember("m1", null);
-        wal.appendForget("m2");
-        wal.appendReinforce("m1", (byte) 50);
-
-        var all = wal.replay(0);
-        assertThat(all).hasSize(3);
-    }
-
-    @Test
-    void eventTypesAreCaptured() {
-        var wal = new MemoryWal();
-        wal.appendRemember("m1", null);
-        wal.appendForget("m1");
-        wal.appendReinforce("m1", (byte) 50);
-
-        var events = wal.replay(0);
-        assertThat(events.get(0).type()).isEqualTo(WalEvent.EventType.REMEMBER);
-        assertThat(events.get(1).type()).isEqualTo(WalEvent.EventType.FORGET);
-        assertThat(events.get(2).type()).isEqualTo(WalEvent.EventType.REINFORCE);
-    }
-
-    @Test
-    void sizeTracksEventCount() {
-        var wal = new MemoryWal();
-        assertThat(wal.size()).isZero();
-
-        wal.appendRemember("m1", null);
-        assertThat(wal.size()).isEqualTo(1);
-
-        wal.appendForget("m1");
-        assertThat(wal.size()).isEqualTo(2);
-    }
-}
-
-class CloudSyncTest {
-
-    @Test
-    void exportEventsFromWal() {
-        var wal = new MemoryWal();
-        wal.appendRemember("m1", null);
-        wal.appendRemember("m2", null);
-        wal.appendRemember("m3", null);
-
-        var sync = new CloudSync(wal);
-        var events = sync.exportEvents(1); // after m1
-        assertThat(events).hasSize(2);
-    }
-
-    @Test
-    void importEventsUpdatesHighWaterMark() {
-        var localWal = new MemoryWal();
-        var sync = new CloudSync(localWal);
-
-        // Simulate remote events
-        var remoteEvents = List.of(
-                new WalEvent(1, WalEvent.EventType.REMEMBER, "m1",
-                        java.time.Instant.now(), new byte[0]),
-                new WalEvent(2, WalEvent.EventType.REMEMBER, "m2",
-                        java.time.Instant.now(), new byte[0])
-        );
-
-        List<String> replayed = new ArrayList<>();
-        sync.importEvents(remoteEvents, event -> replayed.add(event.memoryId()));
-
-        assertThat(replayed).containsExactly("m1", "m2");
-        assertThat(sync.remoteHighWaterMark()).isEqualTo(2);
-    }
-
-    @Test
-    void importSkipsDuplicates() {
-        var localWal = new MemoryWal();
-        var sync = new CloudSync(localWal);
-
-        var events = List.of(
-                new WalEvent(1, WalEvent.EventType.REMEMBER, "m1",
-                        java.time.Instant.now(), new byte[0])
-        );
-
-        List<String> replayed = new ArrayList<>();
-        sync.importEvents(events, e -> replayed.add(e.memoryId()));
-        sync.importEvents(events, e -> replayed.add(e.memoryId())); // duplicate
-
-        // Second import should skip (hwm already at 1)
-        assertThat(replayed).hasSize(1);
-    }
-}
diff --git a/spector-memory/src/test/java/com/spectrayan/spector/memory/sync/MemoryWalPersistenceTest.java b/spector-memory/src/test/java/com/spectrayan/spector/memory/sync/MemoryWalPersistenceTest.java
deleted file mode 100644
index c9bb5fb..0000000
--- a/spector-memory/src/test/java/com/spectrayan/spector/memory/sync/MemoryWalPersistenceTest.java
+++ /dev/null
@@ -1,378 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.sync;
-
-import org.junit.jupiter.api.AfterEach;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.io.TempDir;
-
-import java.io.IOException;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.util.List;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-/**
- * Tests for file-backed WAL persistence, crash recovery, and chunk rolling.
- */
-class MemoryWalPersistenceTest {
-
-    @TempDir
-    Path tempDir;
-
-    private Path walDir;
-
-    @BeforeEach
-    void setUp() {
-        walDir = tempDir.resolve("wal");
-    }
-
-    // ── Basic Persistence ──
-
-    @Test
-    void writeAndRecoverEvents() {
-        // Write events to file-backed WAL
-        try (MemoryWal wal = new MemoryWal(walDir)) {
-            for (int i = 0; i < 100; i++) {
-                wal.appendRemember("mem-" + i, ("payload-" + i).getBytes());
-            }
-            assertThat(wal.size()).isEqualTo(100);
-            assertThat(wal.highWaterMark()).isEqualTo(100);
-        }
-
-        // Reopen — should recover all events from disk
-        try (MemoryWal wal2 = new MemoryWal(walDir)) {
-            assertThat(wal2.size()).isEqualTo(100);
-            assertThat(wal2.highWaterMark()).isEqualTo(100);
-
-            // Verify event content
-            List<WalEvent> all = wal2.replay(0);
-            assertThat(all).hasSize(100);
-            assertThat(all.getFirst().memoryId()).isEqualTo("mem-0");
-            assertThat(all.getFirst().type()).isEqualTo(WalEvent.EventType.REMEMBER);
-            assertThat(all.getLast().memoryId()).isEqualTo("mem-99");
-        }
-    }
-
-    @Test
-    void recoverPreservesAllEventTypes() {
-        try (MemoryWal wal = new MemoryWal(walDir)) {
-            wal.appendRemember("r1", new byte[]{1, 2, 3});
-            wal.appendForget("f1");
-            wal.appendReinforce("r1", (byte) 64);
-            wal.append(WalEvent.EventType.REFLECT, "system", null);
-            wal.append(WalEvent.EventType.TAG_MERGE, "t1", new byte[]{10});
-            wal.append(WalEvent.EventType.RECALL_HIT, "r1", null);
-        }
-
-        try (MemoryWal wal2 = new MemoryWal(walDir)) {
-            List<WalEvent> all = wal2.replay(0);
-            assertThat(all).hasSize(6);
-            assertThat(all.get(0).type()).isEqualTo(WalEvent.EventType.REMEMBER);
-            assertThat(all.get(0).payload()).containsExactly(1, 2, 3);
-            assertThat(all.get(1).type()).isEqualTo(WalEvent.EventType.FORGET);
-            assertThat(all.get(2).type()).isEqualTo(WalEvent.EventType.REINFORCE);
-            assertThat(all.get(2).payload()).containsExactly(64);
-            assertThat(all.get(3).type()).isEqualTo(WalEvent.EventType.REFLECT);
-            assertThat(all.get(4).type()).isEqualTo(WalEvent.EventType.TAG_MERGE);
-            assertThat(all.get(5).type()).isEqualTo(WalEvent.EventType.RECALL_HIT);
-        }
-    }
-
-    @Test
-    void appendAfterRecovery() {
-        try (MemoryWal wal = new MemoryWal(walDir)) {
-            wal.appendRemember("a", new byte[0]);
-            wal.appendRemember("b", new byte[0]);
-        }
-
-        try (MemoryWal wal2 = new MemoryWal(walDir)) {
-            assertThat(wal2.highWaterMark()).isEqualTo(2);
-
-            // Append more events after recovery
-            wal2.appendRemember("c", new byte[0]);
-            wal2.appendRemember("d", new byte[0]);
-            assertThat(wal2.highWaterMark()).isEqualTo(4);
-            assertThat(wal2.size()).isEqualTo(4);
-        }
-
-        // Third open — should see all 4
-        try (MemoryWal wal3 = new MemoryWal(walDir)) {
-            assertThat(wal3.size()).isEqualTo(4);
-            List<WalEvent> all = wal3.replay(0);
-            assertThat(all.get(2).memoryId()).isEqualTo("c");
-            assertThat(all.get(3).memoryId()).isEqualTo("d");
-        }
-    }
-
-    // ── Replay Filtering ──
-
-    @Test
-    void replayAfterSequenceFilters() {
-        try (MemoryWal wal = new MemoryWal(walDir)) {
-            wal.appendRemember("a", new byte[0]); // seq 1
-            wal.appendRemember("b", new byte[0]); // seq 2
-            wal.appendRemember("c", new byte[0]); // seq 3
-            wal.appendForget("a");                 // seq 4
-            wal.appendRemember("d", new byte[0]); // seq 5
-
-            List<WalEvent> afterTwo = wal.replay(2);
-            assertThat(afterTwo).hasSize(3);
-            assertThat(afterTwo.get(0).sequence()).isEqualTo(3);
-            assertThat(afterTwo.get(0).memoryId()).isEqualTo("c");
-        }
-    }
-
-    // ── Chunk Rolling ──
-
-    @Test
-    void chunkRollingCreatesMultipleFiles() throws IOException {
-        // Use a tiny max chunk size to force rolling
-        long tinyChunkSize = 256; // 256 bytes
-
-        try (MemoryWal wal = new MemoryWal(walDir, tinyChunkSize)) {
-            for (int i = 0; i < 50; i++) {
-                wal.appendRemember("mem-" + i, ("large-payload-data-" + i).getBytes());
-            }
-        }
-
-        // Should have created multiple chunk files
-        long chunkCount;
-        try (var stream = Files.list(walDir)) {
-            chunkCount = stream
-                    .filter(p -> p.getFileName().toString().startsWith("wal-") &&
-                                 p.getFileName().toString().endsWith(".bin"))
-                    .count();
-        }
-        assertThat(chunkCount).isGreaterThan(1);
-
-        // Reopen — should recover all events across all chunks
-        try (MemoryWal wal2 = new MemoryWal(walDir, tinyChunkSize)) {
-            assertThat(wal2.size()).isEqualTo(50);
-            assertThat(wal2.highWaterMark()).isEqualTo(50);
-        }
-    }
-
-    // ── Disk Replay ──
-
-    @Test
-    void replayFromDiskMatchesInMemory() {
-        try (MemoryWal wal = new MemoryWal(walDir)) {
-            wal.appendRemember("x", new byte[]{1});
-            wal.appendForget("y");
-            wal.appendReinforce("x", (byte) -10);
-        }
-
-        try (MemoryWal wal2 = new MemoryWal(walDir)) {
-            List<WalEvent> fromDisk = wal2.replayFromDisk();
-            List<WalEvent> fromMemory = wal2.replay(0);
-
-            assertThat(fromDisk).hasSize(fromMemory.size());
-            for (int i = 0; i < fromDisk.size(); i++) {
-                assertThat(fromDisk.get(i).sequence()).isEqualTo(fromMemory.get(i).sequence());
-                assertThat(fromDisk.get(i).type()).isEqualTo(fromMemory.get(i).type());
-                assertThat(fromDisk.get(i).memoryId()).isEqualTo(fromMemory.get(i).memoryId());
-            }
-        }
-    }
-
-    // ── In-Memory Mode ──
-
-    @Test
-    void inMemoryModeWorksWithoutFiles() {
-        try (MemoryWal wal = new MemoryWal()) {
-            assertThat(wal.isPersistent()).isFalse();
-            assertThat(wal.path()).isNull();
-
-            wal.appendRemember("a", new byte[0]);
-            wal.appendRemember("b", new byte[0]);
-
-            assertThat(wal.size()).isEqualTo(2);
-            assertThat(wal.replay(0)).hasSize(2);
-            assertThat(wal.replayFromDisk()).isEmpty();
-        }
-    }
-
-    // ── Edge Cases ──
-
-    @Test
-    void emptyWalRecovery() {
-        // Create and immediately close
-        try (MemoryWal wal = new MemoryWal(walDir)) {
-            assertThat(wal.size()).isEqualTo(0);
-        }
-
-        // Reopen empty WAL
-        try (MemoryWal wal2 = new MemoryWal(walDir)) {
-            assertThat(wal2.size()).isEqualTo(0);
-            assertThat(wal2.highWaterMark()).isEqualTo(0);
-        }
-    }
-
-    @Test
-    void largePayloadRoundTrips() {
-        byte[] largePayload = new byte[4096];
-        for (int i = 0; i < largePayload.length; i++) {
-            largePayload[i] = (byte) (i % 256);
-        }
-
-        try (MemoryWal wal = new MemoryWal(walDir)) {
-            wal.appendRemember("large", largePayload);
-        }
-
-        try (MemoryWal wal2 = new MemoryWal(walDir)) {
-            List<WalEvent> events = wal2.replay(0);
-            assertThat(events).hasSize(1);
-            assertThat(events.getFirst().payload()).isEqualTo(largePayload);
-        }
-    }
-
-    @Test
-    void unicodeMemoryIdRoundTrips() {
-        try (MemoryWal wal = new MemoryWal(walDir)) {
-            wal.appendRemember("日本語テスト-🧠", new byte[]{42});
-        }
-
-        try (MemoryWal wal2 = new MemoryWal(walDir)) {
-            List<WalEvent> events = wal2.replay(0);
-            assertThat(events).hasSize(1);
-            assertThat(events.getFirst().memoryId()).isEqualTo("日本語テスト-🧠");
-        }
-    }
-
-    // ── V2 Upgrades: Compression, Checksums, Auto-Repair & Compaction ──
-
-    @Test
-    void payloadCompressionRoundTrips() {
-        int threshold = 100;
-        try (MemoryWal wal = new MemoryWal(walDir, 8L * 1024 * 1024, true, threshold, false)) {
-            byte[] smallPayload = "small".getBytes();
-            byte[] largePayload = "large-payload-string-that-definitely-exceeds-the-hundred-bytes-threshold-for-compression-testing".repeat(3).getBytes();
-
-            wal.appendRemember("small-id", smallPayload);
-            wal.appendRemember("large-id", largePayload);
-        }
-
-        try (MemoryWal wal2 = new MemoryWal(walDir, 8L * 1024 * 1024, true, threshold, false)) {
-            List<WalEvent> recovered = wal2.replay(0);
-            assertThat(recovered).hasSize(2);
-            
-            WalEvent smallEvent = recovered.get(0);
-            assertThat(smallEvent.memoryId()).isEqualTo("small-id");
-            assertThat(smallEvent.payload()).isEqualTo("small".getBytes());
-
-            WalEvent largeEvent = recovered.get(1);
-            assertThat(largeEvent.memoryId()).isEqualTo("large-id");
-            assertThat(largeEvent.payload()).isEqualTo("large-payload-string-that-definitely-exceeds-the-hundred-bytes-threshold-for-compression-testing".repeat(3).getBytes());
-        }
-    }
-
-    @Test
-    void fsyncConfigurationRespected() {
-        try (MemoryWal wal = new MemoryWal(walDir, 8L * 1024 * 1024, false, 1024, true)) {
-            wal.appendRemember("id-fsync", new byte[]{1, 2, 3});
-        }
-        try (MemoryWal wal2 = new MemoryWal(walDir)) {
-            List<WalEvent> events = wal2.replay(0);
-            assertThat(events).hasSize(1);
-            assertThat(events.getFirst().memoryId()).isEqualTo("id-fsync");
-        }
-    }
-
-    @Test
-    void tornWriteAutoRepair() throws IOException {
-        try (MemoryWal wal = new MemoryWal(walDir)) {
-            wal.appendRemember("m1", new byte[]{10});
-            wal.appendRemember("m2", new byte[]{20});
-            wal.appendRemember("m3", new byte[]{30});
-        }
-
-        Path activeChunk = walDir.resolve(MemoryWal.chunkFileName(0));
-        long fileSize = Files.size(activeChunk);
-        
-        try (var out = Files.newOutputStream(activeChunk, java.nio.file.StandardOpenOption.APPEND)) {
-            out.write(new byte[]{0x57, 0x41, 0, 0, 1, 0, 0, 0, 9, 9, 9, 9, 9, 9, 9});
-        }
-
-        try (MemoryWal wal2 = new MemoryWal(walDir)) {
-            assertThat(wal2.size()).isEqualTo(3);
-            List<WalEvent> events = wal2.replay(0);
-            assertThat(events.get(0).memoryId()).isEqualTo("m1");
-            assertThat(events.get(1).memoryId()).isEqualTo("m2");
-            assertThat(events.get(2).memoryId()).isEqualTo("m3");
-            
-            assertThat(Files.size(activeChunk)).isEqualTo(fileSize);
-            
-            wal2.appendRemember("m4", new byte[]{40});
-            assertThat(wal2.size()).isEqualTo(4);
-        }
-    }
-
-    @Test
-    void middleOfLogCorruptionQuarantine() throws IOException {
-        try (MemoryWal wal = new MemoryWal(walDir)) {
-            wal.appendRemember("m1", new byte[]{10});
-            wal.appendRemember("m2", new byte[]{20});
-            wal.appendRemember("m3", new byte[]{30});
-            wal.appendRemember("m4", new byte[]{40});
-            wal.appendRemember("m5", new byte[]{50});
-        }
-
-        Path activeChunk = walDir.resolve(MemoryWal.chunkFileName(0));
-        byte[] bytes = Files.readAllBytes(activeChunk);
-        
-        bytes[60] ^= (byte) 0xFF;
-        Files.write(activeChunk, bytes);
-
-        org.junit.jupiter.api.Assertions.assertThrows(java.io.UncheckedIOException.class, () -> {
-            new MemoryWal(walDir);
-        });
-
-        Path quarantinedPath = walDir.resolve(".quarantine").resolve(activeChunk.getFileName());
-        assertThat(Files.exists(quarantinedPath)).isTrue();
-        assertThat(Files.exists(activeChunk)).isFalse();
-    }
-
-    @Test
-    void snapshotDrivenLogTruncation() throws IOException {
-        long tinyChunkSize = 256; 
-        try (MemoryWal wal = new MemoryWal(walDir, tinyChunkSize)) {
-            for (int i = 0; i < 30; i++) {
-                wal.appendRemember("mem-" + i, ("payload-string-to-exceed-chunk-boundary-" + i).getBytes());
-            }
-        }
-
-        List<Path> initialChunks;
-        try (var stream = Files.list(walDir)) {
-            initialChunks = stream
-                    .filter(p -> p.getFileName().toString().startsWith("wal-") &&
-                                 p.getFileName().toString().endsWith(".bin"))
-                    .sorted()
-                    .toList();
-        }
-        assertThat(initialChunks.size()).isGreaterThan(2);
-
-        long maxSeqInChunk0;
-        try (MemoryWal wal2 = new MemoryWal(walDir, tinyChunkSize)) {
-            maxSeqInChunk0 = wal2.getMaxSequenceInChunk(initialChunks.get(0));
-            assertThat(maxSeqInChunk0).isGreaterThan(0);
-
-            wal2.truncateBefore(maxSeqInChunk0);
-        }
-
-        assertThat(Files.exists(initialChunks.get(0))).isFalse();
-        assertThat(Files.exists(initialChunks.get(initialChunks.size() - 1))).isTrue();
-    }
-}
diff --git a/spector-memory/src/test/java/com/spectrayan/spector/memory/temporal/TemporalChainTest.java b/spector-memory/src/test/java/com/spectrayan/spector/memory/temporal/TemporalChainTest.java
deleted file mode 100644
index 78a0f8d..0000000
--- a/spector-memory/src/test/java/com/spectrayan/spector/memory/temporal/TemporalChainTest.java
+++ /dev/null
@@ -1,155 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Business Source License 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://github.com/spectrayan/spector/blob/main/spector-memory/LICENSE
- *
- * Change Date: May 27, 2030
- * Change License: Apache License, Version 2.0
- */
-package com.spectrayan.spector.memory.temporal;
-
-import org.junit.jupiter.api.AfterEach;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.io.TempDir;
-
-import java.nio.file.Path;
-import java.util.List;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-/**
- * Tests for TemporalChain: linking, traversal, and persistence.
- */
-class TemporalChainTest {
-
-    @TempDir
-    Path tempDir;
-
-    private TemporalChain chain;
-
-    @BeforeEach
-    void setUp() {
-        chain = new TemporalChain(100);
-    }
-
-    @AfterEach
-    void tearDown() {
-        chain.close();
-    }
-
-    @Test
-    void initialStateIsUnlinked() {
-        assertThat(chain.isLinked(0)).isFalse();
-        assertThat(chain.isLinked(99)).isFalse();
-    }
-
-    @Test
-    void linkCreatesChain() {
-        // Simulate session: memory 0 → memory 1 → memory 2
-        chain.link(1, 0, 1);
-        chain.link(2, 1, 1);
-
-        assertThat(chain.isLinked(0)).isTrue();
-        assertThat(chain.isLinked(1)).isTrue();
-        assertThat(chain.isLinked(2)).isTrue();
-    }
-
-    @Test
-    void followForwardTraversesChain() {
-        chain.link(1, 0, 1);
-        chain.link(2, 1, 1);
-        chain.link(3, 2, 1);
-
-        List<Integer> forward = chain.followForward(0, 10);
-        assertThat(forward).containsExactly(1, 2, 3);
-    }
-
-    @Test
-    void followBackwardTraversesChain() {
-        chain.link(1, 0, 1);
-        chain.link(2, 1, 1);
-        chain.link(3, 2, 1);
-
-        List<Integer> backward = chain.followBackward(3, 10);
-        assertThat(backward).containsExactly(2, 1, 0);
-    }
-
-    @Test
-    void maxHopsLimitsTraversal() {
-        chain.link(1, 0, 1);
-        chain.link(2, 1, 1);
-        chain.link(3, 2, 1);
-        chain.link(4, 3, 1);
-
-        List<Integer> limited = chain.followForward(0, 2);
-        assertThat(limited).hasSize(2);
-        assertThat(limited).containsExactly(1, 2);
-    }
-
-    @Test
-    void sessionIdTracked() {
-        chain.link(1, 0, 42);
-        assertThat(chain.sessionOf(1)).isEqualTo(42);
-        assertThat(chain.sessionOf(0)).isEqualTo(0); // prev not explicitly set
-    }
-
-    @Test
-    void saveAndLoadPreservesChain() {
-        chain.link(1, 0, 1);
-        chain.link(2, 1, 1);
-        chain.link(3, 2, 1);
-
-        Path file = tempDir.resolve("test.chain");
-        chain.save(file);
-        chain.close();
-
-        chain = TemporalChain.load(file, 100);
-        assertThat(chain.followForward(0, 10)).containsExactly(1, 2, 3);
-        assertThat(chain.followBackward(3, 10)).containsExactly(2, 1, 0);
-    }
-
-    @Test
-    void loadNonExistentFileCreatesNew() {
-        Path file = tempDir.resolve("nonexistent.chain");
-        chain.close();
-        chain = TemporalChain.load(file, 50);
-
-        assertThat(chain.capacity()).isEqualTo(50);
-        assertThat(chain.isLinked(0)).isFalse();
-    }
-
-    @Test
-    void boundsCheckDoesNotCrash() {
-        chain.link(-1, 0, 1); // ignored
-        chain.link(0, 500, 1); // ignored (out of capacity)
-        chain.link(0, 0, 1); // self-link: ignored
-        assertThat(chain.isLinked(0)).isFalse();
-        assertThat(chain.followForward(-1, 5)).isEmpty();
-        assertThat(chain.followBackward(500, 5)).isEmpty();
-    }
-
-    @Test
-    void multipleSessions() {
-        // Session 1: 0 → 1 → 2
-        chain.link(1, 0, 1);
-        chain.link(2, 1, 1);
-
-        // Session 2: 5 → 6 → 7 (separate chain)
-        chain.link(6, 5, 2);
-        chain.link(7, 6, 2);
-
-        // Session 1 chain doesn't leak into session 2
-        assertThat(chain.followForward(0, 10)).containsExactly(1, 2);
-        assertThat(chain.followForward(5, 10)).containsExactly(6, 7);
-    }
-
-    @Test
-    void capacityAccessor() {
-        assertThat(chain.capacity()).isEqualTo(100);
-    }
-}
diff --git a/spector-metrics/README.md b/spector-metrics/README.md
deleted file mode 100644
index 6dd267e..0000000
--- a/spector-metrics/README.md
+++ /dev/null
@@ -1,137 +0,0 @@
-# spector-metrics 📊
-
-> **Micrometer-based observability layer for Spector — Prometheus metrics, JVM telemetry, and decorator-pattern engine instrumentation.**
-
-`spector-metrics` provides transparent instrumentation for the Spector engine and JVM runtime. It uses the [Micrometer](https://micrometer.io/) metrics facade, compatible with Prometheus, Datadog, JMX, and any Micrometer-supported backend.
-
----
-
-## 🏗️ Architecture
-
-```mermaid
-graph TD
-    subgraph "spector-metrics"
-        SM["SpectorMetrics<br/><i>Global MeterRegistry holder</i>"]
-        JVM["SpectorJvmMetrics<br/><i>JVM + system binders</i>"]
-        ME["MeteredSpectorEngine<br/><i>Decorator — search/ingest timers</i>"]
-        MM["MeteredSpectorMemory<br/><i>Decorator — memory recall timers</i>"]
-    end
-
-    subgraph "Consumers"
-        NODE["spector-node<br/><i>Prometheus /metrics endpoint</i>"]
-        SPRING["spector-spring<br/><i>Spring Actuator auto-config</i>"]
-    end
-
-    ME -->|wraps| ENGINE["SpectorEngine"]
-    MM -->|wraps| MEMORY["SpectorMemory"]
-    NODE --> SM
-    NODE --> JVM
-    NODE --> ME
-```
-
----
-
-## 📦 Components
-
-### `SpectorMetrics`
-
-Global `MeterRegistry` holder. By default uses a `SimpleMeterRegistry` (zero overhead, discards metrics). Call `init()` at startup to wire a real backend.
-
-```java
-var registry = new PrometheusMeterRegistry(PrometheusConfig.DEFAULT);
-SpectorMetrics.init(registry);
-```
-
-### `SpectorJvmMetrics`
-
-Binds standard JVM telemetry to a registry:
-
-| Metric Group | Source |
-|-------------|--------|
-| JVM Memory | `JvmMemoryMetrics` (heap, non-heap, buffer pools) |
-| GC Activity | `JvmGcMetrics` (pause times, collection counts) |
-| Thread Pools | `JvmThreadMetrics` (live, daemon, peak) |
-| CPU / System | `ProcessorMetrics` (CPU usage, load average) |
-
-```java
-SpectorJvmMetrics.bind(registry);
-```
-
-### `MeteredSpectorEngine`
-
-Decorator (Proxy pattern) wrapping a `SpectorEngine` to record metrics for all coarse-grained operations. Accessor methods are passed through without overhead.
-
-| Metric Name | Type | Description |
-|------------|------|-------------|
-| `spector.engine.search.duration` | Timer | Search query latency |
-| `spector.engine.search.total` | Counter | Total search queries |
-| `spector.engine.ingest.duration` | Timer | Single-doc ingest latency |
-| `spector.engine.ingest.batch.duration` | Timer | Batch ingest latency |
-| `spector.engine.ingest.total` | Counter | Total ingested documents |
-| `spector.engine.delete.total` | Counter | Total deletions |
-| `spector.engine.errors.total` | Counter | Total engine errors |
-| `spector.engine.documents` | Gauge | Current document count |
-
-```java
-SpectorEngine engine = new DefaultSpectorEngine(config);
-SpectorEngine metered = new MeteredSpectorEngine(engine, registry);
-// Use `metered` everywhere — all search/ingest calls are timed
-```
-
-### `MeteredSpectorMemory`
-
-Decorator wrapping `SpectorMemory` with timers and counters for cognitive memory operations (recall, store, reinforce, forget).
-
----
-
-## 🔗 Integration with spector-node
-
-`SpectorNode` automatically wires metrics at startup:
-
-```java
-var registry = new PrometheusMeterRegistry(PrometheusConfig.DEFAULT);
-SpectorMetrics.init(registry);
-SpectorJvmMetrics.bind(registry);
-
-SpectorEngine engine = new MeteredSpectorEngine(rawEngine, registry);
-```
-
-Prometheus scrapes the `/metrics` endpoint served on the same Armeria port.
-
----
-
-## 📊 Prometheus Scrape
-
-```bash
-curl http://localhost:7070/metrics
-```
-
-```text
-# HELP spector_engine_search_duration Time spent executing search queries
-# TYPE spector_engine_search_duration summary
-spector_engine_search_duration_count 1234
-spector_engine_search_duration_sum 0.892
-
-# HELP spector_engine_documents Current number of indexed documents
-# TYPE spector_engine_documents gauge
-spector_engine_documents 50000
-```
-
----
-
-## ⚙️ Dependencies
-
-```xml
-<dependency>
-    <groupId>com.spectrayan</groupId>
-    <artifactId>spector-metrics</artifactId>
-    <version>0.1.0-SNAPSHOT</version>
-</dependency>
-```
-
-| Dependency | Purpose |
-|-----------|---------|
-| `micrometer-core` | Metrics facade (Timer, Counter, Gauge) |
-| `micrometer-registry-prometheus` | Prometheus text format export |
-| `spector-engine` | Engine interface for decorator wrapping |
-| `spector-memory` | Memory interface for decorator wrapping |
diff --git a/spector-metrics/pom.xml b/spector-metrics/pom.xml
deleted file mode 100644
index e33e4ce..0000000
--- a/spector-metrics/pom.xml
+++ /dev/null
@@ -1,39 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0"
-         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
-    <modelVersion>4.0.0</modelVersion>
-
-    <parent>
-        <groupId>com.spectrayan</groupId>
-        <artifactId>spector</artifactId>
-        <version>0.1.0-SNAPSHOT</version>
-    </parent>
-
-    <artifactId>spector-metrics</artifactId>
-    <name>Spector Metrics</name>
-    <description>Micrometer-based observability for Spector — metered decorators for engine, memory, and ingestion.</description>
-
-    <dependencies>
-        <!-- Micrometer core (standalone, no Spring) -->
-        <dependency>
-            <groupId>io.micrometer</groupId>
-            <artifactId>micrometer-core</artifactId>
-        </dependency>
-
-        <!-- Spector modules to decorate -->
-        <dependency>
-            <groupId>com.spectrayan</groupId>
-            <artifactId>spector-engine</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>com.spectrayan</groupId>
-            <artifactId>spector-memory</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>com.spectrayan</groupId>
-            <artifactId>spector-ingestion</artifactId>
-        </dependency>
-    </dependencies>
-
-</project>
diff --git a/spector-metrics/src/main/java/com/spectrayan/spector/metrics/MeteredSpectorEngine.java b/spector-metrics/src/main/java/com/spectrayan/spector/metrics/MeteredSpectorEngine.java
deleted file mode 100644
index 20b1a17..0000000
--- a/spector-metrics/src/main/java/com/spectrayan/spector/metrics/MeteredSpectorEngine.java
+++ /dev/null
@@ -1,309 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.metrics;
-
-import com.spectrayan.spector.config.SpectorConfig;
-import com.spectrayan.spector.embed.EmbeddingProvider;
-import com.spectrayan.spector.engine.EngineIngestionTarget;
-import com.spectrayan.spector.engine.SpectorEngine;
-import com.spectrayan.spector.index.VectorIndex;
-import com.spectrayan.spector.query.SearchQuery;
-import com.spectrayan.spector.query.SearchResponse;
-import com.spectrayan.spector.query.ranking.Reranker;
-import com.spectrayan.spector.storage.DocumentStore;
-import com.spectrayan.spector.storage.VectorStore;
-
-import io.micrometer.core.instrument.Counter;
-import io.micrometer.core.instrument.Gauge;
-import io.micrometer.core.instrument.MeterRegistry;
-import io.micrometer.core.instrument.Timer;
-
-import java.io.IOException;
-import java.nio.file.Path;
-import java.util.function.Function;
-
-/**
- * Metered decorator for {@link SpectorEngine}.
- *
- * <p>Wraps a delegate engine and records Micrometer metrics for all
- * coarse-grained operations (search, ingest, delete). Accessor methods
- * are passed through without instrumentation overhead.</p>
- *
- * <h3>Metrics Registered</h3>
- * <table>
- *   <tr><th>Name</th><th>Type</th><th>Description</th></tr>
- *   <tr><td>{@code spector.engine.search.duration}</td><td>Timer</td><td>Search query latency</td></tr>
- *   <tr><td>{@code spector.engine.search.total}</td><td>Counter</td><td>Total search queries</td></tr>
- *   <tr><td>{@code spector.engine.ingest.duration}</td><td>Timer</td><td>Single-doc ingest latency</td></tr>
- *   <tr><td>{@code spector.engine.ingest.total}</td><td>Counter</td><td>Total ingested documents</td></tr>
- *   <tr><td>{@code spector.engine.delete.total}</td><td>Counter</td><td>Total deletions</td></tr>
- *   <tr><td>{@code spector.engine.documents}</td><td>Gauge</td><td>Current document count</td></tr>
- * </table>
- *
- * @see SpectorEngine
- */
-public class MeteredSpectorEngine implements SpectorEngine {
-
-    public static final String METRIC_SEARCH_DURATION = "spector.engine.search.duration";
-    public static final String METRIC_INGEST_DURATION = "spector.engine.ingest.duration";
-    public static final String METRIC_BATCH_INGEST_DURATION = "spector.engine.ingest.batch.duration";
-    public static final String METRIC_SEARCH_TOTAL = "spector.engine.search.total";
-    public static final String METRIC_INGEST_TOTAL = "spector.engine.ingest.total";
-    public static final String METRIC_DELETE_TOTAL = "spector.engine.delete.total";
-    public static final String METRIC_ERRORS_TOTAL = "spector.engine.errors.total";
-    public static final String METRIC_DOCUMENTS = "spector.engine.documents";
-
-    private final SpectorEngine delegate;
-
-    // ── Timers ──
-    private final Timer searchTimer;
-    private final Timer ingestTimer;
-    private final Timer batchIngestTimer;
-
-    // ── Counters ──
-    private final Counter searchCounter;
-    private final Counter ingestCounter;
-    private final Counter deleteCounter;
-    private final Counter errorCounter;
-
-    /**
-     * Creates a metered engine wrapping the given delegate.
-     *
-     * @param delegate the actual engine implementation
-     * @param registry the meter registry to register metrics with
-     */
-    public MeteredSpectorEngine(SpectorEngine delegate, MeterRegistry registry) {
-        this.delegate = delegate;
-
-        // Timers
-        this.searchTimer = Timer.builder(METRIC_SEARCH_DURATION)
-                .description("Time spent executing search queries")
-                .register(registry);
-        this.ingestTimer = Timer.builder(METRIC_INGEST_DURATION)
-                .description("Time spent ingesting a single document")
-                .register(registry);
-        this.batchIngestTimer = Timer.builder(METRIC_BATCH_INGEST_DURATION)
-                .description("Time spent in batch ingestion")
-                .register(registry);
-
-        // Counters
-        this.searchCounter = Counter.builder(METRIC_SEARCH_TOTAL)
-                .description("Total search queries executed")
-                .register(registry);
-        this.ingestCounter = Counter.builder(METRIC_INGEST_TOTAL)
-                .description("Total documents ingested")
-                .register(registry);
-        this.deleteCounter = Counter.builder(METRIC_DELETE_TOTAL)
-                .description("Total documents deleted")
-                .register(registry);
-        this.errorCounter = Counter.builder(METRIC_ERRORS_TOTAL)
-                .description("Total engine errors")
-                .register(registry);
-
-        // Gauges
-        Gauge.builder(METRIC_DOCUMENTS, delegate, SpectorEngine::documentCount)
-                .description("Current number of indexed documents")
-                .register(registry);
-    }
-
-    /**
-     * Returns the underlying delegate engine.
-     */
-    public SpectorEngine unwrap() {
-        return delegate;
-    }
-
-    // ─────────────── Ingestion (metered) ───────────────
-
-    @Override
-    public void ingest(String id, String content, float[] vector) {
-        ingestCounter.increment();
-        ingestTimer.record(() -> delegate.ingest(id, content, vector));
-    }
-
-    @Override
-    public void ingest(String id, String title, String content, float[] vector) {
-        ingestCounter.increment();
-        ingestTimer.record(() -> delegate.ingest(id, title, content, vector));
-    }
-
-    @Override
-    public void ingestBatch(String[] ids, String[] contents, float[][] vectors) {
-        ingestCounter.increment(ids.length);
-        batchIngestTimer.record(() -> delegate.ingestBatch(ids, contents, vectors));
-    }
-
-    @Override
-    public boolean delete(String id) {
-        deleteCounter.increment();
-        return delegate.delete(id);
-    }
-
-    @Override
-    public int ingestChunked(String id, String content,
-                             Function<String, float[]> vectorProvider) {
-        return ingestTimer.record(() -> {
-            int chunks = delegate.ingestChunked(id, content, vectorProvider);
-            ingestCounter.increment(chunks);
-            return chunks;
-        });
-    }
-
-    @Override
-    public int ingestChunked(String id, String content,
-                             Function<String, float[]> vectorProvider,
-                             com.spectrayan.spector.commons.TextChunker chunker) {
-        return ingestTimer.record(() -> {
-            int chunks = delegate.ingestChunked(id, content, vectorProvider, chunker);
-            ingestCounter.increment(chunks);
-            return chunks;
-        });
-    }
-
-    @Override
-    public void ingestStructured(String id, String content, float[] vector) {
-        ingestCounter.increment();
-        ingestTimer.record(() -> delegate.ingestStructured(id, content, vector));
-    }
-
-    @Override
-    public int ingestFile(Path path, String documentId,
-                          Function<String, float[]> vectorProvider,
-                          int chunkSize, int overlap) throws IOException {
-        // Timer.record doesn't handle checked exceptions, so manual timing
-        Timer.Sample sample = Timer.start();
-        try {
-            int chunks = delegate.ingestFile(path, documentId, vectorProvider, chunkSize, overlap);
-            ingestCounter.increment(chunks);
-            return chunks;
-        } catch (IOException e) {
-            errorCounter.increment();
-            throw e;
-        } finally {
-            sample.stop(ingestTimer);
-        }
-    }
-
-    @Override
-    public int ingestTokenChunked(String id, String content,
-                                  Function<String, float[]> vectorProvider,
-                                  int maxTokens, int overlapTokens) {
-        return ingestTimer.record(() -> {
-            int chunks = delegate.ingestTokenChunked(id, content, vectorProvider, maxTokens, overlapTokens);
-            ingestCounter.increment(chunks);
-            return chunks;
-        });
-    }
-
-    @Override
-    public void ingest(String id, String content) {
-        ingestCounter.increment();
-        ingestTimer.record(() -> delegate.ingest(id, content));
-    }
-
-    @Override
-    public void ingest(String id, String title, String content) {
-        ingestCounter.increment();
-        ingestTimer.record(() -> delegate.ingest(id, title, content));
-    }
-
-    @Override
-    public int ingestChunkedAuto(String id, String content) {
-        return ingestTimer.record(() -> {
-            int chunks = delegate.ingestChunkedAuto(id, content);
-            ingestCounter.increment(chunks);
-            return chunks;
-        });
-    }
-
-    @Override
-    public int ingestFileAuto(Path path, String documentId,
-                              int chunkSize, int overlap) throws IOException {
-        Timer.Sample sample = Timer.start();
-        try {
-            int chunks = delegate.ingestFileAuto(path, documentId, chunkSize, overlap);
-            ingestCounter.increment(chunks);
-            return chunks;
-        } catch (IOException e) {
-            errorCounter.increment();
-            throw e;
-        } finally {
-            sample.stop(ingestTimer);
-        }
-    }
-
-    // ─────────────── Search (metered) ───────────────
-
-    @Override
-    public SearchResponse search(SearchQuery query) {
-        searchCounter.increment();
-        return searchTimer.record(() -> delegate.search(query));
-    }
-
-    @Override
-    public SearchResponse keywordSearch(String text, int topK) {
-        searchCounter.increment();
-        return searchTimer.record(() -> delegate.keywordSearch(text, topK));
-    }
-
-    @Override
-    public SearchResponse vectorSearch(float[] vector, int topK) {
-        searchCounter.increment();
-        return searchTimer.record(() -> delegate.vectorSearch(vector, topK));
-    }
-
-    @Override
-    public SearchResponse hybridSearch(String text, float[] vector, int topK) {
-        searchCounter.increment();
-        return searchTimer.record(() -> delegate.hybridSearch(text, vector, topK));
-    }
-
-    @Override
-    public SearchResponse search(String text, int topK) {
-        searchCounter.increment();
-        return searchTimer.record(() -> delegate.search(text, topK));
-    }
-
-    // ─────────────── GPU (pass-through) ───────────────
-
-    @Override
-    public float[] batchCosineSimilarity(float[] query, float[] database, int n, int dims) {
-        return delegate.batchCosineSimilarity(query, database, n, dims);
-    }
-
-    @Override
-    public boolean isGpuActive() { return delegate.isGpuActive(); }
-
-    // ─────────────── Accessors (pass-through) ───────────────
-
-    @Override public SpectorConfig config() { return delegate.config(); }
-    @Override public int documentCount() { return delegate.documentCount(); }
-    @Override public DocumentStore documentStore() { return delegate.documentStore(); }
-    @Override public VectorStore vectorStore() { return delegate.vectorStore(); }
-    @Override public VectorIndex index() { return delegate.index(); }
-    @Override public EmbeddingProvider embeddingProvider() { return delegate.embeddingProvider(); }
-    @Override public boolean hasEmbeddingProvider() { return delegate.hasEmbeddingProvider(); }
-    @Override public Reranker reranker() { return delegate.reranker(); }
-    @Override public boolean isRerankerActive() { return delegate.isRerankerActive(); }
-    @Override public EngineIngestionTarget target() { return delegate.target(); }
-
-    // ─────────────── Lifecycle ───────────────
-
-    @Override
-    public void close() {
-        delegate.close();
-    }
-}
diff --git a/spector-metrics/src/main/java/com/spectrayan/spector/metrics/MeteredSpectorMemory.java b/spector-metrics/src/main/java/com/spectrayan/spector/metrics/MeteredSpectorMemory.java
deleted file mode 100644
index 2346ad1..0000000
--- a/spector-metrics/src/main/java/com/spectrayan/spector/metrics/MeteredSpectorMemory.java
+++ /dev/null
@@ -1,325 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.metrics;
-
-import com.spectrayan.spector.core.quantization.ScalarQuantizer;
-import com.spectrayan.spector.memory.CognitiveProfile;
-import com.spectrayan.spector.memory.CognitiveResult;
-import com.spectrayan.spector.memory.MemoryType;
-import com.spectrayan.spector.memory.RecallOptions;
-import com.spectrayan.spector.memory.ReflectReport;
-import com.spectrayan.spector.memory.SpectorMemory;
-import com.spectrayan.spector.memory.cortex.MemorySource;
-import com.spectrayan.spector.memory.cortex.TierRouter;
-import com.spectrayan.spector.memory.graph.EntityGraph;
-import com.spectrayan.spector.memory.habituation.HabituationPenalty;
-import com.spectrayan.spector.memory.hebbian.CoActivationTracker;
-import com.spectrayan.spector.memory.hebbian.HebbianGraph;
-import com.spectrayan.spector.memory.index.MemoryIndex;
-import com.spectrayan.spector.memory.inhibition.SuppressionSet;
-import com.spectrayan.spector.memory.metamemory.MemoryInsight;
-import com.spectrayan.spector.memory.neurodivergent.LateralEvaluator;
-import com.spectrayan.spector.memory.pipeline.CognitiveIngestionTarget;
-import com.spectrayan.spector.memory.pipeline.RecallPipeline;
-import com.spectrayan.spector.memory.prospective.ProspectiveScheduler;
-import com.spectrayan.spector.memory.prospective.Reminder;
-import com.spectrayan.spector.memory.sync.MemoryWal;
-import com.spectrayan.spector.memory.temporal.TemporalChain;
-
-import io.micrometer.core.instrument.Counter;
-import io.micrometer.core.instrument.Gauge;
-import io.micrometer.core.instrument.MeterRegistry;
-import io.micrometer.core.instrument.Timer;
-
-import java.time.Duration;
-import java.time.Instant;
-import java.util.List;
-import java.util.concurrent.CompletableFuture;
-
-/**
- * Metered decorator for {@link SpectorMemory}.
- *
- * <p>Wraps a delegate memory and records Micrometer metrics for all
- * core cognitive operations (remember, recall, forget, reinforce, reflect).
- * Subsystem accessors and lightweight operations pass through without
- * instrumentation overhead.</p>
- *
- * <h3>Metrics Registered</h3>
- * <table>
- *   <tr><th>Name</th><th>Type</th><th>Description</th></tr>
- *   <tr><td>{@code spector.memory.recall.duration}</td><td>Timer</td><td>Cognitive recall latency</td></tr>
- *   <tr><td>{@code spector.memory.recall.total}</td><td>Counter</td><td>Total recall queries</td></tr>
- *   <tr><td>{@code spector.memory.remember.total}</td><td>Counter</td><td>Total memories stored</td></tr>
- *   <tr><td>{@code spector.memory.reinforce.total}</td><td>Counter</td><td>Total reinforcement events</td></tr>
- *   <tr><td>{@code spector.memory.forget.total}</td><td>Counter</td><td>Total forget events</td></tr>
- *   <tr><td>{@code spector.memory.reflect.duration}</td><td>Timer</td><td>Reflection cycle latency</td></tr>
- *   <tr><td>{@code spector.memory.count}</td><td>Gauge</td><td>Total memory count</td></tr>
- * </table>
- *
- * @see SpectorMemory
- */
-public class MeteredSpectorMemory implements SpectorMemory {
-
-    public static final String METRIC_RECALL_DURATION = "spector.memory.recall.duration";
-    public static final String METRIC_REFLECT_DURATION = "spector.memory.reflect.duration";
-    public static final String METRIC_RECALL_TOTAL = "spector.memory.recall.total";
-    public static final String METRIC_REMEMBER_TOTAL = "spector.memory.remember.total";
-    public static final String METRIC_REINFORCE_TOTAL = "spector.memory.reinforce.total";
-    public static final String METRIC_FORGET_TOTAL = "spector.memory.forget.total";
-    public static final String METRIC_SUPPRESS_TOTAL = "spector.memory.suppress.total";
-    public static final String METRIC_COUNT = "spector.memory.count";
-
-    private final SpectorMemory delegate;
-
-    // ── Timers ──
-    private final Timer recallTimer;
-    private final Timer reflectTimer;
-
-    // ── Counters ──
-    private final Counter recallCounter;
-    private final Counter rememberCounter;
-    private final Counter reinforceCounter;
-    private final Counter forgetCounter;
-    private final Counter suppressCounter;
-
-    /**
-     * Creates a metered memory wrapping the given delegate.
-     *
-     * @param delegate the actual memory implementation
-     * @param registry the meter registry to register metrics with
-     */
-    public MeteredSpectorMemory(SpectorMemory delegate, MeterRegistry registry) {
-        this.delegate = delegate;
-
-        // Timers with microsecond-precision percentile histograms
-        this.recallTimer = Timer.builder(METRIC_RECALL_DURATION)
-                .description("Time spent in cognitive recall")
-                .publishPercentiles(0.5, 0.9, 0.95, 0.99)
-                .publishPercentileHistogram()
-                .register(registry);
-        this.reflectTimer = Timer.builder(METRIC_REFLECT_DURATION)
-                .description("Time spent in sleep consolidation (reflection)")
-                .publishPercentiles(0.5, 0.9, 0.95, 0.99)
-                .publishPercentileHistogram()
-                .register(registry);
-
-        // Counters
-        this.recallCounter = Counter.builder(METRIC_RECALL_TOTAL)
-                .description("Total recall queries")
-                .register(registry);
-        this.rememberCounter = Counter.builder(METRIC_REMEMBER_TOTAL)
-                .description("Total memories ingested")
-                .register(registry);
-        this.reinforceCounter = Counter.builder(METRIC_REINFORCE_TOTAL)
-                .description("Total reinforcement events")
-                .register(registry);
-        this.forgetCounter = Counter.builder(METRIC_FORGET_TOTAL)
-                .description("Total memories forgotten")
-                .register(registry);
-        this.suppressCounter = Counter.builder(METRIC_SUPPRESS_TOTAL)
-                .description("Total memories suppressed")
-                .register(registry);
-
-        // Gauges
-        Gauge.builder(METRIC_COUNT, delegate, SpectorMemory::totalMemories)
-                .description("Total number of memories across all tiers")
-                .register(registry);
-
-        // Soft & Hard Page Fault Gauges (Linux container tracking)
-        Gauge.builder("spector.memory.page.faults", () -> readPageFaults()[0])
-                .tag("type", "soft")
-                .description("Soft page faults (minor faults) on Linux")
-                .register(registry);
-
-        Gauge.builder("spector.memory.page.faults", () -> readPageFaults()[1])
-                .tag("type", "hard")
-                .description("Hard page faults (major faults) on Linux")
-                .register(registry);
-
-        // Pinned Bytes Gauge (RAM usage verification)
-        Gauge.builder("spector.memory.pinned.bytes", com.spectrayan.spector.commons.concurrent.MemoryPinning::pinnedBytes)
-                .description("Total off-heap memory bytes pinned in RAM")
-                .register(registry);
-    }
-
-    /**
-     * Returns the underlying delegate memory.
-     */
-    public SpectorMemory unwrap() {
-        return delegate;
-    }
-
-    // ══════════════════════════════════════════════════════════════
-    // INGESTION TARGET (pass-through)
-    // ══════════════════════════════════════════════════════════════
-
-    @Override
-    public CognitiveIngestionTarget target() { return delegate.target(); }
-
-    // ══════════════════════════════════════════════════════════════
-    // CORE API (metered)
-    // ══════════════════════════════════════════════════════════════
-
-    @Override
-    public CompletableFuture<Void> remember(String id, String text, MemoryType type,
-                                              MemorySource source, String... tags) {
-        rememberCounter.increment();
-        return delegate.remember(id, text, type, source, tags);
-    }
-
-    @Override
-    public CompletableFuture<Void> remember(String id, String text, MemoryType type,
-                                              String... tags) {
-        rememberCounter.increment();
-        return delegate.remember(id, text, type, tags);
-    }
-
-    @Override
-    public List<CognitiveResult> recall(String queryText, RecallOptions options) {
-        recallCounter.increment();
-        return recallTimer.record(() -> delegate.recall(queryText, options));
-    }
-
-    @Override
-    public List<CognitiveResult> recall(String queryText, CognitiveProfile profile) {
-        recallCounter.increment();
-        return recallTimer.record(() -> delegate.recall(queryText, profile));
-    }
-
-    @Override
-    public List<CognitiveResult> recall(String queryText) {
-        recallCounter.increment();
-        return recallTimer.record(() -> delegate.recall(queryText));
-    }
-
-    @Override
-    public void forget(String id) {
-        forgetCounter.increment();
-        delegate.forget(id);
-    }
-
-    @Override
-    public ReflectReport reflect() {
-        return reflectTimer.record(() -> delegate.reflect());
-    }
-
-    // ══════════════════════════════════════════════════════════════
-    // EXTENDED API (metered where meaningful)
-    // ══════════════════════════════════════════════════════════════
-
-    @Override
-    public void reinforce(String memoryId, byte valence) {
-        reinforceCounter.increment();
-        delegate.reinforce(memoryId, valence);
-    }
-
-    @Override
-    public void suppress(String memoryId, String reason) {
-        suppressCounter.increment();
-        delegate.suppress(memoryId, reason);
-    }
-
-    @Override
-    public void suppress(String memoryId) {
-        suppressCounter.increment();
-        delegate.suppress(memoryId);
-    }
-
-    @Override
-    public void unsuppress(String memoryId) { delegate.unsuppress(memoryId); }
-
-    @Override
-    public void markResolved(String memoryId) { delegate.markResolved(memoryId); }
-
-    @Override
-    public void markUnresolved(String memoryId) { delegate.markUnresolved(memoryId); }
-
-    @Override
-    public MemoryInsight introspect(String topic) {
-        return delegate.introspect(topic);
-    }
-
-    // ══════════════════════════════════════════════════════════════
-    // PROSPECTIVE / SCRATCHPAD / STATS (pass-through)
-    // ══════════════════════════════════════════════════════════════
-
-    @Override
-    public Reminder scheduleReminder(String text, Instant triggerAt, String... tags) {
-        return delegate.scheduleReminder(text, triggerAt, tags);
-    }
-
-    @Override
-    public Reminder scheduleReminder(String text, Duration delay, String... tags) {
-        return delegate.scheduleReminder(text, delay, tags);
-    }
-
-    @Override
-    public CompletableFuture<Void> scratchpad(String text) {
-        return delegate.scratchpad(text);
-    }
-
-    @Override public int totalMemories() { return delegate.totalMemories(); }
-    @Override public int memoryCount(MemoryType type) { return delegate.memoryCount(type); }
-    @Override public int decay(Duration olderThan, float factor) { return delegate.decay(olderThan, factor); }
-
-    // ══════════════════════════════════════════════════════════════
-    // SUBSYSTEM ACCESSORS (pass-through)
-    // ══════════════════════════════════════════════════════════════
-
-    @Override public CoActivationTracker coActivation() { return delegate.coActivation(); }
-    @Override public MemoryWal wal() { return delegate.wal(); }
-    @Override public ProspectiveScheduler prospective() { return delegate.prospective(); }
-    @Override public SuppressionSet suppression() { return delegate.suppression(); }
-    @Override public HabituationPenalty habituation() { return delegate.habituation(); }
-    @Override public ScalarQuantizer quantizer() { return delegate.quantizer(); }
-    @Override public CognitiveIngestionTarget cognitiveTarget() { return delegate.cognitiveTarget(); }
-    @Override public RecallPipeline recallPipeline() { return delegate.recallPipeline(); }
-    @Override public TierRouter tierRouter() { return delegate.tierRouter(); }
-    @Override public MemoryIndex index() { return delegate.index(); }
-    @Override public LateralEvaluator lateralEvaluator() { return delegate.lateralEvaluator(); }
-    @Override public HebbianGraph hebbianGraph() { return delegate.hebbianGraph(); }
-    @Override public TemporalChain temporalChain() { return delegate.temporalChain(); }
-    @Override public EntityGraph entityGraph() { return delegate.entityGraph(); }
-
-    // ── Lifecycle ──
-
-    @Override
-    public void close() {
-        delegate.close();
-    }
-
-    private static long[] readPageFaults() {
-        try {
-            java.nio.file.Path path = java.nio.file.Path.of("/proc/self/stat");
-            if (java.nio.file.Files.exists(path)) {
-                String content = java.nio.file.Files.readString(path);
-                int lastParen = content.lastIndexOf(')');
-                if (lastParen != -1 && lastParen + 2 < content.length()) {
-                    String rest = content.substring(lastParen + 2);
-                    String[] tokens = rest.split("\\s+");
-                    if (tokens.length > 9) {
-                        long soft = Long.parseLong(tokens[7]);
-                        long hard = Long.parseLong(tokens[9]);
-                        return new long[]{soft, hard};
-                    }
-                }
-            }
-        } catch (Exception e) {
-            // safe fallback
-        }
-        return new long[]{0L, 0L};
-    }
-}
diff --git a/spector-metrics/src/main/java/com/spectrayan/spector/metrics/SpectorJvmMetrics.java b/spector-metrics/src/main/java/com/spectrayan/spector/metrics/SpectorJvmMetrics.java
deleted file mode 100644
index 9ddde98..0000000
--- a/spector-metrics/src/main/java/com/spectrayan/spector/metrics/SpectorJvmMetrics.java
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.metrics;
-
-import io.micrometer.core.instrument.MeterRegistry;
-import io.micrometer.core.instrument.binder.jvm.JvmGcMetrics;
-import io.micrometer.core.instrument.binder.jvm.JvmMemoryMetrics;
-import io.micrometer.core.instrument.binder.jvm.JvmThreadMetrics;
-import io.micrometer.core.instrument.binder.system.ProcessorMetrics;
-
-/**
- * Utility to bind common JVM and system metrics to a Micrometer {@link MeterRegistry}.
- * Useful for standalone deployments (like Spector Server) that don't have
- * Spring Boot's automatic Actuator binder support.
- */
-public final class SpectorJvmMetrics {
-
-    private SpectorJvmMetrics() {
-        // Utility class
-    }
-
-    /**
-     * Binds JVM Memory, GC, Thread, and Processor/System metrics to the given registry.
-     *
-     * @param registry the Micrometer registry to bind metrics to
-     */
-    public static void bind(MeterRegistry registry) {
-        new JvmMemoryMetrics().bindTo(registry);
-        new JvmGcMetrics().bindTo(registry);
-        new ProcessorMetrics().bindTo(registry);
-        new JvmThreadMetrics().bindTo(registry);
-    }
-}
diff --git a/spector-metrics/src/main/java/com/spectrayan/spector/metrics/SpectorMetrics.java b/spector-metrics/src/main/java/com/spectrayan/spector/metrics/SpectorMetrics.java
deleted file mode 100644
index 8600009..0000000
--- a/spector-metrics/src/main/java/com/spectrayan/spector/metrics/SpectorMetrics.java
+++ /dev/null
@@ -1,72 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.metrics;
-
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-import com.spectrayan.spector.commons.error.ErrorCode;
-
-import io.micrometer.core.instrument.MeterRegistry;
-import io.micrometer.core.instrument.simple.SimpleMeterRegistry;
-
-/**
- * Global {@link MeterRegistry} holder for Spector observability.
- *
- * <p>By default, uses a {@link SimpleMeterRegistry} which silently discards
- * all metrics — zero overhead when observability is not configured.
- * Call {@link #init(MeterRegistry)} at startup to wire a real registry
- * (Prometheus, Datadog, JMX, etc.).</p>
- *
- * <h3>Standalone Usage (Javalin / MCP)</h3>
- * <pre>{@code
- *   var registry = new PrometheusMeterRegistry(PrometheusConfig.DEFAULT);
- *   SpectorMetrics.init(registry);
- * }</pre>
- *
- * <h3>Spring Boot Usage</h3>
- * <p>Spring auto-configuration calls {@code SpectorMetrics.init(springRegistry)}
- * automatically — no user action required.</p>
- */
-public final class SpectorMetrics {
-
-    private static volatile MeterRegistry registry = new SimpleMeterRegistry();
-
-    private SpectorMetrics() {}
-
-    /**
-     * Initializes the global meter registry.
-     *
-     * <p>Should be called once at application startup, before any metrics
-     * are recorded. Thread-safe via volatile write.</p>
-     *
-     * @param registry the meter registry to use
-     * @throws SpectorValidationException if registry is null
-     */
-    public static void init(MeterRegistry registry) {
-        if (registry == null) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_NULL, "MeterRegistry");
-        }
-        SpectorMetrics.registry = registry;
-    }
-
-    /**
-     * Returns the current meter registry.
-     *
-     * @return the active meter registry (never null)
-     */
-    public static MeterRegistry registry() {
-        return registry;
-    }
-}
diff --git a/spector-metrics/src/test/java/com/spectrayan/spector/metrics/MeteredSpectorEngineTest.java b/spector-metrics/src/test/java/com/spectrayan/spector/metrics/MeteredSpectorEngineTest.java
deleted file mode 100644
index fc028d8..0000000
--- a/spector-metrics/src/test/java/com/spectrayan/spector/metrics/MeteredSpectorEngineTest.java
+++ /dev/null
@@ -1,107 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.metrics;
-
-import com.spectrayan.spector.config.SpectorConfig;
-import com.spectrayan.spector.embed.EmbeddingProvider;
-import com.spectrayan.spector.engine.EngineIngestionTarget;
-import com.spectrayan.spector.engine.SpectorEngine;
-import com.spectrayan.spector.index.VectorIndex;
-import com.spectrayan.spector.query.SearchQuery;
-import com.spectrayan.spector.query.SearchResponse;
-import com.spectrayan.spector.query.ranking.Reranker;
-import com.spectrayan.spector.storage.DocumentStore;
-import com.spectrayan.spector.storage.VectorStore;
-import io.micrometer.core.instrument.MeterRegistry;
-import io.micrometer.core.instrument.simple.SimpleMeterRegistry;
-import org.junit.jupiter.api.Test;
-
-import java.io.IOException;
-import java.nio.file.Path;
-import java.util.function.Function;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-/**
- * Unit tests for {@link MeteredSpectorEngine}.
- */
-class MeteredSpectorEngineTest {
-
-    @Test
-    void searchRecordsMetrics() {
-        MeterRegistry registry = new SimpleMeterRegistry();
-        SpectorEngine stub = new DummySpectorEngine() {
-            @Override
-            public SearchResponse search(SearchQuery query) {
-                return new SearchResponse(new com.spectrayan.spector.index.ScoredResult[0], 0, 0L, SearchQuery.SearchMode.KEYWORD);
-            }
-        };
-
-        MeteredSpectorEngine metered = new MeteredSpectorEngine(stub, registry);
-        SearchQuery query = SearchQuery.keyword("hello", 10);
-        SearchResponse response = metered.search(query);
-
-        assertThat(response).isNotNull();
-        assertThat(registry.get(MeteredSpectorEngine.METRIC_SEARCH_TOTAL).counter().count()).isEqualTo(1.0);
-        assertThat(registry.get(MeteredSpectorEngine.METRIC_SEARCH_DURATION).timer().count()).isEqualTo(1L);
-    }
-
-    @Test
-    void ingestRecordsMetrics() {
-        MeterRegistry registry = new SimpleMeterRegistry();
-        SpectorEngine stub = new DummySpectorEngine();
-
-        MeteredSpectorEngine metered = new MeteredSpectorEngine(stub, registry);
-        metered.ingest("id-1", "content-1", new float[]{0.1f});
-
-        assertThat(registry.get(MeteredSpectorEngine.METRIC_INGEST_TOTAL).counter().count()).isEqualTo(1.0);
-        assertThat(registry.get(MeteredSpectorEngine.METRIC_INGEST_DURATION).timer().count()).isEqualTo(1L);
-    }
-
-    static class DummySpectorEngine implements SpectorEngine {
-        @Override public void ingest(String id, String content, float[] vector) {}
-        @Override public void ingest(String id, String title, String content, float[] vector) {}
-        @Override public void ingestBatch(String[] ids, String[] contents, float[][] vectors) {}
-        @Override public boolean delete(String id) { return true; }
-        @Override public int ingestChunked(String id, String content, Function<String, float[]> vectorProvider) { return 1; }
-        @Override public int ingestChunked(String id, String content, Function<String, float[]> vectorProvider, com.spectrayan.spector.commons.TextChunker chunker) { return 1; }
-        @Override public void ingestStructured(String id, String content, float[] vector) {}
-        @Override public int ingestFile(Path path, String documentId, Function<String, float[]> vectorProvider, int chunkSize, int overlap) throws IOException { return 1; }
-        @Override public int ingestTokenChunked(String id, String content, Function<String, float[]> vectorProvider, int maxTokens, int overlapTokens) { return 1; }
-        @Override public void ingest(String id, String content) {}
-        @Override public void ingest(String id, String title, String content) {}
-        @Override public int ingestChunkedAuto(String id, String content) { return 1; }
-        @Override public int ingestFileAuto(Path path, String documentId, int chunkSize, int overlap) throws IOException { return 1; }
-        @Override public SearchResponse search(SearchQuery query) { return null; }
-        @Override public SearchResponse keywordSearch(String text, int topK) { return null; }
-        @Override public SearchResponse vectorSearch(float[] vector, int topK) { return null; }
-        @Override public SearchResponse hybridSearch(String text, float[] vector, int topK) { return null; }
-        @Override public SearchResponse search(String text, int topK) { return null; }
-        @Override public float[] batchCosineSimilarity(float[] query, float[] database, int n, int dims) { return null; }
-        @Override public boolean isGpuActive() { return false; }
-        @Override public SpectorConfig config() { return null; }
-        @Override public int documentCount() { return 0; }
-        @Override public DocumentStore documentStore() { return null; }
-        @Override public VectorStore vectorStore() { return null; }
-        @Override public VectorIndex index() { return null; }
-        @Override public EmbeddingProvider embeddingProvider() { return null; }
-        @Override public boolean hasEmbeddingProvider() { return false; }
-        @Override public Reranker reranker() { return null; }
-        @Override public boolean isRerankerActive() { return false; }
-        @Override public EngineIngestionTarget target() { return null; }
-        @Override public void close() {}
-    }
-}
diff --git a/spector-metrics/src/test/java/com/spectrayan/spector/metrics/MeteredSpectorMemoryTest.java b/spector-metrics/src/test/java/com/spectrayan/spector/metrics/MeteredSpectorMemoryTest.java
deleted file mode 100644
index c6157d8..0000000
--- a/spector-metrics/src/test/java/com/spectrayan/spector/metrics/MeteredSpectorMemoryTest.java
+++ /dev/null
@@ -1,129 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.metrics;
-
-import com.spectrayan.spector.core.quantization.ScalarQuantizer;
-import com.spectrayan.spector.memory.*;
-import com.spectrayan.spector.memory.cortex.MemorySource;
-import com.spectrayan.spector.memory.cortex.TierRouter;
-import com.spectrayan.spector.memory.habituation.HabituationPenalty;
-import com.spectrayan.spector.memory.hebbian.CoActivationTracker;
-import com.spectrayan.spector.memory.index.MemoryIndex;
-import com.spectrayan.spector.memory.inhibition.SuppressionSet;
-import com.spectrayan.spector.memory.metamemory.MemoryInsight;
-import com.spectrayan.spector.memory.neurodivergent.LateralEvaluator;
-import com.spectrayan.spector.memory.pipeline.CognitiveIngestionTarget;
-import com.spectrayan.spector.memory.pipeline.RecallPipeline;
-import com.spectrayan.spector.memory.prospective.ProspectiveScheduler;
-import com.spectrayan.spector.memory.prospective.Reminder;
-import com.spectrayan.spector.memory.sync.MemoryWal;
-import io.micrometer.core.instrument.MeterRegistry;
-import io.micrometer.core.instrument.simple.SimpleMeterRegistry;
-import org.junit.jupiter.api.Test;
-
-import java.time.Duration;
-import java.time.Instant;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.concurrent.CompletableFuture;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-/**
- * Unit tests for {@link MeteredSpectorMemory}.
- */
-class MeteredSpectorMemoryTest {
-
-    @Test
-    void recallRecordsMetrics() {
-        MeterRegistry registry = new SimpleMeterRegistry();
-        SpectorMemory stub = new DummySpectorMemory() {
-            @Override
-            public List<CognitiveResult> recall(String queryText) {
-                return new ArrayList<>();
-            }
-        };
-
-        MeteredSpectorMemory metered = new MeteredSpectorMemory(stub, registry);
-        List<CognitiveResult> results = metered.recall("hello");
-
-        assertThat(results).isNotNull();
-        assertThat(registry.get(MeteredSpectorMemory.METRIC_RECALL_TOTAL).counter().count()).isEqualTo(1.0);
-        assertThat(registry.get(MeteredSpectorMemory.METRIC_RECALL_DURATION).timer().count()).isEqualTo(1L);
-    }
-
-    @Test
-    void rememberRecordsMetrics() {
-        MeterRegistry registry = new SimpleMeterRegistry();
-        SpectorMemory stub = new DummySpectorMemory();
-
-        MeteredSpectorMemory metered = new MeteredSpectorMemory(stub, registry);
-        metered.remember("id-1", "content-1", MemoryType.EPISODIC, MemorySource.USER_STATED, "tag");
-
-        assertThat(registry.get(MeteredSpectorMemory.METRIC_REMEMBER_TOTAL).counter().count()).isEqualTo(1.0);
-    }
-
-    @Test
-    void observabilityMetricsRegistered() {
-        MeterRegistry registry = new SimpleMeterRegistry();
-        SpectorMemory stub = new DummySpectorMemory();
-
-        new MeteredSpectorMemory(stub, registry);
-
-        assertThat(registry.find("spector.memory.page.faults").tag("type", "soft").gauge()).isNotNull();
-        assertThat(registry.find("spector.memory.page.faults").tag("type", "hard").gauge()).isNotNull();
-        assertThat(registry.find("spector.memory.pinned.bytes").gauge()).isNotNull();
-    }
-
-    static class DummySpectorMemory implements SpectorMemory {
-        @Override public CognitiveIngestionTarget target() { return null; }
-        @Override public CompletableFuture<Void> remember(String id, String text, MemoryType type, MemorySource source, String... tags) { return CompletableFuture.completedFuture(null); }
-        @Override public CompletableFuture<Void> remember(String id, String text, MemoryType type, String... tags) { return CompletableFuture.completedFuture(null); }
-        @Override public List<CognitiveResult> recall(String queryText, RecallOptions options) { return null; }
-        @Override public List<CognitiveResult> recall(String queryText, CognitiveProfile profile) { return null; }
-        @Override public List<CognitiveResult> recall(String queryText) { return null; }
-        @Override public void forget(String id) {}
-        @Override public ReflectReport reflect() { return null; }
-        @Override public void reinforce(String memoryId, byte valence) {}
-        @Override public void suppress(String memoryId, String reason) {}
-        @Override public void suppress(String memoryId) {}
-        @Override public void unsuppress(String memoryId) {}
-        @Override public void markResolved(String memoryId) {}
-        @Override public void markUnresolved(String memoryId) {}
-        @Override public MemoryInsight introspect(String topic) { return null; }
-        @Override public Reminder scheduleReminder(String text, Instant triggerAt, String... tags) { return null; }
-        @Override public Reminder scheduleReminder(String text, Duration delay, String... tags) { return null; }
-        @Override public CompletableFuture<Void> scratchpad(String text) { return CompletableFuture.completedFuture(null); }
-        @Override public int totalMemories() { return 0; }
-        @Override public int memoryCount(MemoryType type) { return 0; }
-        @Override public int decay(Duration olderThan, float factor) { return 0; }
-        @Override public CoActivationTracker coActivation() { return null; }
-        @Override public MemoryWal wal() { return null; }
-        @Override public ProspectiveScheduler prospective() { return null; }
-        @Override public SuppressionSet suppression() { return null; }
-        @Override public HabituationPenalty habituation() { return null; }
-        @Override public ScalarQuantizer quantizer() { return null; }
-        @Override public CognitiveIngestionTarget cognitiveTarget() { return null; }
-        @Override public RecallPipeline recallPipeline() { return null; }
-        @Override public TierRouter tierRouter() { return null; }
-        @Override public MemoryIndex index() { return null; }
-        @Override public LateralEvaluator lateralEvaluator() { return null; }
-        @Override public com.spectrayan.spector.memory.graph.EntityGraph entityGraph() { return null; }
-        @Override public com.spectrayan.spector.memory.hebbian.HebbianGraph hebbianGraph() { return null; }
-        @Override public com.spectrayan.spector.memory.temporal.TemporalChain temporalChain() { return null; }
-        @Override public void close() {}
-    }
-}
diff --git a/spector-metrics/src/test/java/com/spectrayan/spector/metrics/SpectorMetricsTest.java b/spector-metrics/src/test/java/com/spectrayan/spector/metrics/SpectorMetricsTest.java
deleted file mode 100644
index 0236360..0000000
--- a/spector-metrics/src/test/java/com/spectrayan/spector/metrics/SpectorMetricsTest.java
+++ /dev/null
@@ -1,52 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.metrics;
-
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-
-import io.micrometer.core.instrument.MeterRegistry;
-import io.micrometer.core.instrument.simple.SimpleMeterRegistry;
-import org.junit.jupiter.api.Test;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.assertThatThrownBy;
-
-/**
- * Unit tests for {@link SpectorMetrics}.
- */
-class SpectorMetricsTest {
-
-    @Test
-    void defaultRegistryIsSimpleMeterRegistry() {
-        MeterRegistry registry = SpectorMetrics.registry();
-        assertThat(registry).isNotNull();
-        assertThat(registry).isInstanceOf(SimpleMeterRegistry.class);
-    }
-
-    @Test
-    void initSwapsRegistry() {
-        MeterRegistry newRegistry = new SimpleMeterRegistry();
-        SpectorMetrics.init(newRegistry);
-        assertThat(SpectorMetrics.registry()).isSameAs(newRegistry);
-    }
-
-    @Test
-    void initThrowsOnNull() {
-        assertThatThrownBy(() -> SpectorMetrics.init(null))
-                .isInstanceOf(SpectorValidationException.class)
-                .hasMessageContaining("MeterRegistry must not be null");
-    }
-}
diff --git a/spector-node/README.md b/spector-node/README.md
deleted file mode 100644
index 35adc5e..0000000
--- a/spector-node/README.md
+++ /dev/null
@@ -1,194 +0,0 @@
-# spector-node ⚡
-
-> **Unified Armeria-powered node — serves HTTP REST, gRPC, SSE events, Prometheus metrics, and health probes on a single Netty port.**
-
-`spector-node` is the production entry point for Spector. It replaces the old `spector-node` (Armeria) and `spector-node` (gRPC) modules with a single, unified Armeria binary. One port, one NIO runtime, one binary.
-
----
-
-## 🏗️ Architecture
-
-```mermaid
-graph LR
-    subgraph "SpectorNode (Armeria — single port :7070)"
-        REST["🌐 REST API<br/>/api/v1/*"]
-        gRPC["⚡ gRPC<br/>inter-node fan-out"]
-        HEALTH["💚 Health<br/>/health"]
-        METRICS["📊 Prometheus<br/>/metrics"]
-        SSE["📡 SSE Events<br/>/api/v1/events"]
-    end
-
-    CLIENT["👤 Client"] --> REST
-    AGENT["🤖 AI Agent"] --> REST
-    PEER["🌐 Peer Node"] --> gRPC
-    K8S["☸️ Kubernetes"] --> HEALTH
-    PROM["📊 Prometheus"] --> METRICS
-    SUBSCRIBER["📡 Event Subscriber"] --> SSE
-
-    style REST fill:#00b894,color:white
-    style gRPC fill:#6c5ce7,color:white
-    style SSE fill:#fd79a8,color:white
-```
-
----
-
-## 📦 Package Structure
-
-```mermaid
-graph TD
-    subgraph "com.spectrayan.spector.node"
-        SN["SpectorNode<br/><i>entry point</i>"]
-        NC["NodeConfig<br/><i>env-based config</i>"]
-    end
-
-    subgraph "node.api"
-        AM["ApiModule<br/><i>Factory interface</i>"]
-    end
-
-    subgraph "node.api.v1"
-        SE["SearchEndpoint"]
-        IE["IngestEndpoint"]
-        RE["RagEndpoint"]
-        DE["DocumentEndpoint"]
-        STE["StatusEndpoint"]
-        ESE["EventStreamEndpoint"]
-    end
-
-    subgraph "node.api.dto"
-        DTO["SearchRequest<br/>IngestRequest<br/>RagRequest<br/>ErrorResponse<br/>..."]
-    end
-
-    subgraph "node.service"
-        SS["SearchService<br/><i>Facade</i>"]
-        IS["IngestService<br/><i>Facade</i>"]
-        RS["RagService<br/><i>Facade</i>"]
-    end
-
-    subgraph "node.event"
-        EB["SpectorEventBus<br/><i>Observer</i>"]
-        EV["17 SpectorEvent types"]
-    end
-
-    subgraph "node.exception"
-        AEH["ApiExceptionHandler"]
-        SAE["SpectorApiException"]
-    end
-
-    subgraph "cluster"
-        CC["ClusterCoordinator"]
-        DQC["DistributedQueryCoordinator"]
-        RSC["RemoteShardClient"]
-        HMS["HeartbeatMembershipService"]
-        CHSM["ConsistentHashShardManager"]
-    end
-
-    SN --> AM
-    AM --> SE & IE & RE & DE & STE & ESE
-    SE --> SS
-    IE --> IS
-    RE --> RS
-    SS --> CC
-    IS --> CC
-    SS & IS --> EB
-```
-
----
-
-## 🧩 Key Components
-
-| Component | Role |
-|-----------|------|
-| **`SearchService`**, **`IngestService`**, **`RagService`** | Service facades that hide local vs cluster routing — callers don't know if they're hitting a single node or a distributed shard |
-| **`ApiModule`** | Pluggable endpoint registration — each API version (`v1`, `v2`, …) registers its routes as a self-contained module |
-| **`SpectorEventBus`** | In-process event bus with 17 sealed `SpectorEvent` types — decouples producers (services) from consumers (SSE, metrics, cluster sync) |
-| **`ClusterCoordinator`** | Orchestrates distributed mode — consistent-hash shard routing, heartbeat membership, and gRPC fan-out to peer nodes |
-| **`ApiExceptionHandler`** | Centralized error handling — maps exceptions to structured JSON error responses with HTTP status codes |
-
----
-
-## ⚡ Protocols Served (Single Port)
-
-| Protocol | Path | Format |
-|----------|------|--------|
-| HTTP REST | `/api/v1/*` | JSON |
-| gRPC | (auto-detected via `application/grpc`) | Protobuf |
-| Health | `/health` | 200 OK |
-| Prometheus | `/metrics` | OpenMetrics text |
-| SSE Events | `/api/v1/events` | Server-Sent Events |
-
----
-
-## 🚀 Running
-
-### Environment Variables
-
-| Variable | Default | Description |
-|----------|---------|-------------|
-| `SPECTOR_PORT` | 7070 | HTTP + gRPC port |
-| `SPECTOR_NODE_ID` | hostname | Unique node identifier |
-| `SPECTOR_SEED_NODES` | _(none)_ | Comma-separated seed endpoints (triggers CLUSTERED mode) |
-| `SPECTOR_API_KEY` | _(none)_ | API key for authentication |
-| `SPECTOR_DIMS` | 384 | Vector dimensions |
-| `SPECTOR_MAX_CONNECTIONS` | 10,000 | Max concurrent connections |
-| `SPECTOR_REQUEST_TIMEOUT` | 30 | Request timeout (seconds) |
-| `SPECTOR_COMPRESSION` | true | Enable gzip/brotli response compression |
-| `SPECTOR_IDLE_TIMEOUT` | 60 | Idle connection timeout (seconds) |
-| `SPECTOR_MCP_ENABLED` | true | Enable MCP-over-SSE at /mcp |
-
-### Launching
-
-```bash
-# Standalone mode
-SPECTOR_PORT=7070 SPECTOR_DIMS=384 \
-  java --add-modules jdk.incubator.vector --enable-preview \
-  -cp spector-dist/target/spector.jar \
-  com.spectrayan.spector.node.SpectorNode
-
-# Clustered mode (3 nodes)
-SPECTOR_SEED_NODES=node-1:7070,node-2:7070,node-3:7070 \
-SPECTOR_NODE_ID=node-1 SPECTOR_PORT=7070 \
-  java --add-modules jdk.incubator.vector --enable-preview \
-  -cp spector-dist/target/spector.jar \
-  com.spectrayan.spector.node.SpectorNode
-```
-
----
-
-## 📡 Event System (17 Event Types)
-
-Subscribe via SSE:
-```bash
-# All events
-curl -N http://localhost:7070/api/v1/events
-
-# Filter by category
-curl -N http://localhost:7070/api/v1/events?filter=search,document
-```
-
-| Category | Events |
-|----------|--------|
-| `node` | `SpectorNodeStartedEvent`, `SpectorNodeStoppingEvent`, `SpectorNodeHealthChangedEvent` |
-| `search` | `SpectorSearchCompletedEvent`, `SpectorSearchFailedEvent` |
-| `document` | `SpectorDocumentIngestedEvent`, `SpectorDocumentDeletedEvent`, `SpectorBulkIngestCompletedEvent` |
-| `cluster` | `SpectorNodeJoinedEvent`, `SpectorNodeLeftEvent`, `SpectorShardRebalancedEvent`, `SpectorReplicaSyncCompletedEvent` |
-| `mcp` | `SpectorMcpClientConnectedEvent`, `SpectorMcpClientDisconnectedEvent`, `SpectorMcpToolExecutedEvent` |
-| `engine` | `SpectorIndexRebuiltEvent`, `SpectorEmbeddingProviderChangedEvent` |
-
----
-
-## 🔗 REST API Endpoints
-
-| Method | Path | Description |
-|--------|------|-------------|
-| `GET` | `/health` | K8s readiness/liveness probe |
-| `GET` | `/metrics` | Prometheus scrape endpoint |
-| `GET` | `/api/v1/status` | Engine status, SIMD info, cluster mode |
-| `GET` | `/api/v1/metrics` | Request metrics |
-| `POST` | `/api/v1/search` | Keyword/vector/hybrid search |
-| `GET` | `/api/v1/search/stream` | Streaming search via SSE |
-| `POST` | `/api/v1/ingest` | Ingest with pre-computed vector |
-| `POST` | `/api/v1/ingest/auto` | Ingest with auto-embedding |
-| `POST` | `/api/v1/ingest/bulk` | Batch ingest documents |
-| `POST` | `/api/v1/rag` | RAG context retrieval |
-| `DELETE` | `/api/v1/documents/{id}` | Delete document |
-| `GET` | `/api/v1/events` | Live event stream (SSE) |
diff --git a/spector-node/src/main/java/com/spectrayan/spector/cluster/GrpcErrorMapper.java b/spector-node/src/main/java/com/spectrayan/spector/cluster/GrpcErrorMapper.java
deleted file mode 100644
index 90837c6..0000000
--- a/spector-node/src/main/java/com/spectrayan/spector/cluster/GrpcErrorMapper.java
+++ /dev/null
@@ -1,200 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.cluster;
-
-import com.google.protobuf.Any;
-import com.google.rpc.ErrorInfo;
-import com.google.rpc.Code;
-import com.spectrayan.spector.commons.error.*;
-import com.spectrayan.spector.cluster.error.SpectorShardUnavailableException;
-
-import io.grpc.Status;
-import io.grpc.StatusRuntimeException;
-import io.grpc.protobuf.StatusProto;
-
-import java.time.Instant;
-import java.util.HashMap;
-import java.util.Map;
-
-/**
- * Utility for mapping between Spector exceptions and rich gRPC error details.
- *
- * <p>Implements the Google/gRPC Rich Error Model by embedding `com.google.rpc.ErrorInfo`
- * inside the protobuf-based `google.rpc.Status` message. This allows transparent error
- * propagation across distributed search shards.</p>
- */
-public final class GrpcErrorMapper {
-
-    private static final String ERROR_DOMAIN = "spector";
-
-    /**
-     * Translates a Throwable into a rich gRPC StatusRuntimeException.
-     *
-     * @param e the exception to map
-     * @return rich StatusRuntimeException
-     */
-    public static StatusRuntimeException toStatusRuntimeException(Throwable e) {
-        if (e instanceof StatusRuntimeException sre) {
-            return sre;
-        }
-
-        Code grpcCode = Code.INTERNAL;
-        String codeId = "SPE-900-001"; // Default internal error code
-        String category = "Internal";
-        String message = e.getMessage() != null ? e.getMessage() : "An unexpected error occurred";
-
-        if (e instanceof SpectorException se) {
-            ErrorCode ec = se.errorCode();
-            codeId = se.codeId();
-            category = ec.category().displayName();
-            grpcCode = mapCategoryToGrpcCode(ec.category(), ec);
-        }
-
-        // Build the rich ErrorInfo protobuf details
-        ErrorInfo errorInfo = ErrorInfo.newBuilder()
-                .setReason(codeId)
-                .setDomain(ERROR_DOMAIN)
-                .putMetadata("category", category)
-                .putMetadata("timestamp", Instant.now().toString())
-                .build();
-
-        // Build the google.rpc.Status message
-        com.google.rpc.Status status = com.google.rpc.Status.newBuilder()
-                .setCode(grpcCode.getNumber())
-                .setMessage(message)
-                .addDetails(Any.pack(errorInfo))
-                .build();
-
-        return StatusProto.toStatusRuntimeException(status);
-    }
-
-    /**
-     * Extracts a rich gRPC Status from a Throwable and reconstructs the matching SpectorException.
-     *
-     * @param e       the exception caught on the client side
-     * @param shardId the ID of the shard node that was called
-     * @return the reconstructed SpectorException subclass, or a generic SpectorShardUnavailableException
-     */
-    public static SpectorException toSpectorException(Throwable e, String shardId) {
-        if (e instanceof StatusRuntimeException sre) {
-            com.google.rpc.Status status = StatusProto.fromThrowable(sre);
-            if (status != null) {
-                for (Any any : status.getDetailsList()) {
-                    if (any.is(ErrorInfo.class)) {
-                        try {
-                            ErrorInfo errorInfo = any.unpack(ErrorInfo.class);
-                            String codeId = errorInfo.getReason();
-                            ErrorCode ec = ErrorCode.fromId(codeId);
-                            if (ec != null) {
-                                String message = status.getMessage();
-                                return instantiateCategoryException(ec, message, shardId);
-                            }
-                        } catch (Exception ex) {
-                            // Fallback to generic parsing below
-                        }
-                    }
-                }
-            }
-        }
-
-        if (e instanceof SpectorException se) {
-            return se;
-        }
-
-        return new SpectorShardUnavailableException(shardId, e);
-    }
-
-    private static SpectorException instantiateCategoryException(ErrorCode ec, String message, String shardId) {
-        switch (ec.category()) {
-            case VALIDATION:
-                return new SpectorValidationException(ec, message, true);
-            case CONFIG:
-                return new SpectorConfigException(ec, message, true);
-            case INDEX:
-                return new SpectorIndexException(ec, message, true);
-            case STORAGE:
-                return new SpectorStorageException(ec, message, true);
-            case EMBEDDING:
-                return new SpectorEmbeddingException(ec, message, true);
-            case MEMORY:
-                return new SpectorMemoryException(ec, message, true);
-            case GPU:
-                return new SpectorGpuException(ec, message, true);
-            case SERVER:
-                return new SpectorServerException(ec, message, true);
-            case CLIENT:
-                return new SpectorClientException(ec, message, true);
-            case INGESTION:
-                return new SpectorIngestionException(ec, message, true);
-            case CLUSTER:
-                if (ec == ErrorCode.SHARD_UNAVAILABLE) {
-                    return new SpectorShardUnavailableException(shardId);
-                }
-                return new SpectorClusterException(ec, message, true);
-            case INTERNAL:
-            default:
-                return new SpectorInternalException(ec, message, true);
-        }
-    }
-
-    private static Code mapCategoryToGrpcCode(ErrorCategory cat, ErrorCode ec) {
-        switch (cat) {
-            case VALIDATION:
-                return Code.INVALID_ARGUMENT;
-            case CONFIG:
-                return Code.FAILED_PRECONDITION;
-            case INDEX:
-                if (ec == ErrorCode.INDEX_READ_ONLY) return Code.FAILED_PRECONDITION;
-                if (ec == ErrorCode.INDEX_FULL) return Code.RESOURCE_EXHAUSTED;
-                return Code.INTERNAL;
-            case STORAGE:
-                if (ec == ErrorCode.STORE_FULL) return Code.RESOURCE_EXHAUSTED;
-                if (ec == ErrorCode.SEGMENT_CLOSED) return Code.FAILED_PRECONDITION;
-                return Code.INTERNAL;
-            case EMBEDDING:
-                if (ec == ErrorCode.EMBEDDING_UNAVAILABLE) return Code.UNAVAILABLE;
-                if (ec == ErrorCode.EMBEDDING_TIMEOUT) return Code.DEADLINE_EXCEEDED;
-                return Code.INTERNAL;
-            case MEMORY:
-                if (ec == ErrorCode.MEMORY_TIER_FULL) return Code.RESOURCE_EXHAUSTED;
-                return Code.INTERNAL;
-            case GPU:
-                if (ec == ErrorCode.GPU_MEMORY_EXHAUSTED || ec == ErrorCode.GPU_BUDGET_EXCEEDED) {
-                    return Code.RESOURCE_EXHAUSTED;
-                }
-                return Code.INTERNAL;
-            case SERVER:
-                if (ec == ErrorCode.API_UNAUTHORIZED) return Code.UNAUTHENTICATED;
-                if (ec == ErrorCode.API_NOT_FOUND) return Code.NOT_FOUND;
-                if (ec == ErrorCode.API_CONFLICT) return Code.ALREADY_EXISTS;
-                if (ec == ErrorCode.API_SERVICE_UNAVAILABLE) return Code.UNAVAILABLE;
-                return Code.INTERNAL;
-            case CLIENT:
-                if (ec == ErrorCode.CLIENT_CONNECTION_FAILED) return Code.UNAVAILABLE;
-                if (ec == ErrorCode.CLIENT_TIMEOUT) return Code.DEADLINE_EXCEEDED;
-                return Code.INTERNAL;
-            case INGESTION:
-                if (ec == ErrorCode.INGESTION_FORMAT_UNSUPPORTED) return Code.INVALID_ARGUMENT;
-                return Code.INTERNAL;
-            case CLUSTER:
-                return Code.UNAVAILABLE;
-            default:
-                return Code.INTERNAL;
-        }
-    }
-
-    private GrpcErrorMapper() {}
-}
diff --git a/spector-node/src/main/java/com/spectrayan/spector/cluster/NodeStatus.java b/spector-node/src/main/java/com/spectrayan/spector/cluster/NodeStatus.java
deleted file mode 100644
index 5a7c4b6..0000000
--- a/spector-node/src/main/java/com/spectrayan/spector/cluster/NodeStatus.java
+++ /dev/null
@@ -1,28 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.cluster;
-
-/**
- * Represents the current status of a node in the cluster.
- */
-public enum NodeStatus {
-    /** Node is actively participating and responding to heartbeats. */
-    ACTIVE,
-    /** Node has failed heartbeat checks and is considered down. */
-    UNAVAILABLE,
-    /** Node is recovering and synchronizing data. */
-    SYNCING
-}
diff --git a/spector-node/src/main/java/com/spectrayan/spector/cluster/ReplicaState.java b/spector-node/src/main/java/com/spectrayan/spector/cluster/ReplicaState.java
deleted file mode 100644
index 9128605..0000000
--- a/spector-node/src/main/java/com/spectrayan/spector/cluster/ReplicaState.java
+++ /dev/null
@@ -1,28 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.cluster;
-
-/**
- * Represents the state of a replica in the replication group.
- */
-public enum ReplicaState {
-    /** Replica is fully synchronized and serving reads. */
-    ACTIVE,
-    /** Replica is synchronizing with the primary (not serving reads). */
-    SYNCING,
-    /** Replica is unreachable/failed. */
-    UNAVAILABLE
-}
diff --git a/spector-node/src/main/java/com/spectrayan/spector/cluster/ShardAssignment.java b/spector-node/src/main/java/com/spectrayan/spector/cluster/ShardAssignment.java
deleted file mode 100644
index ce063c1..0000000
--- a/spector-node/src/main/java/com/spectrayan/spector/cluster/ShardAssignment.java
+++ /dev/null
@@ -1,26 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.cluster;
-
-/**
- * Represents a shard assignment to a node with a specific role.
- *
- * @param shardIndex   the shard index
- * @param nodeEndpoint the endpoint of the node hosting this shard
- * @param role         the role of this assignment (PRIMARY or REPLICA)
- */
-public record ShardAssignment(int shardIndex, String nodeEndpoint, ShardRole role) {
-}
diff --git a/spector-node/src/main/java/com/spectrayan/spector/cluster/ShardRole.java b/spector-node/src/main/java/com/spectrayan/spector/cluster/ShardRole.java
deleted file mode 100644
index 6753ce9..0000000
--- a/spector-node/src/main/java/com/spectrayan/spector/cluster/ShardRole.java
+++ /dev/null
@@ -1,26 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.cluster;
-
-/**
- * Role of a shard assignment on a node.
- */
-public enum ShardRole {
-    /** The authoritative copy of the shard data. */
-    PRIMARY,
-    /** A replica copy for fault tolerance. */
-    REPLICA
-}
diff --git a/spector-node/src/main/java/com/spectrayan/spector/cluster/error/SpectorClusterRoutingException.java b/spector-node/src/main/java/com/spectrayan/spector/cluster/error/SpectorClusterRoutingException.java
deleted file mode 100644
index 5241d1d..0000000
--- a/spector-node/src/main/java/com/spectrayan/spector/cluster/error/SpectorClusterRoutingException.java
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.cluster.error;
-
-import com.spectrayan.spector.commons.error.*;
-
-/**
- * Exception thrown when a request cannot be routed to the appropriate shard in the cluster.
- *
- * @see SpectorClusterException
- */
-public class SpectorClusterRoutingException extends SpectorClusterException {
-
-    private final String details;
-
-    public SpectorClusterRoutingException(String details) {
-        super(ErrorCode.CLUSTER_ROUTING_FAILED, details);
-        this.details = details;
-    }
-
-    public SpectorClusterRoutingException(String details, Throwable cause) {
-        super(ErrorCode.CLUSTER_ROUTING_FAILED, cause, details);
-        this.details = details;
-    }
-
-    /** Returns details of the cluster routing failure. */
-    public String getDetails() {
-        return details;
-    }
-}
diff --git a/spector-node/src/main/java/com/spectrayan/spector/cluster/error/SpectorMembershipException.java b/spector-node/src/main/java/com/spectrayan/spector/cluster/error/SpectorMembershipException.java
deleted file mode 100644
index 1e90a50..0000000
--- a/spector-node/src/main/java/com/spectrayan/spector/cluster/error/SpectorMembershipException.java
+++ /dev/null
@@ -1,34 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.cluster.error;
-
-import com.spectrayan.spector.commons.error.*;
-
-/**
- * Exception thrown when a cluster membership operation fails.
- *
- * @see SpectorClusterException
- */
-public class SpectorMembershipException extends SpectorClusterException {
-
-    public SpectorMembershipException(String message) {
-        super(ErrorCode.CLUSTER_MEMBERSHIP_FAILED, message);
-    }
-
-    public SpectorMembershipException(String message, Throwable cause) {
-        super(ErrorCode.CLUSTER_MEMBERSHIP_FAILED, cause, message);
-    }
-}
diff --git a/spector-node/src/main/java/com/spectrayan/spector/cluster/error/SpectorShardUnavailableException.java b/spector-node/src/main/java/com/spectrayan/spector/cluster/error/SpectorShardUnavailableException.java
deleted file mode 100644
index fbcede6..0000000
--- a/spector-node/src/main/java/com/spectrayan/spector/cluster/error/SpectorShardUnavailableException.java
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.cluster.error;
-
-import com.spectrayan.spector.commons.error.*;
-
-/**
- * Exception thrown when a target shard is not reachable or has been decommissioned.
- *
- * @see SpectorClusterException
- */
-public class SpectorShardUnavailableException extends SpectorClusterException {
-
-    private final String shardId;
-
-    public SpectorShardUnavailableException(String shardId) {
-        super(ErrorCode.SHARD_UNAVAILABLE, shardId);
-        this.shardId = shardId;
-    }
-
-    public SpectorShardUnavailableException(String shardId, Throwable cause) {
-        super(ErrorCode.SHARD_UNAVAILABLE, cause, shardId);
-        this.shardId = shardId;
-    }
-
-    /** Returns the ID of the shard that is unavailable. */
-    public String getShardId() {
-        return shardId;
-    }
-}
diff --git a/spector-node/src/main/java/com/spectrayan/spector/node/NodeConfig.java b/spector-node/src/main/java/com/spectrayan/spector/node/NodeConfig.java
deleted file mode 100644
index 467c669..0000000
--- a/spector-node/src/main/java/com/spectrayan/spector/node/NodeConfig.java
+++ /dev/null
@@ -1,156 +0,0 @@
-package com.spectrayan.spector.node;
-
-import java.net.InetAddress;
-import java.time.Duration;
-import java.util.List;
-
-/**
- * Configuration for a Spector node instance.
- *
- * <p>Supports two deployment modes:</p>
- * <ul>
- *   <li><b>STANDALONE</b> — single node, local engine only. Default when
- *       {@code SPECTOR_SEED_NODES} is not set.</li>
- *   <li><b>CLUSTERED</b> — multi-node, gRPC fan-out, consistent hash
- *       sharding, heartbeat membership. Activated when seed nodes are
- *       provided.</li>
- * </ul>
- *
- * <h3>Environment Variables</h3>
- * <pre>
- *   SPECTOR_PORT              — HTTP + gRPC port (default 7070)
- *   SPECTOR_NODE_ID           — unique node identifier (default: hostname)
- *   SPECTOR_SEED_NODES        — comma-separated list of seed endpoints (triggers CLUSTERED mode)
- *   SPECTOR_API_KEY           — optional API key for authentication
- *   SPECTOR_MCP_ENABLED       — "false" to disable MCP-over-SSE (default: enabled)
- *   SPECTOR_DIMS              — vector dimensions (default: 384)
- *   SPECTOR_MAX_CONNECTIONS   — max server connections (default: 10000)
- *   SPECTOR_REQUEST_TIMEOUT   — request timeout in seconds (default: 30)
- *   SPECTOR_COMPRESSION       — "false" to disable gzip/brotli (default: enabled)
- *   SPECTOR_IDLE_TIMEOUT      — idle connection timeout in seconds (default: 60)
- * </pre>
- *
- * @param port                 the single port for HTTP REST + gRPC + MCP SSE + Prometheus
- * @param mode                 deployment mode
- * @param nodeId               unique node identifier
- * @param seedNodes            cluster seed endpoints (empty in standalone)
- * @param apiKey               optional API key (null = no auth)
- * @param mcpEnabled           whether to serve MCP over SSE at /mcp
- * @param dimensions           vector dimensions for the engine
- * @param maxConnections       maximum concurrent connections
- * @param requestTimeout       per-request timeout
- * @param compressionEnabled   whether to enable response compression
- * @param idleTimeout          idle connection timeout
- */
-public record NodeConfig(
-        int port,
-        NodeMode mode,
-        String nodeId,
-        List<String> seedNodes,
-        String apiKey,
-        boolean mcpEnabled,
-        int dimensions,
-        int maxConnections,
-        Duration requestTimeout,
-        boolean compressionEnabled,
-        Duration idleTimeout
-) {
-
-    /** Deployment mode. */
-    public enum NodeMode {
-        /** Single node — local engine, no cluster coordination. */
-        STANDALONE,
-        /** Multi-node — gRPC fan-out, consistent hash sharding, HA. */
-        CLUSTERED
-    }
-
-    /** Default HTTP + gRPC port. */
-    public static final int DEFAULT_PORT = 7070;
-
-    /** Default vector dimensions. */
-    public static final int DEFAULT_DIMENSIONS = 384;
-
-    /** Default max connections. */
-    public static final int DEFAULT_MAX_CONNECTIONS = 10_000;
-
-    /** Default request timeout. */
-    public static final Duration DEFAULT_REQUEST_TIMEOUT = Duration.ofSeconds(30);
-
-    /** Default idle timeout. */
-    public static final Duration DEFAULT_IDLE_TIMEOUT = Duration.ofSeconds(60);
-
-    /**
-     * Creates a NodeConfig from environment variables.
-     *
-     * <p>Mode is auto-detected: if {@code SPECTOR_SEED_NODES} is set,
-     * the node starts in CLUSTERED mode. Otherwise, STANDALONE.</p>
-     */
-    public static NodeConfig fromEnv() {
-        String seeds = System.getenv("SPECTOR_SEED_NODES");
-        boolean clustered = seeds != null && !seeds.isBlank();
-
-        return new NodeConfig(
-                envInt("SPECTOR_PORT", DEFAULT_PORT),
-                clustered ? NodeMode.CLUSTERED : NodeMode.STANDALONE,
-                envOrHostname("SPECTOR_NODE_ID"),
-                clustered ? List.of(seeds.split(",")) : List.of(),
-                System.getenv("SPECTOR_API_KEY"),
-                !"false".equalsIgnoreCase(System.getenv("SPECTOR_MCP_ENABLED")),
-                envInt("SPECTOR_DIMS", DEFAULT_DIMENSIONS),
-                envInt("SPECTOR_MAX_CONNECTIONS", DEFAULT_MAX_CONNECTIONS),
-                Duration.ofSeconds(envInt("SPECTOR_REQUEST_TIMEOUT", (int) DEFAULT_REQUEST_TIMEOUT.toSeconds())),
-                !"false".equalsIgnoreCase(System.getenv("SPECTOR_COMPRESSION")),
-                Duration.ofSeconds(envInt("SPECTOR_IDLE_TIMEOUT", (int) DEFAULT_IDLE_TIMEOUT.toSeconds()))
-        );
-    }
-
-    /**
-     * Creates a standalone config for programmatic use.
-     */
-    public static NodeConfig standalone(int port, int dimensions) {
-        return new NodeConfig(
-                port,
-                NodeMode.STANDALONE,
-                resolveHostname(),
-                List.of(),
-                null,
-                true,
-                dimensions,
-                DEFAULT_MAX_CONNECTIONS,
-                DEFAULT_REQUEST_TIMEOUT,
-                true,
-                DEFAULT_IDLE_TIMEOUT
-        );
-    }
-
-    /** Whether this node is in clustered mode. */
-    public boolean isClustered() {
-        return mode == NodeMode.CLUSTERED;
-    }
-
-    // ─────────────── Helpers ───────────────
-
-    private static int envInt(String key, int defaultValue) {
-        String value = System.getenv(key);
-        if (value == null || value.isBlank()) return defaultValue;
-        try {
-            return Integer.parseInt(value.trim());
-        } catch (NumberFormatException e) {
-            return defaultValue;
-        }
-    }
-
-    private static String envOrHostname(String key) {
-        String value = System.getenv(key);
-        if (value != null && !value.isBlank()) return value.trim();
-        return resolveHostname();
-    }
-
-    private static String resolveHostname() {
-        try {
-            return InetAddress.getLocalHost().getHostName();
-        } catch (Exception e) {
-            return "spector-node-" + ProcessHandle.current().pid();
-        }
-    }
-}
diff --git a/spector-node/src/main/java/com/spectrayan/spector/node/SpectorNode.java b/spector-node/src/main/java/com/spectrayan/spector/node/SpectorNode.java
deleted file mode 100644
index 3bf6b4c..0000000
--- a/spector-node/src/main/java/com/spectrayan/spector/node/SpectorNode.java
+++ /dev/null
@@ -1,288 +0,0 @@
-package com.spectrayan.spector.node;
-
-import java.time.Instant;
-import java.util.List;
-import java.util.Map;
-import java.util.concurrent.CompletableFuture;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import com.linecorp.armeria.common.HttpMethod;
-import com.linecorp.armeria.common.HttpResponse;
-import com.linecorp.armeria.common.HttpStatus;
-import com.linecorp.armeria.common.MediaType;
-import com.linecorp.armeria.server.Server;
-import com.linecorp.armeria.server.ServerBuilder;
-import com.linecorp.armeria.server.cors.CorsService;
-import com.linecorp.armeria.server.encoding.EncodingService;
-import com.linecorp.armeria.server.grpc.GrpcService;
-import com.linecorp.armeria.server.healthcheck.HealthCheckService;
-import com.linecorp.armeria.server.logging.AccessLogWriter;
-
-import com.spectrayan.spector.cluster.ClusterCoordinator;
-import com.spectrayan.spector.cluster.SpectorSearchServiceImpl;
-import com.spectrayan.spector.config.SpectorConfig;
-import com.spectrayan.spector.core.simd.SimdCapability;
-import com.spectrayan.spector.engine.DefaultSpectorEngine;
-import com.spectrayan.spector.engine.SpectorEngine;
-import com.spectrayan.spector.memory.SpectorMemory;
-import com.spectrayan.spector.metrics.MeteredSpectorEngine;
-import com.spectrayan.spector.metrics.SpectorMetrics;
-import com.spectrayan.spector.metrics.SpectorJvmMetrics;
-import com.spectrayan.spector.node.api.ApiModule;
-import com.spectrayan.spector.node.api.v1.*;
-import com.spectrayan.spector.node.event.*;
-import com.spectrayan.spector.node.service.IngestService;
-import com.spectrayan.spector.node.service.RagService;
-import com.spectrayan.spector.node.service.SearchService;
-import com.spectrayan.spector.runtime.SpectorRuntime;
-
-import io.micrometer.prometheusmetrics.PrometheusConfig;
-import io.micrometer.prometheusmetrics.PrometheusMeterRegistry;
-
-/**
- * Unified Spector node — serves HTTP REST, gRPC, and Prometheus metrics
- * on a single Armeria (Netty) port.
- *
- * <h3>Architecture</h3>
- * <p>Every Spector node is identical. In standalone mode it serves local search.
- * In clustered mode it additionally participates in cluster membership and
- * fans out queries to peer nodes via gRPC — all on the same port.</p>
- *
- * <h3>Protocols Served (single port)</h3>
- * <ul>
- *   <li><b>HTTP REST</b>: {@code /api/v1/*} — client-facing APIs (via {@link ApiModule})</li>
- *   <li><b>gRPC</b>: auto-detected via {@code application/grpc} content-type</li>
- *   <li><b>Prometheus</b>: {@code /metrics} — scrape endpoint</li>
- *   <li><b>Health</b>: {@code /health} — K8s readiness/liveness probes</li>
- *   <li><b>SSE Events</b>: {@code /api/v1/events} — live event stream</li>
- * </ul>
- *
- * <h3>Design Patterns</h3>
- * <ul>
- *   <li><b>Facade</b>: {@link SearchService}, {@link IngestService}, {@link RagService}</li>
- *   <li><b>Observer</b>: {@link SpectorEventBus} — pub/sub for all node events</li>
- *   <li><b>Factory</b>: {@link ApiModule} — pluggable endpoint registration</li>
- *   <li><b>Strategy</b>: Local vs cluster routing in service facades</li>
- * </ul>
- *
- * <h3>Usage</h3>
- * <pre>{@code
- *   SpectorNode node = SpectorNode.create(NodeConfig.standalone(7070, 384));
- *   node.start();
- * }</pre>
- */
-public class SpectorNode implements AutoCloseable {
-
-    private static final Logger log = LoggerFactory.getLogger(SpectorNode.class);
-
-    private final NodeConfig nodeConfig;
-    private final SpectorEngine engine;
-    private final SpectorMemory memory; // nullable
-    private final PrometheusMeterRegistry prometheusRegistry;
-    private final SpectorEventBus eventBus;
-    private final ClusterCoordinator coordinator; // null in standalone
-    private Server server;
-
-    private SpectorNode(NodeConfig nodeConfig, SpectorEngine engine, SpectorMemory memory,
-                        PrometheusMeterRegistry prometheusRegistry, SpectorEventBus eventBus,
-                        ClusterCoordinator coordinator) {
-        this.nodeConfig = nodeConfig;
-        this.engine = engine;
-        this.memory = memory;
-        this.prometheusRegistry = prometheusRegistry;
-        this.eventBus = eventBus;
-        this.coordinator = coordinator;
-    }
-
-    /**
-     * Creates a SpectorNode with default engine configuration.
-     *
-     * @param nodeConfig node configuration
-     * @return a new SpectorNode instance (not yet started)
-     */
-    public static SpectorNode create(NodeConfig nodeConfig) {
-        var prometheusRegistry = new PrometheusMeterRegistry(PrometheusConfig.DEFAULT);
-        SpectorMetrics.init(prometheusRegistry);
-        SpectorJvmMetrics.bind(prometheusRegistry);
-
-        var engineConfig = SpectorConfig.DEFAULT.withDimensions(nodeConfig.dimensions());
-        SpectorEngine engine = new DefaultSpectorEngine(engineConfig);
-        engine = new MeteredSpectorEngine(engine, prometheusRegistry);
-
-        var eventBus = new SpectorEventBus();
-
-        // Cluster coordinator (null in standalone)
-        ClusterCoordinator coordinator = null;
-        if (nodeConfig.isClustered()) {
-            // TODO: wire ClusterConfig from seed nodes
-            log.info("Clustered mode enabled — seed nodes: {}", nodeConfig.seedNodes());
-        }
-
-        return new SpectorNode(nodeConfig, engine, null, prometheusRegistry, eventBus, coordinator);
-    }
-
-    /**
-     * Creates a SpectorNode backed by a pre-configured runtime.
-     *
-     * @param runtime    the Spector runtime (engine + memory)
-     * @param nodeConfig node configuration
-     * @return a new SpectorNode instance (not yet started)
-     */
-    public static SpectorNode create(SpectorRuntime runtime, NodeConfig nodeConfig) {
-        var prometheusRegistry = new PrometheusMeterRegistry(PrometheusConfig.DEFAULT);
-        SpectorMetrics.init(prometheusRegistry);
-        SpectorJvmMetrics.bind(prometheusRegistry);
-
-        SpectorEngine engine = runtime.engine() instanceof MeteredSpectorEngine
-                ? runtime.engine()
-                : new MeteredSpectorEngine(runtime.engine(), prometheusRegistry);
-
-        var eventBus = new SpectorEventBus();
-
-        return new SpectorNode(nodeConfig, engine, runtime.memory(), prometheusRegistry, eventBus, null);
-    }
-
-    /**
-     * Starts the Armeria server.
-     *
-     * <p>Builds the service facades, registers versioned API modules,
-     * configures gRPC, health, Prometheus, CORS, auth, and compression.
-     * Blocks until the server is fully started.</p>
-     */
-    public void start() {
-        // ── Build service facades ──
-        SearchService searchService = new SearchService(engine, coordinator, eventBus, nodeConfig.nodeId());
-        IngestService ingestService = new IngestService(engine, coordinator, eventBus, nodeConfig.nodeId());
-        RagService ragService = new RagService(engine);
-
-        // ── Assemble API v1 modules ──
-        List<ApiModule> v1Modules = List.of(
-                new SearchEndpoint(searchService),
-                new IngestEndpoint(ingestService),
-                new RagEndpoint(ragService),
-                new DocumentEndpoint(ingestService),
-                new StatusEndpoint(engine, nodeConfig, eventBus, coordinator),
-                new EventStreamEndpoint(eventBus)
-        );
-
-        // ── Build Armeria server ──
-        ServerBuilder sb = Server.builder()
-                .http(nodeConfig.port())
-                .maxNumConnections(nodeConfig.maxConnections())
-                .requestTimeout(nodeConfig.requestTimeout())
-                .idleTimeout(nodeConfig.idleTimeout());
-
-        // Register v1 API modules
-        for (ApiModule module : v1Modules) {
-            sb.annotatedService("/api/v1" + module.pathPrefix(), module);
-        }
-
-        // ── gRPC (auto-detected via content-type: application/grpc) ──
-        sb.service(GrpcService.builder()
-                .addService(new SpectorSearchServiceImpl(nodeConfig.nodeId(), engine))
-                .build());
-
-        // ── Health check (K8s readiness/liveness) ──
-        sb.service("/health", HealthCheckService.of());
-
-        // ── Prometheus metrics ──
-        sb.service("/metrics", (ctx, req) ->
-                HttpResponse.of(HttpStatus.OK,
-                        MediaType.parse("text/plain; version=0.0.4; charset=utf-8"),
-                        prometheusRegistry.scrape()));
-
-        // ── API key authentication ──
-        if (nodeConfig.apiKey() != null && !nodeConfig.apiKey().isBlank()) {
-            sb.decorator("/api/", (delegate, ctx, req) -> {
-                String provided = req.headers().get("X-API-Key");
-                if (!nodeConfig.apiKey().equals(provided)) {
-                    return HttpResponse.ofJson(HttpStatus.UNAUTHORIZED,
-                            Map.of("error", "Invalid or missing API key"));
-                }
-                return delegate.serve(ctx, req);
-            });
-        }
-
-        // ── CORS ──
-        sb.decorator(CorsService.builderForAnyOrigin()
-                .allowRequestMethods(HttpMethod.GET, HttpMethod.POST, HttpMethod.DELETE, HttpMethod.OPTIONS)
-                .allowRequestHeaders("Content-Type", "X-API-Key", "Authorization")
-                .newDecorator());
-
-        // ── Response compression (configurable) ──
-        if (nodeConfig.compressionEnabled()) {
-            sb.decorator(EncodingService.builder()
-                    .minBytesToForceChunkedEncoding(1024)
-                    .newDecorator());
-        }
-
-        // ── Access logging ──
-        sb.accessLogWriter(AccessLogWriter.combined(), true);
-
-        // ── Build and start ──
-        server = sb.build();
-        CompletableFuture<Void> future = server.start();
-        future.join();
-
-        // Publish started event
-        eventBus.publish(new SpectorNodeStartedEvent(
-                nodeConfig.nodeId(), Instant.now(),
-                nodeConfig.port(), nodeConfig.mode().name()));
-
-        log.info("SpectorNode '{}' started on port {} — mode={}, dims={}, auth={}, compression={}, {}",
-                nodeConfig.nodeId(),
-                nodeConfig.port(),
-                nodeConfig.mode(),
-                engine.config().dimensions(),
-                nodeConfig.apiKey() != null ? "API-key" : "none",
-                nodeConfig.compressionEnabled() ? "enabled" : "disabled",
-                SimdCapability.report());
-    }
-
-    /**
-     * Stops the server and closes the engine.
-     */
-    @Override
-    public void close() {
-        eventBus.publish(new SpectorNodeStoppingEvent(
-                nodeConfig.nodeId(), Instant.now(), "shutdown"));
-
-        if (server != null) {
-            server.stop().join();
-        }
-        engine.close();
-        log.info("SpectorNode '{}' stopped", nodeConfig.nodeId());
-    }
-
-    /** Returns the underlying engine. */
-    public SpectorEngine engine() { return engine; }
-
-    /** Returns the node configuration. */
-    public NodeConfig config() { return nodeConfig; }
-
-    /** Returns the event bus for subscribing to node events. */
-    public SpectorEventBus eventBus() { return eventBus; }
-
-    /** Returns the Armeria server (for testing). */
-    public Server server() { return server; }
-
-    // ─────────────── Main ───────────────
-
-    /**
-     * Entry point for the Spector node.
-     *
-     * <p>Reads configuration from environment variables. In standalone mode,
-     * starts a local search node. In clustered mode, joins the cluster.</p>
-     */
-    public static void main(String[] args) {
-        NodeConfig nodeConfig = NodeConfig.fromEnv();
-        SpectorNode node = SpectorNode.create(nodeConfig);
-
-        Runtime.getRuntime().addShutdownHook(new Thread(node::close));
-        node.start();
-
-        log.info("Spector ready — http://localhost:{}/health", nodeConfig.port());
-    }
-}
diff --git a/spector-node/src/main/java/com/spectrayan/spector/node/api/ApiModule.java b/spector-node/src/main/java/com/spectrayan/spector/node/api/ApiModule.java
deleted file mode 100644
index 4c44b6d..0000000
--- a/spector-node/src/main/java/com/spectrayan/spector/node/api/ApiModule.java
+++ /dev/null
@@ -1,40 +0,0 @@
-package com.spectrayan.spector.node.api;
-
-/**
- * Pluggable API endpoint module for Spector node.
- *
- * <p>Each module represents a group of related endpoints (search, ingest, etc.)
- * that are registered on the Armeria server under a versioned path prefix.</p>
- *
- * <h3>API Versioning</h3>
- * <p>{@link com.spectrayan.spector.node.SpectorNode} registers modules at:</p>
- * <pre>{@code
- *   /api/v1 + module.pathPrefix()
- * }</pre>
- *
- * <p>For API v2 with breaking changes, create new endpoint classes implementing
- * this interface and register them at {@code /api/v2}.</p>
- *
- * <h3>Example</h3>
- * <pre>{@code
- *   public class SearchEndpoint implements ApiModule {
- *       @Override public String pathPrefix() { return ""; }
- *
- *       @Post("/search")
- *       public HttpResponse search(SearchRequest request) { ... }
- *   }
- * }</pre>
- */
-public interface ApiModule {
-
-    /**
-     * Path prefix for this module's endpoints.
-     *
-     * <p>Combined with the API version prefix by SpectorNode. For example,
-     * if this returns {@code ""}, endpoints are at {@code /api/v1/...}.
-     * If this returns {@code "/admin"}, endpoints are at {@code /api/v1/admin/...}.</p>
-     *
-     * @return the path prefix (empty string for root, or "/subpath")
-     */
-    String pathPrefix();
-}
diff --git a/spector-node/src/main/java/com/spectrayan/spector/node/api/dto/BulkIngestRequest.java b/spector-node/src/main/java/com/spectrayan/spector/node/api/dto/BulkIngestRequest.java
deleted file mode 100644
index 006099c..0000000
--- a/spector-node/src/main/java/com/spectrayan/spector/node/api/dto/BulkIngestRequest.java
+++ /dev/null
@@ -1,26 +0,0 @@
-package com.spectrayan.spector.node.api.dto;
-
-import java.util.List;
-
-import com.spectrayan.spector.commons.error.ErrorCode;
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-
-/**
- * Request DTO for bulk document ingestion ({@code POST /api/v1/ingest/bulk}).
- */
-public class BulkIngestRequest {
-
-    /** List of documents to ingest. */
-    public List<IngestRequest> documents;
-
-    /**
-     * Validates that the documents list is non-empty.
-     *
-     * @throws ValidationException if validation fails
-     */
-    public void validate() {
-        if (documents == null || documents.isEmpty()) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_INVALID, "documents", "non-empty array required");
-        }
-    }
-}
diff --git a/spector-node/src/main/java/com/spectrayan/spector/node/api/dto/IngestRequest.java b/spector-node/src/main/java/com/spectrayan/spector/node/api/dto/IngestRequest.java
deleted file mode 100644
index e899a59..0000000
--- a/spector-node/src/main/java/com/spectrayan/spector/node/api/dto/IngestRequest.java
+++ /dev/null
@@ -1,57 +0,0 @@
-package com.spectrayan.spector.node.api.dto;
-
-import com.spectrayan.spector.commons.error.ErrorCode;
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-
-/**
- * Request DTO for document ingestion ({@code POST /api/v1/ingest}).
- *
- * <p>For auto-embedding (no vector provided), use {@code POST /api/v1/ingest/auto}
- * which does not require the {@code vector} field.</p>
- */
-public class IngestRequest {
-
-    /** Document ID (required). */
-    public String id;
-
-    /** Optional document title. */
-    public String title;
-
-    /** Document content (required). */
-    public String content;
-
-    /** Pre-computed embedding vector (required for /ingest, optional for /ingest/auto). */
-    public float[] vector;
-
-    /**
-     * Validates the required fields for manual ingestion (with vector).
-     *
-     * @param expectedDimensions the expected vector dimensions from engine config
-     * @throws ValidationException if validation fails
-     */
-    public void validateForIngest(int expectedDimensions) {
-        if (id == null || id.isEmpty()) throw new SpectorValidationException(ErrorCode.ARGUMENT_INVALID, "id", "required");
-        if (content == null || content.isEmpty()) throw new SpectorValidationException(ErrorCode.ARGUMENT_INVALID, "content", "required");
-        if (vector == null || vector.length == 0) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_INVALID, "vector", "required (use /api/v1/ingest/auto for auto-embedding)");
-        }
-        if (vector.length != expectedDimensions) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_INVALID, "vector", "dimension mismatch: expected " + expectedDimensions + ", got " + vector.length);
-        }
-    }
-
-    /**
-     * Validates the required fields for auto-embedding ingestion.
-     *
-     * @throws ValidationException if validation fails
-     */
-    public void validateForAutoIngest() {
-        if (id == null || id.isEmpty()) throw new SpectorValidationException(ErrorCode.ARGUMENT_INVALID, "id", "required");
-        if (content == null || content.isEmpty()) throw new SpectorValidationException(ErrorCode.ARGUMENT_INVALID, "content", "required");
-    }
-
-    /** Returns the title, defaulting to empty string if null. */
-    public String titleOrEmpty() {
-        return title != null ? title : "";
-    }
-}
diff --git a/spector-node/src/main/java/com/spectrayan/spector/node/api/dto/ProblemDetail.java b/spector-node/src/main/java/com/spectrayan/spector/node/api/dto/ProblemDetail.java
deleted file mode 100644
index 5b051f9..0000000
--- a/spector-node/src/main/java/com/spectrayan/spector/node/api/dto/ProblemDetail.java
+++ /dev/null
@@ -1,141 +0,0 @@
-package com.spectrayan.spector.node.api.dto;
-
-import java.net.URI;
-import java.time.Instant;
-
-import com.fasterxml.jackson.annotation.JsonInclude;
-import com.fasterxml.jackson.annotation.JsonProperty;
-import com.fasterxml.jackson.annotation.JsonPropertyOrder;
-
-import com.spectrayan.spector.commons.error.ErrorCode;
-import com.spectrayan.spector.commons.error.SpectorException;
-
-/**
- * RFC 9457 (Problem Details for HTTP APIs) compliant error response.
- *
- * <p>Content-Type: {@code application/problem+json}</p>
- *
- * <h3>Standard Members (RFC 9457 §3.1)</h3>
- * <ul>
- *   <li>{@code type}     — URI reference identifying the problem type</li>
- *   <li>{@code title}    — short human-readable summary of the problem type</li>
- *   <li>{@code status}   — HTTP status code</li>
- *   <li>{@code detail}   — human-readable explanation specific to this occurrence</li>
- *   <li>{@code instance} — URI reference identifying the specific occurrence</li>
- * </ul>
- *
- * <h3>Extension Members (Spector-specific)</h3>
- * <ul>
- *   <li>{@code errorCode}  — Spector error code, e.g. {@code "SPE-100-002"}</li>
- *   <li>{@code category}   — error category, e.g. {@code "Validation"}</li>
- *   <li>{@code timestamp}  — ISO-8601 timestamp of when the error occurred</li>
- * </ul>
- *
- * <h3>Example</h3>
- * <pre>{@code
- * {
- *   "type": "https://docs.spectrayan.com/errors/SPE-100-002",
- *   "title": "Validation Error",
- *   "status": 400,
- *   "detail": "[SPE-100-002] Expected 384 dimensions but received 768",
- *   "instance": "/api/v1/ingest",
- *   "errorCode": "SPE-100-002",
- *   "category": "Validation",
- *   "timestamp": "2026-05-30T12:00:00Z"
- * }
- * }</pre>
- *
- * @see <a href="https://www.rfc-editor.org/rfc/rfc9457">RFC 9457</a>
- */
-@JsonInclude(JsonInclude.Include.NON_NULL)
-@JsonPropertyOrder({"type", "title", "status", "detail", "instance", "errorCode", "category", "timestamp"})
-public record ProblemDetail(
-
-        /** URI reference identifying the problem type (RFC 9457 §3.1.1). */
-        @JsonProperty("type")
-        URI type,
-
-        /** Short human-readable summary of the problem type (RFC 9457 §3.1.3). */
-        @JsonProperty("title")
-        String title,
-
-        /** HTTP status code (RFC 9457 §3.1.2). */
-        @JsonProperty("status")
-        int status,
-
-        /** Human-readable explanation specific to this occurrence (RFC 9457 §3.1.4). */
-        @JsonProperty("detail")
-        String detail,
-
-        /** URI reference identifying the specific occurrence (RFC 9457 §3.1.5). */
-        @JsonProperty("instance")
-        String instance,
-
-        // ── Spector extension members ──
-
-        /** Spector error code, e.g. "SPE-100-002". */
-        @JsonProperty("errorCode")
-        String errorCode,
-
-        /** Error category display name, e.g. "Validation". */
-        @JsonProperty("category")
-        String category,
-
-        /** ISO-8601 timestamp of the error. */
-        @JsonProperty("timestamp")
-        String timestamp
-) {
-    /** Base URI for Spector error type documentation. */
-    private static final String ERROR_TYPE_BASE = "https://docs.spectrayan.com/errors/";
-
-    /** Default type URI for unknown/untyped errors (RFC 9457 §3.1.1). */
-    private static final URI ABOUT_BLANK = URI.create("about:blank");
-
-    /**
-     * Creates a ProblemDetail from a {@link SpectorException}.
-     *
-     * @param e        the Spector exception
-     * @param status   the HTTP status code to return
-     * @param instance the request path that triggered the error
-     * @return a fully populated ProblemDetail
-     */
-    public static ProblemDetail fromException(SpectorException e, int status, String instance) {
-        ErrorCode code = e.errorCode();
-        String codeId = e.codeId();
-        return new ProblemDetail(
-                URI.create(ERROR_TYPE_BASE + codeId),
-                code.category().displayName() + " Error",
-                status,
-                e.getMessage(),
-                instance,
-                codeId,
-                code.category().displayName(),
-                Instant.now().toString()
-        );
-    }
-
-    /**
-     * Creates a ProblemDetail for an error without a Spector error code.
-     *
-     * <p>Per RFC 9457 §3.1.1, when no specific type is defined, the type
-     * SHOULD be {@code "about:blank"}.</p>
-     *
-     * @param status   the HTTP status code
-     * @param title    short description (e.g. "Bad Request")
-     * @param detail   specific error message
-     * @param instance the request path
-     * @return a ProblemDetail with no Spector extensions
-     */
-    public static ProblemDetail of(int status, String title, String detail, String instance) {
-        return new ProblemDetail(
-                ABOUT_BLANK,
-                title,
-                status,
-                detail,
-                instance,
-                null,
-                null,
-                Instant.now().toString()
-        );
-    }
-}
diff --git a/spector-node/src/main/java/com/spectrayan/spector/node/api/dto/RagRequest.java b/spector-node/src/main/java/com/spectrayan/spector/node/api/dto/RagRequest.java
deleted file mode 100644
index 130bc09..0000000
--- a/spector-node/src/main/java/com/spectrayan/spector/node/api/dto/RagRequest.java
+++ /dev/null
@@ -1,61 +0,0 @@
-package com.spectrayan.spector.node.api.dto;
-
-import com.spectrayan.spector.commons.error.ErrorCode;
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-
-/**
- * Request DTO for the RAG endpoint ({@code POST /api/v1/rag}).
- *
- * <p>Accepts a query string plus optional retrieval parameters.
- * The query is embedded, searched, and assembled into a context
- * string within a token limit.</p>
- */
-public class RagRequest {
-
-    private static final int MAX_QUERY_LENGTH = 2000;
-
-    /** The query text (1–2000 characters, required). */
-    public String query;
-
-    /** Maximum number of chunks to retrieve (1–100, default 5). */
-    public Integer topK;
-
-    /** Maximum token limit for assembled context (1–8192, default 4096). */
-    public Integer tokenLimit;
-
-    /** Search mode: "vector" or "hybrid" (default "vector"). */
-    public String searchMode;
-
-    /**
-     * Validates the request.
-     *
-     * @throws ValidationException if validation fails
-     */
-    public void validate() {
-        if (query == null || query.isBlank()) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_INVALID, "query", "non-empty query is required");
-        }
-        if (query.length() > MAX_QUERY_LENGTH) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_INVALID, "query", "must not exceed " + MAX_QUERY_LENGTH + " characters");
-        }
-    }
-
-    /** Returns topK, clamped to [1, 100] with default 5. */
-    public int resolvedTopK() {
-        return clamp(topK != null ? topK : 5, 1, 100);
-    }
-
-    /** Returns token limit, clamped to [1, 8192] with default 4096. */
-    public int resolvedTokenLimit() {
-        return clamp(tokenLimit != null ? tokenLimit : 4096, 1, 8192);
-    }
-
-    /** Whether to use hybrid search mode. */
-    public boolean isHybrid() {
-        return "hybrid".equalsIgnoreCase(searchMode);
-    }
-
-    private static int clamp(int value, int min, int max) {
-        return Math.max(min, Math.min(max, value));
-    }
-}
diff --git a/spector-node/src/main/java/com/spectrayan/spector/node/api/dto/SearchRequest.java b/spector-node/src/main/java/com/spectrayan/spector/node/api/dto/SearchRequest.java
deleted file mode 100644
index bd2956f..0000000
--- a/spector-node/src/main/java/com/spectrayan/spector/node/api/dto/SearchRequest.java
+++ /dev/null
@@ -1,69 +0,0 @@
-package com.spectrayan.spector.node.api.dto;
-
-import com.spectrayan.spector.commons.error.ErrorCode;
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-import com.spectrayan.spector.query.SearchQuery;
-
-/**
- * Request DTO for the search endpoint ({@code POST /api/v1/search}).
- *
- * <p>Supports keyword, vector, and hybrid search modes. The mode is
- * auto-detected from the provided fields if not explicitly set.</p>
- */
-public class SearchRequest {
-
-    /** Query text for keyword/hybrid search. */
-    public String text;
-
-    /** Query vector for vector/hybrid search. */
-    public float[] vector;
-
-    /** Explicit search mode: "KEYWORD", "VECTOR", "HYBRID" (auto-detected if null). */
-    public String mode;
-
-    /** Number of results to return (default: 10). */
-    public int topK;
-
-    /**
-     * Resolves the search mode from explicit mode or field presence.
-     */
-    public SearchQuery.SearchMode resolvedMode() {
-        if (mode != null) {
-            try {
-                return SearchQuery.SearchMode.valueOf(mode.toUpperCase());
-            } catch (IllegalArgumentException ignored) {
-                // Invalid mode string — fall through to auto-detection
-                System.getLogger(SearchRequest.class.getName())
-                        .log(System.Logger.Level.WARNING, "Unknown search mode ''{0}'', auto-detecting", mode);
-            }
-        }
-        if (text != null && vector != null) return SearchQuery.SearchMode.HYBRID;
-        if (vector != null) return SearchQuery.SearchMode.VECTOR;
-        return SearchQuery.SearchMode.KEYWORD;
-    }
-
-    /**
-     * Converts this request to a {@link SearchQuery}.
-     *
-     * @return the search query
-     * @throws ValidationException if the request is invalid
-     */
-    public SearchQuery toQuery() {
-        int k = topK > 0 ? topK : 10;
-        return switch (resolvedMode()) {
-            case KEYWORD -> {
-                if (text == null || text.isBlank()) throw new SpectorValidationException(ErrorCode.ARGUMENT_INVALID, "text", "required for keyword search");
-                yield SearchQuery.keyword(text, k);
-            }
-            case VECTOR -> {
-                if (vector == null || vector.length == 0) throw new SpectorValidationException(ErrorCode.ARGUMENT_INVALID, "vector", "required for vector search");
-                yield SearchQuery.vector(vector, k);
-            }
-            case HYBRID -> {
-                if (text == null || text.isBlank()) throw new SpectorValidationException(ErrorCode.ARGUMENT_INVALID, "text", "required for hybrid search");
-                if (vector == null || vector.length == 0) throw new SpectorValidationException(ErrorCode.ARGUMENT_INVALID, "vector", "required for hybrid search");
-                yield SearchQuery.hybrid(text, vector, k);
-            }
-        };
-    }
-}
diff --git a/spector-node/src/main/java/com/spectrayan/spector/node/api/dto/SearchResponseDto.java b/spector-node/src/main/java/com/spectrayan/spector/node/api/dto/SearchResponseDto.java
deleted file mode 100644
index 54d54e1..0000000
--- a/spector-node/src/main/java/com/spectrayan/spector/node/api/dto/SearchResponseDto.java
+++ /dev/null
@@ -1,42 +0,0 @@
-package com.spectrayan.spector.node.api.dto;
-
-import java.util.Arrays;
-import java.util.List;
-import java.util.Map;
-
-import com.spectrayan.spector.query.SearchResponse;
-
-/**
- * Response DTO for the search endpoint ({@code POST /api/v1/search}).
- *
- * @param results     scored search results
- * @param totalHits   total number of matches
- * @param queryTimeMs query execution time in milliseconds
- * @param mode        search mode used (KEYWORD, VECTOR, HYBRID)
- */
-public record SearchResponseDto(
-        List<Map<String, Object>> results,
-        int totalHits,
-        long queryTimeMs,
-        String mode
-) {
-
-    /**
-     * Creates a DTO from the engine's search response.
-     */
-    public static SearchResponseDto from(SearchResponse response) {
-        var resultList = Arrays.stream(response.results())
-                .map(r -> Map.<String, Object>of(
-                        "id", r.id(),
-                        "score", r.score()
-                ))
-                .toList();
-
-        return new SearchResponseDto(
-                resultList,
-                response.totalHits(),
-                response.queryTimeMs(),
-                response.mode().name()
-        );
-    }
-}
diff --git a/spector-node/src/main/java/com/spectrayan/spector/node/api/v1/DocumentEndpoint.java b/spector-node/src/main/java/com/spectrayan/spector/node/api/v1/DocumentEndpoint.java
deleted file mode 100644
index bfe0dcd..0000000
--- a/spector-node/src/main/java/com/spectrayan/spector/node/api/v1/DocumentEndpoint.java
+++ /dev/null
@@ -1,44 +0,0 @@
-package com.spectrayan.spector.node.api.v1;
-
-import java.util.Map;
-
-import com.linecorp.armeria.common.HttpResponse;
-import com.linecorp.armeria.common.HttpStatus;
-import com.linecorp.armeria.server.annotation.Delete;
-import com.linecorp.armeria.server.annotation.ExceptionHandler;
-import com.linecorp.armeria.server.annotation.Param;
-
-import com.spectrayan.spector.node.api.ApiModule;
-import com.spectrayan.spector.node.exception.ApiExceptionHandler;
-import com.spectrayan.spector.commons.error.ErrorCode;
-import com.spectrayan.spector.commons.error.SpectorApiException;
-import com.spectrayan.spector.node.service.IngestService;
-
-/**
- * Document management API v1 endpoint.
- *
- * <ul>
- *   <li>{@code DELETE /documents/{id}} — delete a document by ID</li>
- * </ul>
- */
-@ExceptionHandler(ApiExceptionHandler.class)
-public class DocumentEndpoint implements ApiModule {
-
-    private final IngestService ingestService;
-
-    public DocumentEndpoint(IngestService ingestService) {
-        this.ingestService = ingestService;
-    }
-
-    @Override
-    public String pathPrefix() { return ""; }
-
-    @Delete("/documents/{id}")
-    public HttpResponse delete(@Param("id") String id) throws SpectorApiException {
-        boolean deleted = ingestService.delete(id);
-        if (!deleted) {
-            throw SpectorApiException.notFound(ErrorCode.API_NOT_FOUND, id);
-        }
-        return HttpResponse.ofJson(Map.of("id", id, "deleted", true));
-    }
-}
diff --git a/spector-node/src/main/java/com/spectrayan/spector/node/api/v1/EventStreamEndpoint.java b/spector-node/src/main/java/com/spectrayan/spector/node/api/v1/EventStreamEndpoint.java
deleted file mode 100644
index d4526c7..0000000
--- a/spector-node/src/main/java/com/spectrayan/spector/node/api/v1/EventStreamEndpoint.java
+++ /dev/null
@@ -1,118 +0,0 @@
-package com.spectrayan.spector.node.api.v1;
-
-import java.time.Duration;
-import java.util.Set;
-
-import com.fasterxml.jackson.annotation.JsonInclude;
-import com.fasterxml.jackson.databind.ObjectMapper;
-import com.fasterxml.jackson.databind.SerializationFeature;
-import com.linecorp.armeria.common.sse.ServerSentEvent;
-import com.linecorp.armeria.server.annotation.ExceptionHandler;
-import com.linecorp.armeria.server.annotation.Get;
-import com.linecorp.armeria.server.annotation.Param;
-import com.linecorp.armeria.server.annotation.ProducesEventStream;
-
-import com.spectrayan.spector.node.api.ApiModule;
-import com.spectrayan.spector.node.event.SpectorEvent;
-import com.spectrayan.spector.node.event.SpectorEventBus;
-import com.spectrayan.spector.node.exception.ApiExceptionHandler;
-
-import org.reactivestreams.Publisher;
-import reactor.core.publisher.Flux;
-import reactor.core.publisher.Sinks;
-
-/**
- * SSE event stream endpoint — clients subscribe to live Spector events.
- *
- * <h3>Usage</h3>
- * <pre>
- *   GET /api/v1/events                       — all events
- *   GET /api/v1/events?filter=search,document — only search + document events
- *   GET /api/v1/events?filter=cluster         — only cluster events
- * </pre>
- *
- * <h3>Event Format</h3>
- * <pre>
- *   event: search.completed
- *   data: {"nodeId":"node-1","resultCount":5,"latencyMs":12,"searchMode":"HYBRID"}
- *
- *   event: document.ingested
- *   data: {"nodeId":"node-1","documentId":"doc-1","autoEmbedded":false}
- * </pre>
- *
- * <h3>Filter Categories</h3>
- * <ul>
- *   <li>{@code node} — lifecycle events (started, stopping, health)</li>
- *   <li>{@code search} — search completed/failed events</li>
- *   <li>{@code document} — ingest/delete events</li>
- *   <li>{@code cluster} — node join/leave, shard rebalance, replica sync</li>
- *   <li>{@code mcp} — MCP client connect/disconnect, tool execution</li>
- *   <li>{@code engine} — index rebuild, embedding provider changes</li>
- * </ul>
- */
-@ExceptionHandler(ApiExceptionHandler.class)
-public class EventStreamEndpoint implements ApiModule {
-
-    private static final ObjectMapper MAPPER = new ObjectMapper()
-            .setSerializationInclusion(JsonInclude.Include.NON_NULL)
-            .disable(SerializationFeature.FAIL_ON_EMPTY_BEANS);
-
-    private final SpectorEventBus eventBus;
-
-    public EventStreamEndpoint(SpectorEventBus eventBus) {
-        this.eventBus = eventBus;
-    }
-
-    @Override
-    public String pathPrefix() { return ""; }
-
-    @Get("/events")
-    @ProducesEventStream
-    public Publisher<ServerSentEvent> eventStream(
-            @Param("filter") String filter) {
-
-        Set<String> categories = parseFilter(filter);
-
-        Sinks.Many<ServerSentEvent> sink = Sinks.many().multicast().onBackpressureBuffer();
-
-        SpectorEventBus.Subscription subscription = eventBus.subscribe(event -> {
-            if (!categories.isEmpty() && !matchesFilter(event, categories)) {
-                return;
-            }
-            try {
-                String data = MAPPER.writeValueAsString(event);
-                ServerSentEvent sse = ServerSentEvent.builder()
-                        .event(event.eventType())
-                        .data(data)
-                        .build();
-                sink.tryEmitNext(sse);
-            } catch (Exception e) {
-                // Skip events that fail serialization
-            }
-        });
-
-        // Send heartbeat every 30s to keep connection alive
-        Flux<ServerSentEvent> heartbeat = Flux.interval(Duration.ofSeconds(30))
-                .map(tick -> ServerSentEvent.builder()
-                        .event("heartbeat")
-                        .data("{}")
-                        .build());
-
-        return Flux.merge(sink.asFlux(), heartbeat)
-                .doOnCancel(subscription::cancel)
-                .doOnTerminate(subscription::cancel);
-    }
-
-    private static Set<String> parseFilter(String filter) {
-        if (filter == null || filter.isBlank()) return Set.of();
-        return Set.of(filter.toLowerCase().split(","));
-    }
-
-    private static boolean matchesFilter(SpectorEvent event, Set<String> categories) {
-        String eventType = event.eventType(); // e.g., "search.completed"
-        String category = eventType.contains(".")
-                ? eventType.substring(0, eventType.indexOf('.'))
-                : eventType;
-        return categories.contains(category);
-    }
-}
diff --git a/spector-node/src/main/java/com/spectrayan/spector/node/api/v1/IngestEndpoint.java b/spector-node/src/main/java/com/spectrayan/spector/node/api/v1/IngestEndpoint.java
deleted file mode 100644
index 73048f8..0000000
--- a/spector-node/src/main/java/com/spectrayan/spector/node/api/v1/IngestEndpoint.java
+++ /dev/null
@@ -1,58 +0,0 @@
-package com.spectrayan.spector.node.api.v1;
-
-import java.util.Map;
-
-import com.linecorp.armeria.common.HttpResponse;
-import com.linecorp.armeria.common.HttpStatus;
-import com.linecorp.armeria.server.annotation.ExceptionHandler;
-import com.linecorp.armeria.server.annotation.Post;
-
-import com.spectrayan.spector.node.api.ApiModule;
-import com.spectrayan.spector.node.api.dto.BulkIngestRequest;
-import com.spectrayan.spector.node.api.dto.IngestRequest;
-import com.spectrayan.spector.node.exception.ApiExceptionHandler;
-import com.spectrayan.spector.node.service.IngestService;
-import com.spectrayan.spector.commons.error.SpectorException;
-
-/**
- * Ingest API v1 endpoint.
- *
- * <ul>
- *   <li>{@code POST /ingest}      — ingest with pre-computed vector</li>
- *   <li>{@code POST /ingest/auto} — ingest with auto-embedding</li>
- *   <li>{@code POST /ingest/bulk} — batch ingest multiple documents</li>
- * </ul>
- */
-@ExceptionHandler(ApiExceptionHandler.class)
-public class IngestEndpoint implements ApiModule {
-
-    private final IngestService ingestService;
-
-    public IngestEndpoint(IngestService ingestService) {
-        this.ingestService = ingestService;
-    }
-
-    @Override
-    public String pathPrefix() { return ""; }
-
-    @Post("/ingest")
-    public HttpResponse ingest(IngestRequest request) throws com.spectrayan.spector.commons.error.SpectorException {
-        ingestService.ingest(request);
-        return HttpResponse.ofJson(HttpStatus.CREATED,
-                Map.of("id", request.id, "indexed", true));
-    }
-
-    @Post("/ingest/auto")
-    public HttpResponse autoIngest(IngestRequest request) throws com.spectrayan.spector.commons.error.SpectorException {
-        ingestService.autoIngest(request);
-        return HttpResponse.ofJson(HttpStatus.CREATED,
-                Map.of("id", request.id, "indexed", true, "autoEmbedded", true));
-    }
-
-    @Post("/ingest/bulk")
-    public HttpResponse bulkIngest(BulkIngestRequest request) throws com.spectrayan.spector.commons.error.SpectorException {
-        int[] result = ingestService.bulkIngest(request);
-        return HttpResponse.ofJson(HttpStatus.CREATED,
-                Map.of("total", result[0], "success", result[1], "failed", result[2]));
-    }
-}
diff --git a/spector-node/src/main/java/com/spectrayan/spector/node/api/v1/RagEndpoint.java b/spector-node/src/main/java/com/spectrayan/spector/node/api/v1/RagEndpoint.java
deleted file mode 100644
index 00d7123..0000000
--- a/spector-node/src/main/java/com/spectrayan/spector/node/api/v1/RagEndpoint.java
+++ /dev/null
@@ -1,36 +0,0 @@
-package com.spectrayan.spector.node.api.v1;
-
-import com.linecorp.armeria.common.HttpResponse;
-import com.linecorp.armeria.server.annotation.ExceptionHandler;
-import com.linecorp.armeria.server.annotation.Post;
-
-import com.spectrayan.spector.node.api.ApiModule;
-import com.spectrayan.spector.node.api.dto.RagRequest;
-import com.spectrayan.spector.node.exception.ApiExceptionHandler;
-import com.spectrayan.spector.node.service.RagService;
-import com.spectrayan.spector.commons.error.SpectorException;
-
-/**
- * RAG (Retrieval-Augmented Generation) API v1 endpoint.
- *
- * <ul>
- *   <li>{@code POST /rag} — retrieve context with attributions</li>
- * </ul>
- */
-@ExceptionHandler(ApiExceptionHandler.class)
-public class RagEndpoint implements ApiModule {
-
-    private final RagService ragService;
-
-    public RagEndpoint(RagService ragService) {
-        this.ragService = ragService;
-    }
-
-    @Override
-    public String pathPrefix() { return ""; }
-
-    @Post("/rag")
-    public HttpResponse rag(RagRequest request) throws com.spectrayan.spector.commons.error.SpectorException {
-        return HttpResponse.ofJson(ragService.retrieveContext(request));
-    }
-}
diff --git a/spector-node/src/main/java/com/spectrayan/spector/node/api/v1/SearchEndpoint.java b/spector-node/src/main/java/com/spectrayan/spector/node/api/v1/SearchEndpoint.java
deleted file mode 100644
index 846e5a2..0000000
--- a/spector-node/src/main/java/com/spectrayan/spector/node/api/v1/SearchEndpoint.java
+++ /dev/null
@@ -1,85 +0,0 @@
-package com.spectrayan.spector.node.api.v1;
-
-import java.util.Map;
-
-import com.fasterxml.jackson.databind.ObjectMapper;
-import com.linecorp.armeria.common.HttpResponse;
-import com.linecorp.armeria.common.sse.ServerSentEvent;
-import com.linecorp.armeria.server.annotation.ExceptionHandler;
-import com.linecorp.armeria.server.annotation.Get;
-import com.linecorp.armeria.server.annotation.Param;
-import com.linecorp.armeria.server.annotation.Post;
-import com.linecorp.armeria.server.annotation.ProducesEventStream;
-
-import com.spectrayan.spector.index.ScoredResult;
-import com.spectrayan.spector.node.api.ApiModule;
-import com.spectrayan.spector.node.api.dto.SearchRequest;
-import com.spectrayan.spector.node.api.dto.SearchResponseDto;
-import com.spectrayan.spector.node.exception.ApiExceptionHandler;
-import com.spectrayan.spector.node.service.SearchService;
-import com.spectrayan.spector.query.SearchQuery;
-import com.spectrayan.spector.query.SearchResponse;
-
-import org.reactivestreams.Publisher;
-import reactor.core.publisher.Flux;
-import com.spectrayan.spector.commons.error.SpectorException;
-
-/**
- * Search API v1 endpoint.
- *
- * <ul>
- *   <li>{@code POST /search} — keyword/vector/hybrid search</li>
- *   <li>{@code GET /search/stream} — streaming search via SSE</li>
- * </ul>
- */
-@ExceptionHandler(ApiExceptionHandler.class)
-public class SearchEndpoint implements ApiModule {
-
-    private static final ObjectMapper MAPPER = new ObjectMapper();
-
-    private final SearchService searchService;
-
-    public SearchEndpoint(SearchService searchService) {
-        this.searchService = searchService;
-    }
-
-    @Override
-    public String pathPrefix() { return ""; }
-
-    @Post("/search")
-    public HttpResponse search(SearchRequest request) throws com.spectrayan.spector.commons.error.SpectorException {
-        SearchResponseDto response = searchService.search(request);
-        return HttpResponse.ofJson(response);
-    }
-
-    @Get("/search/stream")
-    @ProducesEventStream
-    public Publisher<ServerSentEvent> streamSearch(
-            @Param("text") String text,
-            @Param("topK") int topK) {
-
-        int k = topK > 0 ? topK : 10;
-        SearchQuery query = SearchQuery.keyword(text, k);
-        SearchResponse response = searchService.searchRaw(query);
-        ScoredResult[] results = response.results();
-
-        return Flux.create(sink -> {
-            try {
-                for (int i = 0; i < results.length; i++) {
-                    ScoredResult r = results[i];
-                    String data = MAPPER.writeValueAsString(Map.of(
-                            "id", r.id(), "score", r.score(), "rank", i + 1));
-                    sink.next(ServerSentEvent.builder().event("result").data(data).build());
-                }
-                String doneData = MAPPER.writeValueAsString(Map.of(
-                        "totalHits", response.totalHits(),
-                        "queryTimeMs", response.queryTimeMs(),
-                        "mode", response.mode().name()));
-                sink.next(ServerSentEvent.builder().event("done").data(doneData).build());
-                sink.complete();
-            } catch (Exception e) {
-                sink.error(e);
-            }
-        });
-    }
-}
diff --git a/spector-node/src/main/java/com/spectrayan/spector/node/api/v1/StatusEndpoint.java b/spector-node/src/main/java/com/spectrayan/spector/node/api/v1/StatusEndpoint.java
deleted file mode 100644
index 3db5e9d..0000000
--- a/spector-node/src/main/java/com/spectrayan/spector/node/api/v1/StatusEndpoint.java
+++ /dev/null
@@ -1,77 +0,0 @@
-package com.spectrayan.spector.node.api.v1;
-
-import com.linecorp.armeria.common.HttpResponse;
-import com.linecorp.armeria.server.annotation.ExceptionHandler;
-import com.linecorp.armeria.server.annotation.Get;
-
-import com.spectrayan.spector.cluster.ClusterCoordinator;
-import com.spectrayan.spector.core.simd.SimdCapability;
-import com.spectrayan.spector.engine.SpectorEngine;
-import com.spectrayan.spector.node.NodeConfig;
-import com.spectrayan.spector.node.api.ApiModule;
-import com.spectrayan.spector.node.event.SpectorEventBus;
-import com.spectrayan.spector.node.exception.ApiExceptionHandler;
-
-import io.micrometer.prometheusmetrics.PrometheusMeterRegistry;
-
-import java.util.Map;
-
-/**
- * Status and metrics API v1 endpoint.
- *
- * <ul>
- *   <li>{@code GET /status}  — engine status, SIMD info, cluster mode</li>
- *   <li>{@code GET /metrics} — request metrics and resource usage</li>
- * </ul>
- */
-@ExceptionHandler(ApiExceptionHandler.class)
-public class StatusEndpoint implements ApiModule {
-
-    private final SpectorEngine engine;
-    private final NodeConfig nodeConfig;
-    private final SpectorEventBus eventBus;
-    private final ClusterCoordinator coordinator; // nullable
-    private final long startTime = System.currentTimeMillis();
-
-    public StatusEndpoint(SpectorEngine engine, NodeConfig nodeConfig,
-                          SpectorEventBus eventBus, ClusterCoordinator coordinator) {
-        this.engine = engine;
-        this.nodeConfig = nodeConfig;
-        this.eventBus = eventBus;
-        this.coordinator = coordinator;
-    }
-
-    @Override
-    public String pathPrefix() { return ""; }
-
-    @Get("/status")
-    public HttpResponse status() {
-        var status = new java.util.LinkedHashMap<String, Object>();
-        status.put("engine", "spector");
-        status.put("version", "0.1.0-SNAPSHOT");
-        status.put("nodeId", nodeConfig.nodeId());
-        status.put("mode", nodeConfig.mode().name());
-        status.put("documents", engine.documentCount());
-        status.put("dimensions", engine.config().dimensions());
-        status.put("similarity", engine.config().similarityFunction().name());
-        status.put("indexType", engine.config().indexType().name());
-        status.put("gpu", engine.isGpuActive() ? "active" : "inactive");
-        status.put("reranker", engine.isRerankerActive() ? engine.reranker().modelName() : "disabled");
-        status.put("embedding", engine.hasEmbeddingProvider() ? "configured" : "none");
-        status.put("simd", SimdCapability.report());
-        status.put("eventSubscribers", eventBus.subscriberCount());
-        return HttpResponse.ofJson(status);
-    }
-
-    @Get("/metrics")
-    public HttpResponse metrics() {
-        long uptimeMs = System.currentTimeMillis() - startTime;
-        return HttpResponse.ofJson(Map.of(
-                "uptimeMs", uptimeMs,
-                "documents", engine.documentCount(),
-                "gpu", engine.isGpuActive(),
-                "reranker", engine.isRerankerActive(),
-                "eventSubscribers", eventBus.subscriberCount()
-        ));
-    }
-}
diff --git a/spector-node/src/main/java/com/spectrayan/spector/node/event/SpectorBulkIngestCompletedEvent.java b/spector-node/src/main/java/com/spectrayan/spector/node/event/SpectorBulkIngestCompletedEvent.java
deleted file mode 100644
index bebfd57..0000000
--- a/spector-node/src/main/java/com/spectrayan/spector/node/event/SpectorBulkIngestCompletedEvent.java
+++ /dev/null
@@ -1,11 +0,0 @@
-package com.spectrayan.spector.node.event;
-
-import java.time.Instant;
-
-/** Fired when a bulk ingestion batch completes. */
-public record SpectorBulkIngestCompletedEvent(
-        String nodeId, Instant timestamp,
-        int totalDocuments, int successCount, int failedCount
-) implements SpectorEvent {
-    @Override public String eventType() { return "document.bulk_completed"; }
-}
diff --git a/spector-node/src/main/java/com/spectrayan/spector/node/event/SpectorDocumentDeletedEvent.java b/spector-node/src/main/java/com/spectrayan/spector/node/event/SpectorDocumentDeletedEvent.java
deleted file mode 100644
index e0cde1f..0000000
--- a/spector-node/src/main/java/com/spectrayan/spector/node/event/SpectorDocumentDeletedEvent.java
+++ /dev/null
@@ -1,11 +0,0 @@
-package com.spectrayan.spector.node.event;
-
-import java.time.Instant;
-
-/** Fired when a document is deleted from the index. */
-public record SpectorDocumentDeletedEvent(
-        String nodeId, Instant timestamp,
-        String documentId
-) implements SpectorEvent {
-    @Override public String eventType() { return "document.deleted"; }
-}
diff --git a/spector-node/src/main/java/com/spectrayan/spector/node/event/SpectorDocumentIngestedEvent.java b/spector-node/src/main/java/com/spectrayan/spector/node/event/SpectorDocumentIngestedEvent.java
deleted file mode 100644
index a78fd0c..0000000
--- a/spector-node/src/main/java/com/spectrayan/spector/node/event/SpectorDocumentIngestedEvent.java
+++ /dev/null
@@ -1,11 +0,0 @@
-package com.spectrayan.spector.node.event;
-
-import java.time.Instant;
-
-/** Fired when a document is successfully ingested into the index. */
-public record SpectorDocumentIngestedEvent(
-        String nodeId, Instant timestamp,
-        String documentId, boolean autoEmbedded
-) implements SpectorEvent {
-    @Override public String eventType() { return "document.ingested"; }
-}
diff --git a/spector-node/src/main/java/com/spectrayan/spector/node/event/SpectorEmbeddingProviderChangedEvent.java b/spector-node/src/main/java/com/spectrayan/spector/node/event/SpectorEmbeddingProviderChangedEvent.java
deleted file mode 100644
index 7c0f6af..0000000
--- a/spector-node/src/main/java/com/spectrayan/spector/node/event/SpectorEmbeddingProviderChangedEvent.java
+++ /dev/null
@@ -1,11 +0,0 @@
-package com.spectrayan.spector.node.event;
-
-import java.time.Instant;
-
-/** Fired when the embedding provider status changes (connected, disconnected, switched). */
-public record SpectorEmbeddingProviderChangedEvent(
-        String nodeId, Instant timestamp,
-        String providerName, boolean available
-) implements SpectorEvent {
-    @Override public String eventType() { return "engine.embedding_provider_changed"; }
-}
diff --git a/spector-node/src/main/java/com/spectrayan/spector/node/event/SpectorEvent.java b/spector-node/src/main/java/com/spectrayan/spector/node/event/SpectorEvent.java
deleted file mode 100644
index d36414b..0000000
--- a/spector-node/src/main/java/com/spectrayan/spector/node/event/SpectorEvent.java
+++ /dev/null
@@ -1,67 +0,0 @@
-package com.spectrayan.spector.node.event;
-
-import java.time.Instant;
-
-/**
- * Sealed base interface for all Spector node events.
- *
- * <p>Follows Spring/Redis naming convention: {@code Spector[Domain][Action]Event}.
- * Events are published via {@link SpectorEventBus} and consumed by subscribers
- * (SSE clients, metrics collectors, audit loggers, etc.).</p>
- *
- * <h3>Event Categories</h3>
- * <ul>
- *   <li><b>Lifecycle</b>: Node start, stop, health changes</li>
- *   <li><b>Search</b>: Query completed, query failed</li>
- *   <li><b>Document</b>: Ingested, deleted, bulk completed</li>
- *   <li><b>Cluster</b>: Node joined, left, shard rebalanced, replica synced</li>
- *   <li><b>MCP</b>: Client connected, disconnected, tool executed</li>
- *   <li><b>Engine</b>: Index rebuilt, embedding provider changed</li>
- * </ul>
- *
- * <h3>Usage</h3>
- * <pre>{@code
- *   eventBus.publish(new SpectorSearchCompletedEvent("node-1", 5, 12L, "HYBRID"));
- *   eventBus.subscribe(event -> {
- *       switch (event) {
- *           case SpectorSearchCompletedEvent e -> log.info("Search: {} results in {}ms", e.resultCount(), e.latencyMs());
- *           case SpectorDocumentIngestedEvent e -> log.info("Ingested: {}", e.documentId());
- *           default -> {}
- *       }
- *   });
- * }</pre>
- */
-public sealed interface SpectorEvent permits
-        // ── Lifecycle ──
-        SpectorNodeStartedEvent,
-        SpectorNodeStoppingEvent,
-        SpectorNodeHealthChangedEvent,
-        // ── Search ──
-        SpectorSearchCompletedEvent,
-        SpectorSearchFailedEvent,
-        // ── Document ──
-        SpectorDocumentIngestedEvent,
-        SpectorDocumentDeletedEvent,
-        SpectorBulkIngestCompletedEvent,
-        // ── Cluster ──
-        SpectorNodeJoinedEvent,
-        SpectorNodeLeftEvent,
-        SpectorShardRebalancedEvent,
-        SpectorReplicaSyncCompletedEvent,
-        // ── MCP ──
-        SpectorMcpClientConnectedEvent,
-        SpectorMcpClientDisconnectedEvent,
-        SpectorMcpToolExecutedEvent,
-        // ── Engine ──
-        SpectorIndexRebuiltEvent,
-        SpectorEmbeddingProviderChangedEvent {
-
-    /** Timestamp when the event occurred. */
-    Instant timestamp();
-
-    /** Node ID that originated the event. */
-    String nodeId();
-
-    /** Event type name (e.g., "search.completed"). Used in SSE {@code event:} field. */
-    String eventType();
-}
diff --git a/spector-node/src/main/java/com/spectrayan/spector/node/event/SpectorEventBus.java b/spector-node/src/main/java/com/spectrayan/spector/node/event/SpectorEventBus.java
deleted file mode 100644
index 73401c8..0000000
--- a/spector-node/src/main/java/com/spectrayan/spector/node/event/SpectorEventBus.java
+++ /dev/null
@@ -1,112 +0,0 @@
-package com.spectrayan.spector.node.event;
-
-import java.util.List;
-import java.util.concurrent.CopyOnWriteArrayList;
-import java.util.function.Consumer;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-/**
- * Thread-safe publish/subscribe event bus for Spector node events.
- *
- * <p>Implements the Observer pattern. Any component can publish events,
- * and any number of subscribers can listen. Subscribers receive events
- * synchronously on the publisher's thread — keep handlers fast.</p>
- *
- * <h3>Usage</h3>
- * <pre>{@code
- *   SpectorEventBus eventBus = new SpectorEventBus();
- *
- *   // Subscribe
- *   SpectorEventBus.Subscription sub = eventBus.subscribe(event -> {
- *       if (event instanceof SpectorSearchCompletedEvent e) {
- *           log.info("Search completed: {} results", e.resultCount());
- *       }
- *   });
- *
- *   // Publish
- *   eventBus.publish(new SpectorSearchCompletedEvent("node-1", Instant.now(), 5, 12L, "HYBRID"));
- *
- *   // Unsubscribe
- *   sub.cancel();
- * }</pre>
- *
- * <h3>Thread Safety</h3>
- * <p>Uses {@link CopyOnWriteArrayList} for lock-free reads during event
- * dispatch. Suitable for high-throughput event publishing with infrequent
- * subscribe/unsubscribe operations.</p>
- */
-public class SpectorEventBus {
-
-    private static final Logger log = LoggerFactory.getLogger(SpectorEventBus.class);
-
-    private final List<Consumer<SpectorEvent>> subscribers = new CopyOnWriteArrayList<>();
-
-    /**
-     * Publishes an event to all subscribers.
-     *
-     * <p>Exceptions thrown by individual subscribers are caught and logged
-     * to prevent one failing subscriber from blocking others.</p>
-     *
-     * @param event the event to publish
-     */
-    public void publish(SpectorEvent event) {
-        for (Consumer<SpectorEvent> subscriber : subscribers) {
-            try {
-                subscriber.accept(event);
-            } catch (Exception e) {
-                log.warn("Event subscriber threw exception for {}: {}",
-                        event.eventType(), e.getMessage(), e);
-            }
-        }
-    }
-
-    /**
-     * Subscribes to all events.
-     *
-     * @param subscriber the event handler
-     * @return a subscription handle that can be cancelled
-     */
-    public Subscription subscribe(Consumer<SpectorEvent> subscriber) {
-        subscribers.add(subscriber);
-        log.debug("Event subscriber added (total: {})", subscribers.size());
-        return () -> {
-            subscribers.remove(subscriber);
-            log.debug("Event subscriber removed (total: {})", subscribers.size());
-        };
-    }
-
-    /**
-     * Subscribes to events of a specific type only.
-     *
-     * @param eventType  the event class to filter for
-     * @param subscriber the typed event handler
-     * @param <T>        the event type
-     * @return a subscription handle that can be cancelled
-     */
-    @SuppressWarnings("unchecked")
-    public <T extends SpectorEvent> Subscription subscribe(Class<T> eventType, Consumer<T> subscriber) {
-        Consumer<SpectorEvent> wrapped = event -> {
-            if (eventType.isInstance(event)) {
-                subscriber.accept((T) event);
-            }
-        };
-        subscribers.add(wrapped);
-        return () -> subscribers.remove(wrapped);
-    }
-
-    /** Returns the current subscriber count (for monitoring). */
-    public int subscriberCount() {
-        return subscribers.size();
-    }
-
-    /**
-     * Handle for cancelling an event subscription.
-     */
-    @FunctionalInterface
-    public interface Subscription {
-        /** Cancels the subscription — the subscriber will no longer receive events. */
-        void cancel();
-    }
-}
diff --git a/spector-node/src/main/java/com/spectrayan/spector/node/event/SpectorIndexRebuiltEvent.java b/spector-node/src/main/java/com/spectrayan/spector/node/event/SpectorIndexRebuiltEvent.java
deleted file mode 100644
index 3fdc3b8..0000000
--- a/spector-node/src/main/java/com/spectrayan/spector/node/event/SpectorIndexRebuiltEvent.java
+++ /dev/null
@@ -1,11 +0,0 @@
-package com.spectrayan.spector.node.event;
-
-import java.time.Instant;
-
-/** Fired when the search index is rebuilt or optimized (e.g., HNSW re-indexing). */
-public record SpectorIndexRebuiltEvent(
-        String nodeId, Instant timestamp,
-        String indexType, long documentCount, long rebuildTimeMs
-) implements SpectorEvent {
-    @Override public String eventType() { return "engine.index_rebuilt"; }
-}
diff --git a/spector-node/src/main/java/com/spectrayan/spector/node/event/SpectorMcpClientConnectedEvent.java b/spector-node/src/main/java/com/spectrayan/spector/node/event/SpectorMcpClientConnectedEvent.java
deleted file mode 100644
index 0227034..0000000
--- a/spector-node/src/main/java/com/spectrayan/spector/node/event/SpectorMcpClientConnectedEvent.java
+++ /dev/null
@@ -1,11 +0,0 @@
-package com.spectrayan.spector.node.event;
-
-import java.time.Instant;
-
-/** Fired when an MCP client connects via SSE transport. */
-public record SpectorMcpClientConnectedEvent(
-        String nodeId, Instant timestamp,
-        String clientId, String remoteAddress
-) implements SpectorEvent {
-    @Override public String eventType() { return "mcp.client_connected"; }
-}
diff --git a/spector-node/src/main/java/com/spectrayan/spector/node/event/SpectorMcpClientDisconnectedEvent.java b/spector-node/src/main/java/com/spectrayan/spector/node/event/SpectorMcpClientDisconnectedEvent.java
deleted file mode 100644
index c4c4620..0000000
--- a/spector-node/src/main/java/com/spectrayan/spector/node/event/SpectorMcpClientDisconnectedEvent.java
+++ /dev/null
@@ -1,11 +0,0 @@
-package com.spectrayan.spector.node.event;
-
-import java.time.Instant;
-
-/** Fired when an MCP client disconnects. */
-public record SpectorMcpClientDisconnectedEvent(
-        String nodeId, Instant timestamp,
-        String clientId
-) implements SpectorEvent {
-    @Override public String eventType() { return "mcp.client_disconnected"; }
-}
diff --git a/spector-node/src/main/java/com/spectrayan/spector/node/event/SpectorMcpToolExecutedEvent.java b/spector-node/src/main/java/com/spectrayan/spector/node/event/SpectorMcpToolExecutedEvent.java
deleted file mode 100644
index bf07376..0000000
--- a/spector-node/src/main/java/com/spectrayan/spector/node/event/SpectorMcpToolExecutedEvent.java
+++ /dev/null
@@ -1,11 +0,0 @@
-package com.spectrayan.spector.node.event;
-
-import java.time.Instant;
-
-/** Fired when an MCP tool is invoked by a connected client. */
-public record SpectorMcpToolExecutedEvent(
-        String nodeId, Instant timestamp,
-        String clientId, String toolName, long executionMs
-) implements SpectorEvent {
-    @Override public String eventType() { return "mcp.tool_executed"; }
-}
diff --git a/spector-node/src/main/java/com/spectrayan/spector/node/event/SpectorNodeHealthChangedEvent.java b/spector-node/src/main/java/com/spectrayan/spector/node/event/SpectorNodeHealthChangedEvent.java
deleted file mode 100644
index c1fa206..0000000
--- a/spector-node/src/main/java/com/spectrayan/spector/node/event/SpectorNodeHealthChangedEvent.java
+++ /dev/null
@@ -1,11 +0,0 @@
-package com.spectrayan.spector.node.event;
-
-import java.time.Instant;
-
-/** Fired when the node's health status changes (healthy → unhealthy or vice versa). */
-public record SpectorNodeHealthChangedEvent(
-        String nodeId, Instant timestamp,
-        boolean healthy, String reason
-) implements SpectorEvent {
-    @Override public String eventType() { return "node.health_changed"; }
-}
diff --git a/spector-node/src/main/java/com/spectrayan/spector/node/event/SpectorNodeJoinedEvent.java b/spector-node/src/main/java/com/spectrayan/spector/node/event/SpectorNodeJoinedEvent.java
deleted file mode 100644
index d2d3f6b..0000000
--- a/spector-node/src/main/java/com/spectrayan/spector/node/event/SpectorNodeJoinedEvent.java
+++ /dev/null
@@ -1,11 +0,0 @@
-package com.spectrayan.spector.node.event;
-
-import java.time.Instant;
-
-/** Fired when a peer node joins the cluster. */
-public record SpectorNodeJoinedEvent(
-        String nodeId, Instant timestamp,
-        String joinedNodeId, String endpoint
-) implements SpectorEvent {
-    @Override public String eventType() { return "cluster.node_joined"; }
-}
diff --git a/spector-node/src/main/java/com/spectrayan/spector/node/event/SpectorNodeLeftEvent.java b/spector-node/src/main/java/com/spectrayan/spector/node/event/SpectorNodeLeftEvent.java
deleted file mode 100644
index 78512d5..0000000
--- a/spector-node/src/main/java/com/spectrayan/spector/node/event/SpectorNodeLeftEvent.java
+++ /dev/null
@@ -1,11 +0,0 @@
-package com.spectrayan.spector.node.event;
-
-import java.time.Instant;
-
-/** Fired when a peer node leaves the cluster (heartbeat failure or graceful shutdown). */
-public record SpectorNodeLeftEvent(
-        String nodeId, Instant timestamp,
-        String leftNodeId, String reason
-) implements SpectorEvent {
-    @Override public String eventType() { return "cluster.node_left"; }
-}
diff --git a/spector-node/src/main/java/com/spectrayan/spector/node/event/SpectorNodeStartedEvent.java b/spector-node/src/main/java/com/spectrayan/spector/node/event/SpectorNodeStartedEvent.java
deleted file mode 100644
index c90babf..0000000
--- a/spector-node/src/main/java/com/spectrayan/spector/node/event/SpectorNodeStartedEvent.java
+++ /dev/null
@@ -1,11 +0,0 @@
-package com.spectrayan.spector.node.event;
-
-import java.time.Instant;
-
-/** Fired when the node has started and is ready to accept requests. */
-public record SpectorNodeStartedEvent(
-        String nodeId, Instant timestamp,
-        int port, String mode
-) implements SpectorEvent {
-    @Override public String eventType() { return "node.started"; }
-}
diff --git a/spector-node/src/main/java/com/spectrayan/spector/node/event/SpectorNodeStoppingEvent.java b/spector-node/src/main/java/com/spectrayan/spector/node/event/SpectorNodeStoppingEvent.java
deleted file mode 100644
index 2237f45..0000000
--- a/spector-node/src/main/java/com/spectrayan/spector/node/event/SpectorNodeStoppingEvent.java
+++ /dev/null
@@ -1,11 +0,0 @@
-package com.spectrayan.spector.node.event;
-
-import java.time.Instant;
-
-/** Fired when the node is shutting down gracefully. */
-public record SpectorNodeStoppingEvent(
-        String nodeId, Instant timestamp,
-        String reason
-) implements SpectorEvent {
-    @Override public String eventType() { return "node.stopping"; }
-}
diff --git a/spector-node/src/main/java/com/spectrayan/spector/node/event/SpectorReplicaSyncCompletedEvent.java b/spector-node/src/main/java/com/spectrayan/spector/node/event/SpectorReplicaSyncCompletedEvent.java
deleted file mode 100644
index 63fcd83..0000000
--- a/spector-node/src/main/java/com/spectrayan/spector/node/event/SpectorReplicaSyncCompletedEvent.java
+++ /dev/null
@@ -1,11 +0,0 @@
-package com.spectrayan.spector.node.event;
-
-import java.time.Instant;
-
-/** Fired when a shard replica finishes synchronization with its primary. */
-public record SpectorReplicaSyncCompletedEvent(
-        String nodeId, Instant timestamp,
-        String shardId, long documentsSynced
-) implements SpectorEvent {
-    @Override public String eventType() { return "cluster.replica_synced"; }
-}
diff --git a/spector-node/src/main/java/com/spectrayan/spector/node/event/SpectorSearchCompletedEvent.java b/spector-node/src/main/java/com/spectrayan/spector/node/event/SpectorSearchCompletedEvent.java
deleted file mode 100644
index c13364e..0000000
--- a/spector-node/src/main/java/com/spectrayan/spector/node/event/SpectorSearchCompletedEvent.java
+++ /dev/null
@@ -1,11 +0,0 @@
-package com.spectrayan.spector.node.event;
-
-import java.time.Instant;
-
-/** Fired when a search query completes successfully. */
-public record SpectorSearchCompletedEvent(
-        String nodeId, Instant timestamp,
-        int resultCount, long latencyMs, String searchMode
-) implements SpectorEvent {
-    @Override public String eventType() { return "search.completed"; }
-}
diff --git a/spector-node/src/main/java/com/spectrayan/spector/node/event/SpectorSearchFailedEvent.java b/spector-node/src/main/java/com/spectrayan/spector/node/event/SpectorSearchFailedEvent.java
deleted file mode 100644
index 46f29d9..0000000
--- a/spector-node/src/main/java/com/spectrayan/spector/node/event/SpectorSearchFailedEvent.java
+++ /dev/null
@@ -1,11 +0,0 @@
-package com.spectrayan.spector.node.event;
-
-import java.time.Instant;
-
-/** Fired when a search query fails with an error. */
-public record SpectorSearchFailedEvent(
-        String nodeId, Instant timestamp,
-        String searchMode, String errorMessage
-) implements SpectorEvent {
-    @Override public String eventType() { return "search.failed"; }
-}
diff --git a/spector-node/src/main/java/com/spectrayan/spector/node/event/SpectorShardRebalancedEvent.java b/spector-node/src/main/java/com/spectrayan/spector/node/event/SpectorShardRebalancedEvent.java
deleted file mode 100644
index 9cdfad1..0000000
--- a/spector-node/src/main/java/com/spectrayan/spector/node/event/SpectorShardRebalancedEvent.java
+++ /dev/null
@@ -1,11 +0,0 @@
-package com.spectrayan.spector.node.event;
-
-import java.time.Instant;
-
-/** Fired when shard assignments are rebalanced across the cluster. */
-public record SpectorShardRebalancedEvent(
-        String nodeId, Instant timestamp,
-        int totalShards, int localShards
-) implements SpectorEvent {
-    @Override public String eventType() { return "cluster.shard_rebalanced"; }
-}
diff --git a/spector-node/src/main/java/com/spectrayan/spector/node/exception/ApiExceptionHandler.java b/spector-node/src/main/java/com/spectrayan/spector/node/exception/ApiExceptionHandler.java
deleted file mode 100644
index d3bc50b..0000000
--- a/spector-node/src/main/java/com/spectrayan/spector/node/exception/ApiExceptionHandler.java
+++ /dev/null
@@ -1,99 +0,0 @@
-package com.spectrayan.spector.node.exception;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import com.linecorp.armeria.common.HttpRequest;
-import com.linecorp.armeria.common.HttpResponse;
-import com.linecorp.armeria.common.HttpStatus;
-import com.linecorp.armeria.common.MediaType;
-import com.linecorp.armeria.server.ServiceRequestContext;
-import com.linecorp.armeria.server.annotation.ExceptionHandlerFunction;
-
-import com.spectrayan.spector.commons.error.SpectorApiException;
-import com.spectrayan.spector.commons.error.SpectorException;
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-import com.spectrayan.spector.node.api.dto.ProblemDetail;
-
-/**
- * Centralized Armeria exception handler for all Spector REST endpoints.
- *
- * <p>Produces RFC 9457 {@code application/problem+json} responses.</p>
- *
- * <h3>Exception Mapping</h3>
- * <ul>
- *   <li>{@link SpectorApiException} → HTTP status from exception</li>
- *   <li>{@link SpectorValidationException} → 400 Bad Request</li>
- *   <li>{@link SpectorException} → 500 Internal Server Error</li>
- *   <li>{@link IllegalArgumentException} → 400 Bad Request (fallback)</li>
- *   <li>All others → 500 Internal Server Error</li>
- * </ul>
- *
- * <h3>Logging Policy</h3>
- * <ul>
- *   <li>4xx errors → WARN level, error code + message only (no stack trace)</li>
- *   <li>5xx errors → ERROR level, error code + message + full stack trace</li>
- * </ul>
- *
- * @see <a href="https://www.rfc-editor.org/rfc/rfc9457">RFC 9457</a>
- */
-public class ApiExceptionHandler implements ExceptionHandlerFunction {
-
-    private static final Logger log = LoggerFactory.getLogger(ApiExceptionHandler.class);
-
-    /** RFC 9457 content type. */
-    private static final MediaType PROBLEM_JSON = MediaType.parse("application/problem+json");
-
-    @Override
-    public HttpResponse handleException(ServiceRequestContext ctx, HttpRequest req, Throwable cause) {
-        // ── SpectorApiException — carries its own HTTP status ──
-        if (cause instanceof SpectorApiException e) {
-            int status = e.httpStatus();
-            logByStatus(status, e.codeId(), e.getMessage(), e);
-            return problemResponse(status, ProblemDetail.fromException(e, status, ctx.path()));
-        }
-
-        // ── SpectorValidationException → 400 ──
-        if (cause instanceof SpectorValidationException e) {
-            log.warn("{}: {}", e.codeId(), e.getMessage());
-            return problemResponse(400, ProblemDetail.fromException(e, 400, ctx.path()));
-        }
-
-        // ── Any other SpectorException → 500 ──
-        if (cause instanceof SpectorException e) {
-            log.error("{}: {}", e.codeId(), e.getMessage(), e);
-            return problemResponse(500, ProblemDetail.fromException(e, 500, ctx.path()));
-        }
-
-        // ── IllegalArgumentException → 400 (framework/library fallback) ──
-        if (cause instanceof IllegalArgumentException e) {
-            log.warn("Bad request: {}", e.getMessage());
-            return problemResponse(400,
-                    ProblemDetail.of(400, "Bad Request", e.getMessage(), ctx.path()));
-        }
-
-        // ── Unexpected — 500, full stack trace ──
-        log.error("Unexpected error on {}", ctx.path(), cause);
-        return problemResponse(500,
-                ProblemDetail.of(500, "Internal Server Error",
-                        "An unexpected error occurred", ctx.path()));
-    }
-
-    /**
-     * Builds an {@code application/problem+json} HTTP response.
-     */
-    private static HttpResponse problemResponse(int status, ProblemDetail problem) {
-        return HttpResponse.ofJson(HttpStatus.valueOf(status), PROBLEM_JSON, problem);
-    }
-
-    /**
-     * Logs at WARN for 4xx, ERROR (with stack trace) for 5xx.
-     */
-    private static void logByStatus(int status, String codeId, String message, Throwable cause) {
-        if (status >= 500) {
-            log.error("{}: {}", codeId, message, cause);
-        } else {
-            log.warn("{}: {}", codeId, message);
-        }
-    }
-}
diff --git a/spector-node/src/main/java/com/spectrayan/spector/node/service/IngestService.java b/spector-node/src/main/java/com/spectrayan/spector/node/service/IngestService.java
deleted file mode 100644
index 2674026..0000000
--- a/spector-node/src/main/java/com/spectrayan/spector/node/service/IngestService.java
+++ /dev/null
@@ -1,141 +0,0 @@
-package com.spectrayan.spector.node.service;
-
-import java.time.Instant;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import com.spectrayan.spector.cluster.ClusterCoordinator;
-import com.spectrayan.spector.engine.SpectorEngine;
-import com.spectrayan.spector.node.api.dto.BulkIngestRequest;
-import com.spectrayan.spector.node.api.dto.IngestRequest;
-import com.spectrayan.spector.node.event.SpectorBulkIngestCompletedEvent;
-import com.spectrayan.spector.node.event.SpectorDocumentDeletedEvent;
-import com.spectrayan.spector.node.event.SpectorDocumentIngestedEvent;
-import com.spectrayan.spector.node.event.SpectorEventBus;
-import com.spectrayan.spector.commons.error.ErrorCode;
-import com.spectrayan.spector.commons.error.SpectorException;
-
-/**
- * Ingest service facade — encapsulates local vs cluster routing for document ingestion.
- *
- * <p>Handles three ingestion modes:</p>
- * <ul>
- *   <li><b>Manual</b> — client provides pre-computed vector</li>
- *   <li><b>Auto-embed</b> — engine embeds the content automatically</li>
- *   <li><b>Bulk</b> — batch of documents, mixed modes</li>
- * </ul>
- *
- * <p>Publishes {@link SpectorDocumentIngestedEvent} for each successful ingestion
- * and {@link SpectorBulkIngestCompletedEvent} for bulk operations.</p>
- */
-public class IngestService {
-
-    private static final Logger log = LoggerFactory.getLogger(IngestService.class);
-
-    private final SpectorEngine engine;
-    private final ClusterCoordinator coordinator; // nullable
-    private final SpectorEventBus eventBus;
-    private final String nodeId;
-
-    public IngestService(SpectorEngine engine, ClusterCoordinator coordinator,
-                         SpectorEventBus eventBus, String nodeId) {
-        this.engine = engine;
-        this.coordinator = coordinator;
-        this.eventBus = eventBus;
-        this.nodeId = nodeId;
-    }
-
-    /**
-     * Ingests a document with a pre-computed vector.
-     */
-    public void ingest(IngestRequest request) throws com.spectrayan.spector.commons.error.SpectorException {
-        request.validateForIngest(engine.config().dimensions());
-
-        if (coordinator != null) {
-            coordinator.ingest(request.id, request.content, request.vector);
-        } else {
-            engine.ingest(request.id, request.titleOrEmpty(), request.content, request.vector);
-        }
-
-        eventBus.publish(new SpectorDocumentIngestedEvent(
-                nodeId, Instant.now(), request.id, false));
-    }
-
-    /**
-     * Ingests a document with automatic embedding.
-     */
-    public void autoIngest(IngestRequest request) throws com.spectrayan.spector.commons.error.SpectorException {
-        request.validateForAutoIngest();
-
-        if (!engine.hasEmbeddingProvider()) {
-            throw com.spectrayan.spector.commons.error.SpectorApiException.conflict(
-                    com.spectrayan.spector.commons.error.ErrorCode.EMBEDDING_PROVIDER_MISSING);
-        }
-
-        if (request.title != null && !request.title.isEmpty()) {
-            engine.ingest(request.id, request.title, request.content);
-        } else {
-            engine.ingest(request.id, request.content);
-        }
-
-        eventBus.publish(new SpectorDocumentIngestedEvent(
-                nodeId, Instant.now(), request.id, true));
-    }
-
-    /**
-     * Bulk ingests multiple documents.
-     *
-     * @return array of [total, success, failed]
-     */
-    public int[] bulkIngest(BulkIngestRequest request) throws com.spectrayan.spector.commons.error.SpectorException {
-        request.validate();
-
-        int success = 0;
-        int failed = 0;
-
-        for (var doc : request.documents) {
-            try {
-                if (doc.id == null || doc.content == null) {
-                    failed++;
-                    continue;
-                }
-                if (doc.vector != null && doc.vector.length > 0) {
-                    if (coordinator != null) {
-                        coordinator.ingest(doc.id, doc.content, doc.vector);
-                    } else {
-                        engine.ingest(doc.id, doc.titleOrEmpty(), doc.content, doc.vector);
-                    }
-                } else if (engine.hasEmbeddingProvider()) {
-                    engine.ingest(doc.id, doc.content);
-                } else {
-                    failed++;
-                    continue;
-                }
-                success++;
-            } catch (Exception e) {
-                failed++;
-                log.warn("Bulk ingest failed for doc '{}': {}", doc.id, e.getMessage());
-            }
-        }
-
-        eventBus.publish(new SpectorBulkIngestCompletedEvent(
-                nodeId, Instant.now(), request.documents.size(), success, failed));
-
-        return new int[]{request.documents.size(), success, failed};
-    }
-
-    /**
-     * Deletes a document by ID.
-     *
-     * @return true if the document was found and deleted
-     */
-    public boolean delete(String id) {
-        boolean deleted = engine.delete(id);
-        if (deleted) {
-            eventBus.publish(new SpectorDocumentDeletedEvent(
-                    nodeId, Instant.now(), id));
-        }
-        return deleted;
-    }
-}
diff --git a/spector-node/src/main/java/com/spectrayan/spector/node/service/RagService.java b/spector-node/src/main/java/com/spectrayan/spector/node/service/RagService.java
deleted file mode 100644
index f5200ff..0000000
--- a/spector-node/src/main/java/com/spectrayan/spector/node/service/RagService.java
+++ /dev/null
@@ -1,119 +0,0 @@
-package com.spectrayan.spector.node.service;
-
-import com.spectrayan.spector.commons.error.SpectorEmbeddingException;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-import java.util.Map;
-import java.util.Objects;
-
-import com.spectrayan.spector.commons.TextChunk;
-import com.spectrayan.spector.commons.WordTokenizer;
-import com.spectrayan.spector.engine.SpectorEngine;
-import com.spectrayan.spector.node.api.dto.RagRequest;
-import com.spectrayan.spector.commons.error.ErrorCode;
-import com.spectrayan.spector.commons.error.SpectorApiException;
-import com.spectrayan.spector.query.SearchQuery;
-import com.spectrayan.spector.query.SearchResponse;
-import com.spectrayan.spector.rag.ContextBuilder;
-import com.spectrayan.spector.rag.ContextResult;
-import com.spectrayan.spector.rag.ScoredChunk;
-import com.spectrayan.spector.commons.error.SpectorException;
-
-/**
- * RAG (Retrieval-Augmented Generation) service facade.
- *
- * <p>Wires together the full RAG pipeline:</p>
- * <ol>
- *   <li>Validate and parse request</li>
- *   <li>Embed the query text</li>
- *   <li>Search for relevant chunks (vector or hybrid)</li>
- *   <li>Assemble context within token limits</li>
- *   <li>Return context + attributions</li>
- * </ol>
- */
-public class RagService {
-
-    private final SpectorEngine engine;
-    private final ContextBuilder contextBuilder;
-
-    public RagService(SpectorEngine engine) {
-        this.engine = engine;
-        this.contextBuilder = new ContextBuilder();
-    }
-
-    /**
-     * Executes the RAG pipeline.
-     *
-     * @param request the RAG request
-     * @return a map suitable for JSON serialization
-     */
-    public Map<String, Object> retrieveContext(RagRequest request) throws com.spectrayan.spector.commons.error.SpectorException {
-        request.validate();
-
-        if (!engine.hasEmbeddingProvider()) {
-            throw SpectorApiException.serviceUnavailable(ErrorCode.EMBEDDING_UNAVAILABLE, "No embedding provider configured");
-        }
-
-        // 1. Embed query
-        float[] queryVector;
-        try {
-            queryVector = engine.embeddingProvider().embed(request.query).vector();
-        } catch (SpectorEmbeddingException e) {
-            throw SpectorApiException.serviceUnavailable(ErrorCode.EMBEDDING_UNAVAILABLE, e.getMessage());
-        }
-
-        // 2. Search
-        int topK = request.resolvedTopK();
-        SearchQuery query = request.isHybrid()
-                ? SearchQuery.hybrid(request.query, queryVector, topK)
-                : SearchQuery.vector(queryVector, topK);
-
-        SearchResponse searchResponse = engine.search(query);
-
-        if (searchResponse.results() == null || searchResponse.results().length == 0) {
-            return emptyContext();
-        }
-
-        // 3. Build scored chunks
-        List<ScoredChunk> scoredChunks = Arrays.stream(searchResponse.results())
-                .map(r -> {
-                    var doc = engine.documentStore().get(r.id());
-                    if (doc == null || doc.content() == null || doc.content().isBlank()) return null;
-                    int tokens = WordTokenizer.countTokens(doc.content());
-                    var chunk = new TextChunk(doc.content(), tokens, 0, doc.content().length(), r.id());
-                    return new ScoredChunk(chunk, r.score());
-                })
-                .filter(Objects::nonNull)
-                .toList();
-
-        // 4. Assemble context
-        ContextResult contextResult = contextBuilder.build(
-                new ArrayList<>(scoredChunks), request.resolvedTokenLimit());
-
-        if (contextResult.isEmpty()) {
-            return emptyContext();
-        }
-
-        // 5. Build response
-        var attributions = contextResult.attributions().stream()
-                .map(a -> Map.<String, Object>of(
-                        "documentId", a.documentId(),
-                        "chunkOffset", a.chunkOffset()))
-                .toList();
-
-        return Map.of(
-                "context", contextResult.contextText(),
-                "attributions", attributions
-        );
-    }
-
-    private static Map<String, Object> emptyContext() {
-        return Map.of(
-                "context", "",
-                "attributions", List.of(),
-                "message", "No matching documents were found"
-        );
-    }
-}
diff --git a/spector-node/src/main/java/com/spectrayan/spector/node/service/SearchService.java b/spector-node/src/main/java/com/spectrayan/spector/node/service/SearchService.java
deleted file mode 100644
index b9311b6..0000000
--- a/spector-node/src/main/java/com/spectrayan/spector/node/service/SearchService.java
+++ /dev/null
@@ -1,103 +0,0 @@
-package com.spectrayan.spector.node.service;
-
-import java.time.Instant;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import com.spectrayan.spector.cluster.ClusterCoordinator;
-import com.spectrayan.spector.engine.SpectorEngine;
-import com.spectrayan.spector.index.ScoredResult;
-import com.spectrayan.spector.node.api.dto.SearchRequest;
-import com.spectrayan.spector.node.api.dto.SearchResponseDto;
-import com.spectrayan.spector.node.event.SpectorEventBus;
-import com.spectrayan.spector.node.event.SpectorSearchCompletedEvent;
-import com.spectrayan.spector.node.event.SpectorSearchFailedEvent;
-import com.spectrayan.spector.commons.error.ErrorCode;
-import com.spectrayan.spector.commons.error.SpectorApiException;
-import com.spectrayan.spector.query.SearchQuery;
-import com.spectrayan.spector.query.SearchResponse;
-import com.spectrayan.spector.commons.error.SpectorException;
-
-/**
- * Search service facade — encapsulates local vs cluster routing.
- *
- * <p>Applies the Strategy pattern internally: in standalone mode, queries
- * go directly to the local engine. In clustered mode, queries are fanned
- * out through the {@link ClusterCoordinator}.</p>
- *
- * <p>All search operations publish events to the {@link SpectorEventBus}
- * for subscribers (SSE clients, metrics, audit logging).</p>
- */
-public class SearchService {
-
-    private static final Logger log = LoggerFactory.getLogger(SearchService.class);
-
-    private final SpectorEngine engine;
-    private final ClusterCoordinator coordinator; // nullable — null in standalone
-    private final SpectorEventBus eventBus;
-    private final String nodeId;
-
-    public SearchService(SpectorEngine engine, ClusterCoordinator coordinator,
-                         SpectorEventBus eventBus, String nodeId) {
-        this.engine = engine;
-        this.coordinator = coordinator;
-        this.eventBus = eventBus;
-        this.nodeId = nodeId;
-    }
-
-    /**
-     * Executes a search query, routing to local engine or cluster coordinator.
-     *
-     * @param request the search request DTO
-     * @return the search response DTO
-     * @throws com.spectrayan.spector.commons.error.SpectorException if the search fails
-     */
-    public SearchResponseDto search(SearchRequest request) throws com.spectrayan.spector.commons.error.SpectorException {
-        SearchQuery query = request.toQuery();
-        long startNanos = System.nanoTime();
-
-        try {
-            SearchResponse response = executeSearch(query);
-            long latencyMs = (System.nanoTime() - startNanos) / 1_000_000;
-
-            eventBus.publish(new SpectorSearchCompletedEvent(
-                    nodeId, Instant.now(),
-                    response.totalHits(), latencyMs, response.mode().name()));
-
-            return SearchResponseDto.from(response);
-
-        } catch (Exception e) {
-            long latencyMs = (System.nanoTime() - startNanos) / 1_000_000;
-            eventBus.publish(new SpectorSearchFailedEvent(
-                    nodeId, Instant.now(),
-                    request.resolvedMode().name(), e.getMessage()));
-
-            throw SpectorApiException.internal(ErrorCode.INTERNAL_ERROR, e, "Search failed: " + e.getMessage());
-        }
-    }
-
-    /**
-     * Executes a search query and returns the raw engine response.
-     * Used by streaming endpoints that need direct access to results.
-     */
-    public SearchResponse searchRaw(SearchQuery query) {
-        return executeSearch(query);
-    }
-
-    private SearchResponse executeSearch(SearchQuery query) {
-        if (coordinator != null) {
-            // Clustered mode — fan-out by mode
-            long start = System.nanoTime();
-            ScoredResult[] results = switch (query.mode()) {
-                case KEYWORD -> coordinator.keywordSearch(query.text(), query.topK());
-                case VECTOR -> coordinator.vectorSearch(query.vector(), query.topK());
-                case HYBRID -> coordinator.hybridSearch(query.text(), query.vector(), query.topK());
-            };
-            long elapsed = (System.nanoTime() - start) / 1_000_000;
-            return new SearchResponse(results, results.length, elapsed, query.mode());
-        }
-        // Standalone — local engine
-        return engine.search(query);
-    }
-}
diff --git a/spector-node/src/test/java/com/spectrayan/spector/cluster/GrpcErrorMapperTest.java b/spector-node/src/test/java/com/spectrayan/spector/cluster/GrpcErrorMapperTest.java
deleted file mode 100644
index e6d74bc..0000000
--- a/spector-node/src/test/java/com/spectrayan/spector/cluster/GrpcErrorMapperTest.java
+++ /dev/null
@@ -1,100 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.cluster;
-
-import com.google.rpc.Code;
-import com.spectrayan.spector.commons.error.*;
-import com.spectrayan.spector.cluster.error.SpectorShardUnavailableException;
-import io.grpc.Status;
-import io.grpc.StatusRuntimeException;
-import io.grpc.protobuf.StatusProto;
-import org.junit.jupiter.api.Test;
-
-import static org.junit.jupiter.api.Assertions.*;
-
-/**
- * Unit tests for {@link GrpcErrorMapper}.
- */
-class GrpcErrorMapperTest {
-
-    @Test
-    void shouldMapValidationExceptionToInvalidArgumentStatusRuntimeException() {
-        var cause = new SpectorValidationException(ErrorCode.DIMENSIONS_MISMATCH, 384, 768);
-        StatusRuntimeException sre = GrpcErrorMapper.toStatusRuntimeException(cause);
-
-        assertNotNull(sre);
-        com.google.rpc.Status status = StatusProto.fromThrowable(sre);
-        assertNotNull(status);
-
-        assertEquals(Code.INVALID_ARGUMENT.getNumber(), status.getCode());
-        assertTrue(status.getMessage().contains("SPE-100-002"));
-        assertTrue(status.getMessage().contains("Expected 384 dimensions but received 768"));
-
-        assertEquals(1, status.getDetailsCount());
-    }
-
-    @Test
-    void shouldMapGenericExceptionToInternalStatusRuntimeException() {
-        var cause = new RuntimeException("DB offline");
-        StatusRuntimeException sre = GrpcErrorMapper.toStatusRuntimeException(cause);
-
-        assertNotNull(sre);
-        com.google.rpc.Status status = StatusProto.fromThrowable(sre);
-        assertNotNull(status);
-
-        assertEquals(Code.INTERNAL.getNumber(), status.getCode());
-        assertEquals("DB offline", status.getMessage());
-    }
-
-    @Test
-    void shouldReconstructConcreteExceptionOnClientSide() {
-        var original = new SpectorValidationException(ErrorCode.TOP_K_INVALID, 10, 0);
-        StatusRuntimeException sre = GrpcErrorMapper.toStatusRuntimeException(original);
-
-        SpectorException reconstructed = GrpcErrorMapper.toSpectorException(sre, "shard-1");
-
-        assertNotNull(reconstructed);
-        assertTrue(reconstructed instanceof SpectorValidationException, "Expected SpectorValidationException class");
-        assertEquals(ErrorCode.TOP_K_INVALID, reconstructed.errorCode());
-        assertEquals(original.getMessage(), reconstructed.getMessage(), "Message should be perfectly preserved");
-    }
-
-    @Test
-    void shouldReconstructStorageExceptionOnClientSide() {
-        var original = new SpectorStorageException(ErrorCode.STORE_FULL, "index-1");
-        StatusRuntimeException sre = GrpcErrorMapper.toStatusRuntimeException(original);
-
-        SpectorException reconstructed = GrpcErrorMapper.toSpectorException(sre, "shard-1");
-
-        assertNotNull(reconstructed);
-        assertTrue(reconstructed instanceof SpectorStorageException, "Expected SpectorStorageException class");
-        assertEquals(ErrorCode.STORE_FULL, reconstructed.errorCode());
-        assertEquals(original.getMessage(), reconstructed.getMessage());
-    }
-
-    @Test
-    void shouldFallbackToSpectorShardUnavailableExceptionForGenericGrpcErrors() {
-        StatusRuntimeException sre = io.grpc.Status.UNAVAILABLE
-                .withDescription("Connection refused")
-                .asRuntimeException();
-
-        SpectorException reconstructed = GrpcErrorMapper.toSpectorException(sre, "shard-9");
-
-        assertNotNull(reconstructed);
-        assertTrue(reconstructed instanceof SpectorShardUnavailableException, "Expected SpectorShardUnavailableException fallback");
-        assertEquals("shard-9", ((SpectorShardUnavailableException) reconstructed).getShardId());
-    }
-}
diff --git a/spector-query/README.md b/spector-query/README.md
deleted file mode 100644
index c00a437..0000000
--- a/spector-query/README.md
+++ /dev/null
@@ -1,39 +0,0 @@
-# spector-query 🔍
-
-> **Hybrid orchestrator, Reciprocal Rank Fusion (RRF), and LLM re-ranking engine.**
-
-`spector-query` coordinates hybrid searches by executing parallel keyword (BM25) and semantic vector (HNSW) searches on Virtual Threads, fusing their scores using Reciprocal Rank Fusion (RRF), and executing final listwise LLM relevance re-ranking for precision-critical pipelines.
-
----
-
-## 🏗️ Core Architecture & Roles
-
-1. **Hybrid Query Planner (`HybridQueryPlanner`):** Orchestrates parallel execution of keyword search and vector search legs on JVM Virtual Threads.
-2. **Reciprocal Rank Fusion (`RrfCombiner`):** Fuses keyword rankings and vector rankings using rank-based scores:
-   $$RRF\_Score(d) = \sum_{m \in M} \frac{1}{k + r_m(d)}$$
-   This prevents raw scoring scale differences from skewing the results.
-3. **Listwise LLM Re-ranker (`OllamaReranker`):** Sends the top retrieved candidates to a local Ollama LLM (e.g. `llama3.2`) in a listwise prompt to calculate final relevance scores.
-
----
-
-## 🚀 Key APIs
-
-### Executing an Orchestrated Hybrid Query
-```java
-// Coordinates both legs in parallel using Virtual Threads
-SearchResponse response = HybridQueryPlanner.execute(
-    engine,
-    "java vector api",    // keyword text
-    queryVector,          // semantic vector
-    10                    // topK
-);
-```
-
-### RRF Fusion
-```java
-ScoredResult[] keywordResults = ...;
-ScoredResult[] vectorResults = ...;
-int k = 60; // default RRF constant
-
-ScoredResult[] fused = RrfCombiner.fuse(keywordResults, vectorResults, k);
-```
diff --git a/spector-query/pom.xml b/spector-query/pom.xml
index abbd444..d9610eb 100644
--- a/spector-query/pom.xml
+++ b/spector-query/pom.xml
@@ -6,7 +6,7 @@
 
     <parent>
         <groupId>com.spectrayan</groupId>
-        <artifactId>spector</artifactId>
+        <artifactId>spector-search</artifactId>
         <version>0.1.0-SNAPSHOT</version>
     </parent>
 
@@ -19,10 +19,6 @@
             <groupId>com.spectrayan</groupId>
             <artifactId>spector-index</artifactId>
         </dependency>
-        <dependency>
-            <groupId>com.spectrayan</groupId>
-            <artifactId>spector-commons</artifactId>
-        </dependency>
     </dependencies>
 
 </project>
diff --git a/spector-query/src/main/java/com/spectrayan/spector/query/HybridSearchOrchestrator.java b/spector-query/src/main/java/com/spectrayan/spector/query/HybridSearchOrchestrator.java
index 69992d9..551b1c0 100644
--- a/spector-query/src/main/java/com/spectrayan/spector/query/HybridSearchOrchestrator.java
+++ b/spector-query/src/main/java/com/spectrayan/spector/query/HybridSearchOrchestrator.java
@@ -1,22 +1,5 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.query;
 
-import com.spectrayan.spector.commons.concurrent.ConcurrentExecutionException;
-import com.spectrayan.spector.commons.concurrent.ConcurrentTasks;
 import com.spectrayan.spector.index.KeywordIndex;
 import com.spectrayan.spector.index.ScoredResult;
 import com.spectrayan.spector.index.VectorIndex;
@@ -26,13 +9,16 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import java.util.List;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
 
 /**
  * Orchestrates hybrid search across keyword and vector indexes.
  *
  * <p>In {@link SearchQuery.SearchMode#HYBRID} mode, keyword and vector searches
- * are executed in parallel using {@link ConcurrentTasks}, then merged via
+ * are executed in parallel on virtual threads, then merged via
  * {@link ReciprocalRankFusion}.</p>
  *
  * <h3>Execution Model</h3>
@@ -42,11 +28,10 @@
  *   <li>{@code HYBRID} — fans out both in parallel, fuses via RRF</li>
  * </ul>
  *
- * <h3>Concurrency</h3>
- * <p>Uses {@link ConcurrentTasks#forkJoinAll} which provides dual-mode concurrency:
- * structured concurrency (JEP 505) with automatic cancellation by default, or
- * classic virtual-thread executor when structured concurrency is disabled via
- * {@code -Dspector.concurrency.structured=false}.</p>
+ * <h3>Performance</h3>
+ * <p>Uses a shared virtual-thread executor to avoid per-query lifecycle overhead.
+ * Virtual threads are extremely cheap (~few hundred bytes each), so a shared
+ * unbounded executor with per-task threads is optimal.</p>
  */
 public class HybridSearchOrchestrator implements AutoCloseable {
 
@@ -54,6 +39,7 @@ public class HybridSearchOrchestrator implements AutoCloseable {
 
     private final KeywordIndex keywordIndex;
     private final VectorIndex vectorIndex;
+    private final ExecutorService executor;
     private final Reranker reranker;       // nullable
     private final DocumentStore docStore;  // nullable, needed for re-ranking
 
@@ -81,6 +67,7 @@ public HybridSearchOrchestrator(KeywordIndex keywordIndex, VectorIndex vectorInd
         this.vectorIndex = vectorIndex;
         this.reranker = reranker;
         this.docStore = docStore;
+        this.executor = Executors.newVirtualThreadPerTaskExecutor();
     }
 
     /**
@@ -118,7 +105,7 @@ public SearchResponse search(SearchQuery query) {
 
     @Override
     public void close() {
-        // No executor to close — ConcurrentTasks manages scope per-call
+        executor.close();
     }
 
     // ─────────────── Mode handlers ───────────────
@@ -140,9 +127,8 @@ private ScoredResult[] executeVectorSearch(SearchQuery query) {
     /**
      * Executes hybrid search: parallel fan-out → RRF fusion.
      *
-     * <p>Uses {@link ConcurrentTasks#forkJoin2} for zero-allocation parallel execution.
-     * In structured concurrency mode, if either sub-search fails, the other is
-     * automatically cancelled — preventing thread leaks.</p>
+     * <p>Uses the shared virtual-thread executor for lightweight parallelism.
+     * Each sub-search runs on its own virtual thread for maximum concurrency.</p>
      */
     private ScoredResult[] executeHybridSearch(SearchQuery query) {
         boolean hasKeyword = keywordIndex != null && query.text() != null;
@@ -156,23 +142,27 @@ private ScoredResult[] executeHybridSearch(SearchQuery query) {
         int retrievalK = Math.max(query.topK() * 2, 50);
 
         try {
-            var pair = ConcurrentTasks.forkJoin2(
-                    () -> keywordIndex.search(query.text(), retrievalK),
-                    () -> vectorIndex.search(query.vector(), retrievalK)
-            );
+            Future<ScoredResult[]> keywordFuture = executor.submit(
+                    () -> keywordIndex.search(query.text(), retrievalK));
+            Future<ScoredResult[]> vectorFuture = executor.submit(
+                    () -> vectorIndex.search(query.vector(), retrievalK));
+
+            ScoredResult[] keywordResults = keywordFuture.get();
+            ScoredResult[] vectorResults = vectorFuture.get();
 
             return ReciprocalRankFusion.fuse(
-                    new ScoredResult[][]{pair.first(), pair.second()},
+                    new ScoredResult[][]{keywordResults, vectorResults},
                     query.topK()
             );
 
-        } catch (ConcurrentExecutionException e) {
-            log.error("Hybrid search failed", e.getCause());
-            return new ScoredResult[0];
         } catch (InterruptedException e) {
             Thread.currentThread().interrupt();
             log.warn("Hybrid search interrupted", e);
             return new ScoredResult[0];
+        } catch (ExecutionException e) {
+            log.error("Hybrid search failed", e.getCause());
+            return new ScoredResult[0];
         }
     }
 }
+
diff --git a/spector-query/src/main/java/com/spectrayan/spector/query/QueryParser.java b/spector-query/src/main/java/com/spectrayan/spector/query/QueryParser.java
index 003230a..fc4a71d 100644
--- a/spector-query/src/main/java/com/spectrayan/spector/query/QueryParser.java
+++ b/spector-query/src/main/java/com/spectrayan/spector/query/QueryParser.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.query;
 
 import java.util.HashMap;
diff --git a/spector-query/src/main/java/com/spectrayan/spector/query/ReciprocalRankFusion.java b/spector-query/src/main/java/com/spectrayan/spector/query/ReciprocalRankFusion.java
index 4bcc25e..ccf2847 100644
--- a/spector-query/src/main/java/com/spectrayan/spector/query/ReciprocalRankFusion.java
+++ b/spector-query/src/main/java/com/spectrayan/spector/query/ReciprocalRankFusion.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.query;
 
 import com.spectrayan.spector.index.ScoredResult;
diff --git a/spector-query/src/main/java/com/spectrayan/spector/query/SearchQuery.java b/spector-query/src/main/java/com/spectrayan/spector/query/SearchQuery.java
index a3324cd..3255c8c 100644
--- a/spector-query/src/main/java/com/spectrayan/spector/query/SearchQuery.java
+++ b/spector-query/src/main/java/com/spectrayan/spector/query/SearchQuery.java
@@ -1,23 +1,6 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.query;
 
 import java.util.Map;
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-import com.spectrayan.spector.commons.error.ErrorCode;
 
 /**
  * Represents a search query with mode selection and parameters.
@@ -46,7 +29,7 @@ public enum SearchMode {
     }
 
     public SearchQuery {
-        if (topK <= 0) throw new SpectorValidationException(ErrorCode.TOP_K_INVALID, 1, topK);
+        if (topK <= 0) throw new IllegalArgumentException("topK must be positive: " + topK);
         if (mode == null) mode = SearchMode.HYBRID;
         if (metadata == null) metadata = Map.of();
     }
diff --git a/spector-query/src/main/java/com/spectrayan/spector/query/SearchResponse.java b/spector-query/src/main/java/com/spectrayan/spector/query/SearchResponse.java
index 7796526..b522698 100644
--- a/spector-query/src/main/java/com/spectrayan/spector/query/SearchResponse.java
+++ b/spector-query/src/main/java/com/spectrayan/spector/query/SearchResponse.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.query;
 
 import com.spectrayan.spector.index.ScoredResult;
diff --git a/spector-query/src/main/java/com/spectrayan/spector/query/package-info.java b/spector-query/src/main/java/com/spectrayan/spector/query/package-info.java
index 10ec4fa..019b881 100644
--- a/spector-query/src/main/java/com/spectrayan/spector/query/package-info.java
+++ b/spector-query/src/main/java/com/spectrayan/spector/query/package-info.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 /**
  * Spector Query — Query engine with hybrid search orchestration and RRF fusion.
  *
diff --git a/spector-query/src/main/java/com/spectrayan/spector/query/ranking/LlmReranker.java b/spector-query/src/main/java/com/spectrayan/spector/query/ranking/LlmReranker.java
index 26610cc..a5f72db 100644
--- a/spector-query/src/main/java/com/spectrayan/spector/query/ranking/LlmReranker.java
+++ b/spector-query/src/main/java/com/spectrayan/spector/query/ranking/LlmReranker.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.query.ranking;
 
 import com.spectrayan.spector.index.ScoredResult;
@@ -30,8 +15,6 @@
 import java.time.Duration;
 import java.util.Arrays;
 import java.util.Comparator;
-import com.spectrayan.spector.commons.error.SpectorServerException;
-import com.spectrayan.spector.commons.error.ErrorCode;
 
 /**
  * LLM-powered re-ranker using a local Ollama server.
@@ -187,7 +170,7 @@ private String callOllama(String prompt) throws Exception {
                 HttpResponse.BodyHandlers.ofString());
 
         if (response.statusCode() != 200) {
-            throw new SpectorServerException(ErrorCode.EMBEDDING_UNAVAILABLE);
+            throw new RuntimeException("Ollama returned status " + response.statusCode());
         }
 
         // Extract "response" field from JSON (simple parsing)
diff --git a/spector-query/src/main/java/com/spectrayan/spector/query/ranking/Reranker.java b/spector-query/src/main/java/com/spectrayan/spector/query/ranking/Reranker.java
index b4f11c8..6456487 100644
--- a/spector-query/src/main/java/com/spectrayan/spector/query/ranking/Reranker.java
+++ b/spector-query/src/main/java/com/spectrayan/spector/query/ranking/Reranker.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.query.ranking;
 
 import com.spectrayan.spector.index.ScoredResult;
diff --git a/spector-query/src/test/java/com/spectrayan/spector/query/HybridSearchOrchestratorTest.java b/spector-query/src/test/java/com/spectrayan/spector/query/HybridSearchOrchestratorTest.java
index 6812a00..53da784 100644
--- a/spector-query/src/test/java/com/spectrayan/spector/query/HybridSearchOrchestratorTest.java
+++ b/spector-query/src/test/java/com/spectrayan/spector/query/HybridSearchOrchestratorTest.java
@@ -1,23 +1,8 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.query;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
-import com.spectrayan.spector.core.similarity.SimilarityFunction;
+import com.spectrayan.spector.core.SimilarityFunction;
 import com.spectrayan.spector.index.BM25Index;
 import com.spectrayan.spector.index.HnswIndex;
 import com.spectrayan.spector.index.ScoredResult;
diff --git a/spector-query/src/test/java/com/spectrayan/spector/query/QueryParserTest.java b/spector-query/src/test/java/com/spectrayan/spector/query/QueryParserTest.java
index 705f2d6..56e167f 100644
--- a/spector-query/src/test/java/com/spectrayan/spector/query/QueryParserTest.java
+++ b/spector-query/src/test/java/com/spectrayan/spector/query/QueryParserTest.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.query;
 
 import static org.assertj.core.api.Assertions.assertThat;
diff --git a/spector-query/src/test/java/com/spectrayan/spector/query/ReciprocalRankFusionTest.java b/spector-query/src/test/java/com/spectrayan/spector/query/ReciprocalRankFusionTest.java
index dfead44..eff5451 100644
--- a/spector-query/src/test/java/com/spectrayan/spector/query/ReciprocalRankFusionTest.java
+++ b/spector-query/src/test/java/com/spectrayan/spector/query/ReciprocalRankFusionTest.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.query;
 
 import static org.assertj.core.api.Assertions.assertThat;
diff --git a/spector-query/src/test/java/com/spectrayan/spector/query/ranking/LlmRerankerTest.java b/spector-query/src/test/java/com/spectrayan/spector/query/ranking/LlmRerankerTest.java
index 38f7504..0155968 100644
--- a/spector-query/src/test/java/com/spectrayan/spector/query/ranking/LlmRerankerTest.java
+++ b/spector-query/src/test/java/com/spectrayan/spector/query/ranking/LlmRerankerTest.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.query.ranking;
 
 import com.spectrayan.spector.index.ScoredResult;
diff --git a/spector-rag/README.md b/spector-rag/README.md
deleted file mode 100644
index aac884d..0000000
--- a/spector-rag/README.md
+++ /dev/null
@@ -1,39 +0,0 @@
-# spector-rag 🤖
-
-> **Zero-dependency Retrieval-Augmented Generation (RAG) context assembly and prompt pipelines.**
-
-`spector-rag` implements zero-dependency RAG context orchestration. It executes semantic/hybrid searches on `SpectorEngine`, ranks and filters the top retrieved passages using listwise re-rankers, assembles context packages, and templates LLM prompts.
-
----
-
-## 🏗️ Core Architecture & Roles
-
-1. **Context Assembler (`ContextAssembler`):** Aggregates text passages from hybrid search, deduplicates entries, and trims contexts based on maximum LLM token budgets.
-2. **Prompt Template Controller (`PromptTemplate`):** Maps search results to custom markdown templates:
-   ```
-   Answer the query based ONLY on the following context:
-   ---
-   [Context Passages]
-   ---
-   Query: [User Query]
-   ```
-3. **RAG Client (`RagClient`):** Handles remote connection streams with Ollama or external OpenAI-compatible services.
-
----
-
-## 🚀 Key APIs
-
-### Generating a Prompt Template
-```java
-// Retrieve context using SpectorEngine
-SearchResponse response = engine.hybridSearch(query, queryVector, 5);
-
-// Format prompt based on Markdown template
-String contextPrompt = PromptTemplate.DEFAULT
-    .withQuery(query)
-    .withResults(response.results())
-    .assemble();
-
-// Send prompt directly to your LLM provider
-String llmResponse = RagClient.generate(contextPrompt);
-```
diff --git a/spector-rag/pom.xml b/spector-rag/pom.xml
deleted file mode 100644
index fea947a..0000000
--- a/spector-rag/pom.xml
+++ /dev/null
@@ -1,40 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0"
-         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
-    <modelVersion>4.0.0</modelVersion>
-
-    <parent>
-        <groupId>com.spectrayan</groupId>
-        <artifactId>spector</artifactId>
-        <version>0.1.0-SNAPSHOT</version>
-    </parent>
-
-    <artifactId>spector-rag</artifactId>
-    <name>Spector RAG</name>
-    <description>Retrieval-Augmented Generation pipeline: context assembly, attribution, and retrieval orchestration.</description>
-
-    <dependencies>
-        <dependency>
-            <groupId>com.spectrayan</groupId>
-            <artifactId>spector-commons</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>com.spectrayan</groupId>
-            <artifactId>spector-embed-api</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>com.spectrayan</groupId>
-            <artifactId>spector-query</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>com.spectrayan</groupId>
-            <artifactId>spector-storage</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>com.spectrayan</groupId>
-            <artifactId>spector-index</artifactId>
-        </dependency>
-    </dependencies>
-
-</project>
diff --git a/spector-rag/src/main/java/com/spectrayan/spector/rag/ChunkAttribution.java b/spector-rag/src/main/java/com/spectrayan/spector/rag/ChunkAttribution.java
deleted file mode 100644
index 120ba02..0000000
--- a/spector-rag/src/main/java/com/spectrayan/spector/rag/ChunkAttribution.java
+++ /dev/null
@@ -1,37 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.rag;
-
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-import com.spectrayan.spector.commons.error.ErrorCode;
-
-/**
- * Source attribution metadata for a chunk included in the assembled context.
- *
- * @param documentId  the identifier of the source document
- * @param chunkOffset the offset (index) of the chunk within the source document
- */
-public record ChunkAttribution(String documentId, int chunkOffset) {
-
-    public ChunkAttribution {
-        if (documentId == null || documentId.isBlank()) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_NULL, "documentId");
-        }
-        if (chunkOffset < 0) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_NEGATIVE, "chunkOffset", 0);
-        }
-    }
-}
diff --git a/spector-rag/src/main/java/com/spectrayan/spector/rag/ContextResult.java b/spector-rag/src/main/java/com/spectrayan/spector/rag/ContextResult.java
deleted file mode 100644
index f5b49c3..0000000
--- a/spector-rag/src/main/java/com/spectrayan/spector/rag/ContextResult.java
+++ /dev/null
@@ -1,47 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.rag;
-
-import java.util.List;
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-import com.spectrayan.spector.commons.error.ErrorCode;
-
-/**
- * Result of context assembly by the {@link ContextBuilder}.
- *
- * @param contextText  the assembled context string (empty if no chunks fit)
- * @param attributions source attribution entries for each included chunk
- * @param isEmpty      indicator that no chunks were included in the context
- */
-public record ContextResult(String contextText, List<ChunkAttribution> attributions, boolean isEmpty) {
-
-    public ContextResult {
-        if (contextText == null) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_NULL, "contextText");
-        }
-        if (attributions == null) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_NULL, "attributions");
-        }
-        attributions = List.copyOf(attributions);
-    }
-
-    /**
-     * Creates an empty context result indicating no chunks were included.
-     */
-    public static ContextResult empty() {
-        return new ContextResult("", List.of(), true);
-    }
-}
diff --git a/spector-rag/src/main/java/com/spectrayan/spector/rag/RagPipeline.java b/spector-rag/src/main/java/com/spectrayan/spector/rag/RagPipeline.java
deleted file mode 100644
index 81a0f3c..0000000
--- a/spector-rag/src/main/java/com/spectrayan/spector/rag/RagPipeline.java
+++ /dev/null
@@ -1,180 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.rag;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import com.spectrayan.spector.commons.TextChunk;
-import com.spectrayan.spector.commons.WordTokenizer;
-import com.spectrayan.spector.embed.EmbeddingProvider;
-import com.spectrayan.spector.index.ScoredResult;
-import com.spectrayan.spector.query.HybridSearchOrchestrator;
-import com.spectrayan.spector.query.SearchQuery;
-import com.spectrayan.spector.query.SearchResponse;
-import com.spectrayan.spector.storage.Document;
-import com.spectrayan.spector.storage.DocumentStore;
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-import com.spectrayan.spector.commons.error.ErrorCode;
-import com.spectrayan.spector.commons.error.SpectorServerException;
-
-/**
- * Full RAG pipeline orchestrator: query → embed → retrieve → assemble context.
- *
- * <p>Coordinates the end-to-end RAG flow using synchronous calls on virtual threads.
- * No reactive framework needed — virtual threads handle the I/O-bound embedding call
- * efficiently while the search and assembly steps are CPU-bound and fast.</p>
- *
- * <h3>Pipeline Steps</h3>
- * <ol>
- *   <li>Validate request</li>
- *   <li>Embed the query text via {@link EmbeddingProvider}</li>
- *   <li>Search via {@link HybridSearchOrchestrator} (vector or hybrid mode)</li>
- *   <li>Fetch document content from {@link DocumentStore}</li>
- *   <li>Assemble context via {@link ContextBuilder} within token budget</li>
- *   <li>Return {@link RagResponse} with attributions</li>
- * </ol>
- *
- * <h3>Usage</h3>
- * <pre>{@code
- *   var pipeline = new RagPipeline(searchOrchestrator, documentStore, embeddingProvider);
- *   RagResponse response = pipeline.execute(new RagRequest("What is HNSW?"));
- * }</pre>
- */
-public class RagPipeline {
-
-    private static final Logger log = LoggerFactory.getLogger(RagPipeline.class);
-
-    private static final int MAX_QUERY_LENGTH = 2000;
-
-    private final HybridSearchOrchestrator searchOrchestrator;
-    private final DocumentStore documentStore;
-    private final EmbeddingProvider embeddingProvider;
-    private final ContextBuilder contextBuilder;
-
-    /**
-     * Creates a RAG pipeline.
-     *
-     * @param searchOrchestrator the hybrid search orchestrator
-     * @param documentStore      document store for retrieving content
-     * @param embeddingProvider  embedding provider for query vectorization
-     */
-    public RagPipeline(HybridSearchOrchestrator searchOrchestrator,
-                       DocumentStore documentStore,
-                       EmbeddingProvider embeddingProvider) {
-        this.searchOrchestrator = searchOrchestrator;
-        this.documentStore = documentStore;
-        this.embeddingProvider = embeddingProvider;
-        this.contextBuilder = new ContextBuilder();
-    }
-
-    /**
-     * Executes the full RAG pipeline for the given request.
-     *
-     * @param request the RAG request
-     * @return RAG response with assembled context and attributions
-     * @throws SpectorValidationException if the request is invalid
-     * @throws SpectorServerException     if the embedding provider is unavailable
-     */
-    public RagResponse execute(RagRequest request) {
-        long start = System.nanoTime();
-
-        // Validate
-        validate(request);
-
-        int topK = request.resolvedTopK();
-        int tokenLimit = request.resolvedTokenLimit();
-        String searchMode = request.resolvedSearchMode();
-
-        // Embed the query
-        float[] queryVector;
-        try {
-            queryVector = embeddingProvider.embed(request.query()).vector();
-        } catch (Exception e) {
-            log.warn("Embedding failed for RAG query: {}", e.getMessage());
-            throw new SpectorServerException(ErrorCode.EMBEDDING_UNAVAILABLE, e);
-        }
-
-        // Search
-        SearchQuery query = buildSearchQuery(request.query(), queryVector, topK, searchMode);
-        SearchResponse searchResponse = searchOrchestrator.search(query);
-
-        long elapsed = (System.nanoTime() - start) / 1_000_000;
-
-        // No results
-        if (searchResponse.results() == null || searchResponse.results().length == 0) {
-            return RagResponse.empty(elapsed);
-        }
-
-        // Convert to scored chunks
-        List<ScoredChunk> scoredChunks = toScoredChunks(searchResponse.results());
-
-        if (scoredChunks.isEmpty()) {
-            return RagResponse.empty(elapsed);
-        }
-
-        // Assemble context
-        ContextResult contextResult = contextBuilder.build(scoredChunks, tokenLimit);
-
-        elapsed = (System.nanoTime() - start) / 1_000_000;
-
-        if (contextResult.isEmpty()) {
-            return RagResponse.empty(elapsed);
-        }
-
-        // Map attributions
-        List<RagResponse.Attribution> attributions = contextResult.attributions().stream()
-                .map(attr -> new RagResponse.Attribution(attr.documentId(), attr.chunkOffset()))
-                .toList();
-
-        return new RagResponse(contextResult.contextText(), attributions, null, elapsed);
-    }
-
-    private void validate(RagRequest request) {
-        if (request.query() == null || request.query().isBlank()) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_NULL, "query");
-        }
-        if (request.query().length() > MAX_QUERY_LENGTH) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_OUT_OF_RANGE, "query.length", 1, MAX_QUERY_LENGTH, 0);
-        }
-    }
-
-    private SearchQuery buildSearchQuery(String text, float[] vector, int topK, String searchMode) {
-        if ("hybrid".equals(searchMode)) {
-            return SearchQuery.hybrid(text, vector, topK);
-        }
-        return SearchQuery.vector(vector, topK);
-    }
-
-    private List<ScoredChunk> toScoredChunks(ScoredResult[] results) {
-        List<ScoredChunk> chunks = new ArrayList<>(results.length);
-        for (ScoredResult result : results) {
-            Document document = documentStore.get(result.id());
-            if (document == null) continue;
-
-            String content = document.content();
-            if (content == null || content.isBlank()) continue;
-
-            int tokenCount = WordTokenizer.countTokens(content);
-            TextChunk textChunk = new TextChunk(content, tokenCount, 0, content.length(), result.id());
-            chunks.add(new ScoredChunk(textChunk, result.score()));
-        }
-        return chunks;
-    }
-}
\ No newline at end of file
diff --git a/spector-rag/src/main/java/com/spectrayan/spector/rag/RagRequest.java b/spector-rag/src/main/java/com/spectrayan/spector/rag/RagRequest.java
deleted file mode 100644
index 2bcac6a..0000000
--- a/spector-rag/src/main/java/com/spectrayan/spector/rag/RagRequest.java
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.rag;
-
-/**
- * Input parameters for a RAG pipeline query.
- *
- * @param query       the user query text
- * @param topK        maximum number of chunks to retrieve (default: 5)
- * @param tokenLimit  maximum tokens in assembled context (default: 4096)
- * @param searchMode  "vector" or "hybrid" (default: "vector")
- */
-public record RagRequest(String query, Integer topK, Integer tokenLimit, String searchMode) {
-
-    /** Default topK if not specified. */
-    public static final int DEFAULT_TOP_K = 5;
-
-    /** Default token limit if not specified. */
-    public static final int DEFAULT_TOKEN_LIMIT = 4096;
-
-    /** Convenience constructor with just a query. */
-    public RagRequest(String query) {
-        this(query, null, null, null);
-    }
-
-    /** Returns resolved topK with bounds [1, 100]. */
-    public int resolvedTopK() {
-        if (topK == null) return DEFAULT_TOP_K;
-        return Math.max(1, Math.min(100, topK));
-    }
-
-    /** Returns resolved token limit with bounds [256, 131072]. */
-    public int resolvedTokenLimit() {
-        if (tokenLimit == null) return DEFAULT_TOKEN_LIMIT;
-        return Math.max(256, Math.min(131_072, tokenLimit));
-    }
-
-    /** Returns resolved search mode (defaults to "vector"). */
-    public String resolvedSearchMode() {
-        if (searchMode == null || searchMode.isBlank()) return "vector";
-        String normalized = searchMode.toLowerCase().trim();
-        if ("hybrid".equals(normalized)) return "hybrid";
-        return "vector";
-    }
-}
diff --git a/spector-rag/src/main/java/com/spectrayan/spector/rag/RagResponse.java b/spector-rag/src/main/java/com/spectrayan/spector/rag/RagResponse.java
deleted file mode 100644
index f1869dd..0000000
--- a/spector-rag/src/main/java/com/spectrayan/spector/rag/RagResponse.java
+++ /dev/null
@@ -1,47 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.rag;
-
-import java.util.List;
-
-/**
- * Output from a RAG pipeline execution.
- *
- * @param contextText  the assembled context string for LLM prompting
- * @param attributions source attributions for included chunks
- * @param message      optional message (e.g., "No matching documents found")
- * @param queryTimeMs  total pipeline execution time in milliseconds
- */
-public record RagResponse(
-        String contextText,
-        List<Attribution> attributions,
-        String message,
-        long queryTimeMs
-) {
-
-    /**
-     * Source attribution for a chunk in the context.
-     *
-     * @param documentId  source document ID
-     * @param chunkOffset chunk offset within the document
-     */
-    public record Attribution(String documentId, int chunkOffset) {}
-
-    /** Creates an empty response when no results are found. */
-    public static RagResponse empty(long queryTimeMs) {
-        return new RagResponse("", List.of(), "No matching documents were found", queryTimeMs);
-    }
-}
diff --git a/spector-rag/src/main/java/com/spectrayan/spector/rag/ScoredChunk.java b/spector-rag/src/main/java/com/spectrayan/spector/rag/ScoredChunk.java
deleted file mode 100644
index 7e64418..0000000
--- a/spector-rag/src/main/java/com/spectrayan/spector/rag/ScoredChunk.java
+++ /dev/null
@@ -1,38 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.rag;
-
-import com.spectrayan.spector.commons.TextChunk;
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-import com.spectrayan.spector.commons.error.ErrorCode;
-
-/**
- * A text chunk annotated with a relevance score from search.
- *
- * @param chunk the text chunk
- * @param score relevance score (higher is more relevant)
- */
-public record ScoredChunk(TextChunk chunk, float score) {
-
-    public ScoredChunk {
-        if (chunk == null) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_NULL, "chunk");
-        }
-        if (Float.isNaN(score)) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_INVALID, "score", "NaN");
-        }
-    }
-}
diff --git a/spector-rag/src/main/java/com/spectrayan/spector/rag/package-info.java b/spector-rag/src/main/java/com/spectrayan/spector/rag/package-info.java
deleted file mode 100644
index ab65d2e..0000000
--- a/spector-rag/src/main/java/com/spectrayan/spector/rag/package-info.java
+++ /dev/null
@@ -1,31 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-/**
- * Retrieval-Augmented Generation pipeline for Spector.
- *
- * <p>Provides the full RAG flow: query embedding → retrieval → context assembly → attribution.
- * Uses virtual threads for I/O-bound operations (embedding calls) while keeping retrieval
- * on the synchronous high-performance path.</p>
- *
- * <h3>Key Classes</h3>
- * <ul>
- *   <li>{@link com.spectrayan.spector.rag.ContextBuilder} — assembles scored chunks into a token-limited context</li>
- *   <li>{@link com.spectrayan.spector.rag.RagPipeline} — full RAG orchestrator: embed → search → assemble</li>
- *   <li>{@link com.spectrayan.spector.rag.RagRequest} — input parameters for a RAG query</li>
- *   <li>{@link com.spectrayan.spector.rag.RagResponse} — output with context, attributions, and metadata</li>
- * </ul>
- */
-package com.spectrayan.spector.rag;
diff --git a/spector-runtime/README.md b/spector-runtime/README.md
deleted file mode 100644
index f897685..0000000
--- a/spector-runtime/README.md
+++ /dev/null
@@ -1,118 +0,0 @@
-# ⚡ Spector Runtime
-
-**Composition root — the single entry point for all Spector consumers.**
-
-`SpectorRuntime` creates, wires, and exposes all subsystem services. It is a thin composition root with no business logic — each handler owns its domain.
-
-## Architecture
-
-```mermaid
-graph TD
-    RT["SpectorRuntime<br/><i>Composition Root</i>"]
-    SH["SearchHandler<br/><i>mode-aware routing</i>"]
-    IH["IngestionHandler<br/><i>pipeline delegation</i>"]
-    ENG["spector-engine<br/><i>vector search, RAG</i>"]
-    MEM["spector-memory<br/><i>cognitive memory</i>"]
-    ING["spector-ingestion<br/><i>IngestionPipeline</i>"]
-    CFG["spector-config"]
-    EMB["spector-embed-api"]
-
-    RT --> SH
-    RT --> IH
-    SH --> ENG
-    SH --> MEM
-    IH --> ING
-    ING --> ENG
-    ING --> MEM
-    RT --> CFG
-    RT --> EMB
-```
-
-`SpectorRuntime.ingestion()` builds the `IngestionPipeline` with the correct `IngestionTarget` (engine or cognitive) and reads chunking configuration from `spector.yml`.
-
-## Service Accessors
-
-| Accessor | Returns | Description |
-|----------|---------|-------------|
-| `runtime.search()` | `SearchHandler` | Mode-aware search (engine or memory) |
-| `runtime.ingestion()` | `IngestionHandler` | Mode-aware ingestion (text, file, directory) |
-| `runtime.engine()` | `SpectorEngine` | Direct engine access (always available) |
-| `runtime.memory()` | `SpectorMemory` | Direct memory access (null if disabled) |
-| `runtime.mode()` | `SpectorMode` | Current mode (SEARCH or MEMORY) |
-
-## Usage
-
-### Search & Ingest via Handlers
-
-```java
-try (var runtime = SpectorRuntime.from(props, embedder, true)) {
-    // Search — mode-aware (routes to engine or memory)
-    var results = runtime.search().query("query text", 10);
-    
-    // Ingest text — pipeline auto-chunks if content > threshold
-    runtime.ingestion().ingest("doc-1", "content text");
-    
-    // Ingest directory — discovers files, chunks, embeds, and stores
-    runtime.ingestion().ingest(Path.of("/docs"), "**/*.md", 800, 100, ".git");
-    
-    // Chunked ingestion — returns IngestionResult with chunk count
-    var result = runtime.ingestion().ingestChunked("doc-2", longContent);
-}
-```
-
-### Factory Methods
-
-```java
-// Standard — creates engine + optional memory from config
-SpectorRuntime.from(props, embedder);
-
-// With writable index (for ingestion)
-SpectorRuntime.from(props, embedder, true);
-
-// Engine-only (no memory)
-SpectorRuntime.engineOnly(engine, props);
-```
-
-## Configuration
-
-Runtime behavior is driven by `spector.yml`:
-
-```yaml
-spector:
-  mode: search              # search or memory
-  engine:
-    dimensions: 768
-    persistence-mode: DISK
-    data-directory: .spector/index
-  embedding:
-    model: nomic-embed-text
-    base-url: http://localhost:11434
-  memory:
-    enabled: true
-    persistence-mode: DISK
-    persistence-path: .spector-memory
-  ingestion:
-    root-directory: /path/to/docs
-    file-pattern: "**/*.md"
-    chunk-size: 800
-    chunk-overlap: 100
-```
-
-## Consumers
-
-| Module | How it uses SpectorRuntime |
-|--------|---------------------------|
-| `spector-cli` | `SpectorCtl` — CLI commands call `runtime.search()` / `runtime.ingestion()` |
-| `spector-mcp` | `SpectorMcpServer(runtime)` — MCP tools call runtime handlers |
-| `spector-node` | `SpectorNode(runtime)` — Armeria REST + gRPC + SSE endpoints |
-| `spector-dist` | Fat JAR bundles runtime + all modules |
-
-## Dependencies
-
-```xml
-<dependency>
-    <groupId>com.spectrayan</groupId>
-    <artifactId>spector-runtime</artifactId>
-    <version>0.1.0-SNAPSHOT</version>
-</dependency>
-```
diff --git a/spector-runtime/pom.xml b/spector-runtime/pom.xml
deleted file mode 100644
index 34b3372..0000000
--- a/spector-runtime/pom.xml
+++ /dev/null
@@ -1,68 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0"
-         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
-    <modelVersion>4.0.0</modelVersion>
-
-    <parent>
-        <groupId>com.spectrayan</groupId>
-        <artifactId>spector</artifactId>
-        <version>0.1.0-SNAPSHOT</version>
-    </parent>
-
-    <artifactId>spector-runtime</artifactId>
-    <name>Spector Runtime</name>
-    <description>
-        Unified application context that composes SpectorEngine (search) and
-        SpectorMemory (cognitive) into a single configurable runtime.
-        All consumers (MCP, API, CLI) depend on this module.
-    </description>
-
-    <dependencies>
-
-        <dependency>
-            <groupId>com.spectrayan</groupId>
-            <artifactId>spector-config</artifactId>
-        </dependency>
-        <!-- ── Configuration ── -->
-        <dependency>
-            <groupId>com.spectrayan</groupId>
-            <artifactId>spector-commons</artifactId>
-        </dependency>
-
-        <!-- ── Search Engine ── -->
-        <dependency>
-            <groupId>com.spectrayan</groupId>
-            <artifactId>spector-engine</artifactId>
-        </dependency>
-
-        <!-- ── Cognitive Memory ── -->
-        <dependency>
-            <groupId>com.spectrayan</groupId>
-            <artifactId>spector-memory</artifactId>
-        </dependency>
-
-        <!-- ── Embedding API ── -->
-        <dependency>
-            <groupId>com.spectrayan</groupId>
-            <artifactId>spector-embed-api</artifactId>
-        </dependency>
-
-        <!-- ── Query types for mode-aware routing ── -->
-        <dependency>
-            <groupId>com.spectrayan</groupId>
-            <artifactId>spector-query</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>com.spectrayan</groupId>
-            <artifactId>spector-index</artifactId>
-        </dependency>
-
-        <!-- ── Ingestion utilities (file discovery, chunking) ── -->
-        <dependency>
-            <groupId>com.spectrayan</groupId>
-            <artifactId>spector-ingestion</artifactId>
-        </dependency>
-    </dependencies>
-
-</project>
diff --git a/spector-runtime/src/main/java/com/spectrayan/spector/runtime/IngestionHandler.java b/spector-runtime/src/main/java/com/spectrayan/spector/runtime/IngestionHandler.java
deleted file mode 100644
index da1468f..0000000
--- a/spector-runtime/src/main/java/com/spectrayan/spector/runtime/IngestionHandler.java
+++ /dev/null
@@ -1,332 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.runtime;
-
-import java.io.IOException;
-import java.io.UncheckedIOException;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.time.Duration;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.concurrent.Semaphore;
-import java.util.concurrent.atomic.AtomicInteger;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import com.spectrayan.spector.commons.concurrent.ConcurrentTasks;
-
-import com.spectrayan.spector.config.SpectorMode;
-import com.spectrayan.spector.engine.SpectorEngine;
-import com.spectrayan.spector.ingestion.FileDiscoveryService;
-import com.spectrayan.spector.ingestion.IngestionPipeline;
-import com.spectrayan.spector.ingestion.IngestionResult;
-import com.spectrayan.spector.memory.SpectorMemory;
-
-/**
- * Mode-aware ingestion service — thin routing layer over the unified {@link IngestionPipeline}.
- *
- * <p>Handles all ingestion variants — raw text, single file, directory scan —
- * by delegating to a pre-configured {@link IngestionPipeline} that knows
- * how to chunk, embed, and store data for the active mode (search or memory).</p>
- *
- * <p>The pipeline is built by {@link SpectorRuntime} with the appropriate
- * {@link com.spectrayan.spector.ingestion.IngestionTarget} (engine or cognitive)
- * and chunking configuration from {@code spector.yml}.</p>
- *
- * <p>Obtained via {@code runtime.ingestion()}. Not instantiated directly.</p>
- */
-public final class IngestionHandler {
-
-    private static final Logger log = LoggerFactory.getLogger(IngestionHandler.class);
-
-    private final IngestionPipeline pipeline;
-    private final SpectorEngine engine;   // for count() and backward-compat
-    private final SpectorMemory memory;   // for count() (nullable)
-    private final SpectorMode mode;
-
-    IngestionHandler(IngestionPipeline pipeline, SpectorEngine engine,
-                     SpectorMemory memory, SpectorMode mode) {
-        this.pipeline = pipeline;
-        this.engine = engine;
-        this.memory = memory;
-        this.mode = mode;
-    }
-
-    // ─────────────── Text Ingestion ───────────────
-
-    /**
-     * Ingests raw text content. The pipeline handles chunking and embedding.
-     *
-     * @param id   document/memory ID
-     * @param text content text
-     */
-    public void ingest(String id, String text) {
-        pipeline.ingest(id, text);
-    }
-
-    /**
-     * Ingests a long text by auto-chunking via the pipeline.
-     *
-     * <p>The pipeline decides whether to chunk based on content length
-     * and its configured chunk threshold.</p>
-     *
-     * @param id      document ID
-     * @param content full document content
-     * @return ingestion result
-     */
-    public IngestionResult ingestChunked(String id, String content) {
-        return pipeline.ingest(id, content);
-    }
-
-    // ─────────────── File Ingestion ───────────────
-
-    /**
-     * Ingests a single file. Reads content and delegates to the pipeline.
-     *
-     * @param file      path to the file
-     * @param chunkSize chunk size in characters (used for title extraction threshold)
-     * @return ingestion result
-     */
-    public IngestionResult ingest(Path file, int chunkSize) {
-        try {
-            String content = Files.readString(file);
-            if (content.isBlank()) {
-                return IngestionResult.single(file.toString(), 0);
-            }
-
-            String id = file.getFileName().toString();
-            return pipeline.ingest(id, content);
-        } catch (Exception e) {
-            log.error("Failed to ingest file '{}': {}", file, e.getMessage());
-            return IngestionResult.chunked(file.toString(), 0,
-                    List.of(file.toString()), 0);
-        }
-    }
-
-    /**
-     * Discovers and ingests files from a directory.
-     *
-     * @param rootDir     root directory to scan
-     * @param filePattern glob pattern (e.g., {@code "**\/*.md"})
-     * @param chunkSize   chunk size in characters
-     * @param chunkOverlap overlap between chunks
-     * @param skipDirs    directories to skip (e.g., {@code ".git,.idea"})
-     * @return list of ingestion results (one per file)
-     */
-    public List<IngestionResult> ingest(Path rootDir, String filePattern,
-                                         int chunkSize, int chunkOverlap, String skipDirs) {
-        return ingest(rootDir, filePattern, chunkSize, chunkOverlap, skipDirs, null);
-    }
-
-    /**
-     * Discovers and ingests files from a directory with progress reporting.
-     */
-    public List<IngestionResult> ingest(Path rootDir, String filePattern,
-                                         int chunkSize, int chunkOverlap, String skipDirs,
-                                         IngestionProgress progress) {
-        return ingest(rootDir, filePattern, chunkSize, chunkOverlap, skipDirs,
-                progress, 4, 3, 2000);
-    }
-
-    /**
-     * Discovers and ingests files from a directory with full configuration.
-     * Uses virtual threads for parallelism and retry with exponential backoff.
-     */
-    public List<IngestionResult> ingest(Path rootDir, String filePattern,
-                                         int chunkSize, int chunkOverlap, String skipDirs,
-                                         IngestionProgress progress,
-                                         int parallelism, int maxRetries, int retryDelayMs) {
-        var discovery = FileDiscoveryService.builder()
-                .rootDirectory(rootDir)
-                .filePattern(filePattern)
-                .chunkSize(chunkSize)
-                .chunkOverlap(chunkOverlap)
-                .skipDirs(skipDirs.split(","))
-                .build();
-        List<Path> files;
-        try {
-            files = discovery.discover();
-        } catch (IOException e) {
-            throw new UncheckedIOException("Failed to discover files in " + rootDir, e);
-        }
-
-        int totalFiles = files.size();
-        log.info("[Ingestion] Discovered {} files in {} (pattern: {}, parallelism: {})",
-                totalFiles, rootDir, filePattern, parallelism);
-
-        // Semaphore bounds concurrency — ConcurrentTasks launches all tasks,
-        // but only `parallelism` file ingestions run at a time
-        var semaphore = new Semaphore(parallelism);
-        var completedCount = new AtomicInteger(0);
-        List<ConcurrentTasks.LabeledTask<IngestionResult>> tasks = new ArrayList<>(totalFiles);
-        for (int fi = 0; fi < files.size(); fi++) {
-            Path file = files.get(fi);
-            final int fileIndex = fi + 1; // 1-based for display
-            String relativePath = rootDir.relativize(file).toString().replace('\\', '/');
-            tasks.add(new ConcurrentTasks.LabeledTask<>(relativePath, () -> {
-                semaphore.acquire();
-                try {
-                    return ingestFileWithRetry(file, rootDir, chunkSize, maxRetries, retryDelayMs,
-                            completedCount, totalFiles, progress, fileIndex);
-                } finally {
-                    semaphore.release();
-                }
-            }));
-        }
-
-        // Execute via ConcurrentTasks
-        Duration timeout = Duration.ofMinutes(Math.max(totalFiles * 2L, 30));
-        ConcurrentTasks.PartialResult<IngestionResult> partial;
-        try {
-            partial = ConcurrentTasks.forkJoinPartial(tasks, timeout);
-        } catch (InterruptedException e) {
-            Thread.currentThread().interrupt();
-            log.warn("Ingestion interrupted");
-            return List.of();
-        }
-
-        // Collect results
-        var results = new ArrayList<IngestionResult>(totalFiles);
-        for (var entry : partial.successes()) {
-            results.add(entry.result());
-        }
-        for (String timedOut : partial.timedOut()) {
-            log.warn("[Ingestion] Timed out: {}", timedOut);
-            if (progress != null) {
-                progress.onFile(completedCount.incrementAndGet(), totalFiles,
-                        timedOut, 0, -1, "Timed out");
-            }
-            results.add(IngestionResult.chunked(timedOut, 0, List.of(timedOut), -1));
-        }
-        for (var failure : partial.failures()) {
-            log.error("[Ingestion] Failed: {} — {}", failure.label(), failure.cause().getMessage());
-            if (progress != null) {
-                progress.onFile(completedCount.incrementAndGet(), totalFiles,
-                        failure.label(), 0, -1, failure.cause().getMessage());
-            }
-            results.add(IngestionResult.chunked(failure.label(), 0,
-                    List.of(failure.label()), -1));
-        }
-
-        return results;
-    }
-
-    /**
-     * Ingests a single file with retry logic (exponential backoff).
-     */
-    private IngestionResult ingestFileWithRetry(Path file, Path rootDir, int chunkSize,
-                                                 int maxRetries, int retryDelayMs,
-                                                 AtomicInteger completedCount, int totalFiles,
-                                                 IngestionProgress progress, int fileIndex) {
-        String relativePath = rootDir.relativize(file).toString().replace('\\', '/');
-        long fileStart = System.currentTimeMillis();
-
-        if (progress != null) {
-            progress.onFileStart(fileIndex, totalFiles, relativePath);
-        }
-
-        for (int attempt = 1; attempt <= maxRetries; attempt++) {
-            try {
-                // Check file size to decide strategy:
-                // - Small files (≤ 2× chunkSize bytes): read into memory
-                // - Large files: use streaming pipeline to avoid heap exhaustion
-                long fileSize = Files.size(file);
-                IngestionResult result;
-
-                if (fileSize <= chunkSize * 2L) {
-                    // Small file — safe to read fully into memory
-                    String content = Files.readString(file);
-                    if (content.isBlank()) {
-                        int idx = completedCount.incrementAndGet();
-                        if (progress != null) {
-                            progress.onFile(idx, totalFiles, relativePath, 0,
-                                    System.currentTimeMillis() - fileStart, null);
-                        }
-                        return IngestionResult.single(relativePath, 0);
-                    }
-                    result = pipeline.ingest(relativePath, content);
-                } else {
-                    // Large file — stream chunk-by-chunk (bounded memory)
-                    result = pipeline.ingest(file, relativePath);
-                }
-
-                long elapsed = System.currentTimeMillis() - fileStart;
-                int idx = completedCount.incrementAndGet();
-                log.info("  [{}] {} chunks, {}ms", relativePath, result.chunksStored(), elapsed);
-                if (progress != null) {
-                    progress.onFile(idx, totalFiles, relativePath,
-                            result.chunksStored(), elapsed, null);
-                }
-                return result;
-
-            } catch (Exception e) {
-                if (attempt < maxRetries) {
-                    long delay = (long) retryDelayMs * (1L << (attempt - 1));
-                    log.warn("  [{}] attempt {}/{} failed: {} — retrying in {}ms",
-                            relativePath, attempt, maxRetries, e.getMessage(), delay);
-                    try {
-                        Thread.sleep(delay);
-                    } catch (InterruptedException ie) {
-                        Thread.currentThread().interrupt();
-                        break;
-                    }
-                } else {
-                    long elapsed = System.currentTimeMillis() - fileStart;
-                    int idx = completedCount.incrementAndGet();
-                    log.error("  [{}] all {} attempts failed: {}",
-                            relativePath, maxRetries, e.getMessage());
-                    if (progress != null) {
-                        progress.onFile(idx, totalFiles, relativePath, 0, elapsed, e.getMessage());
-                    }
-                    return IngestionResult.chunked(relativePath, 0,
-                            List.of(relativePath), elapsed);
-                }
-            }
-        }
-
-        // Safety net
-        long elapsed = System.currentTimeMillis() - fileStart;
-        return IngestionResult.chunked(relativePath, 0,
-                List.of(relativePath), elapsed);
-    }
-
-    /**
-     * Progress callback for directory ingestion.
-     */
-    public interface IngestionProgress {
-
-        /** Called when a file starts processing (before embedding). */
-        default void onFileStart(int fileIndex, int totalFiles, String relativePath) {}
-
-        /** Called when a file finishes processing (success or failure). */
-        void onFile(int fileIndex, int totalFiles, String relativePath,
-                    int chunks, long elapsedMs, String error);
-    }
-
-    // ─────────────── Count ───────────────
-
-    /**
-     * Returns the total number of indexed documents/memories.
-     */
-    public int count() {
-        if (mode == SpectorMode.MEMORY && memory != null) {
-            return memory.totalMemories();
-        }
-        return engine.documentCount();
-    }
-}
diff --git a/spector-runtime/src/main/java/com/spectrayan/spector/runtime/SearchHandler.java b/spector-runtime/src/main/java/com/spectrayan/spector/runtime/SearchHandler.java
deleted file mode 100644
index c399e1c..0000000
--- a/spector-runtime/src/main/java/com/spectrayan/spector/runtime/SearchHandler.java
+++ /dev/null
@@ -1,96 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.runtime;
-
-import java.util.Arrays;
-import java.util.List;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import com.spectrayan.spector.config.SpectorMode;
-import com.spectrayan.spector.engine.SpectorEngine;
-import com.spectrayan.spector.index.ScoredResult;
-import com.spectrayan.spector.memory.CognitiveResult;
-import com.spectrayan.spector.memory.RecallOptions;
-import com.spectrayan.spector.memory.SpectorMemory;
-import com.spectrayan.spector.query.SearchResponse;
-
-/**
- * Mode-aware search service.
- *
- * <p>Routes search queries to the engine or cognitive memory based on
- * the global {@link SpectorMode}. Produces unified {@link SpectorResult}
- * objects regardless of the underlying source.</p>
- *
- * <p>Obtained via {@code runtime.search()}. Not instantiated directly.</p>
- */
-public final class SearchHandler {
-
-    private static final Logger log = LoggerFactory.getLogger(SearchHandler.class);
-
-    private final SpectorEngine engine;
-    private final SpectorMemory memory;  // nullable
-    private final SpectorMode mode;
-
-    SearchHandler(SpectorEngine engine, SpectorMemory memory, SpectorMode mode) {
-        this.engine = engine;
-        this.memory = memory;
-        this.mode = mode;
-    }
-
-    /**
-     * Executes a mode-aware search.
-     *
-     * <p>In SEARCH mode, performs hybrid (BM25 + vector) search via the engine.
-     * In MEMORY mode, queries cognitive memory with decay and importance scoring.</p>
-     *
-     * @param text query text
-     * @param topK maximum results to return
-     * @return list of unified results
-     */
-    public List<SpectorResult> query(String text, int topK) {
-        if (mode == SpectorMode.MEMORY && memory != null) {
-            return queryMemory(text, topK);
-        }
-        return queryEngine(text, topK);
-    }
-
-    /**
-     * Searches the engine directly, bypassing mode routing.
-     */
-    public SearchResponse queryEngine(String text, int topK, boolean raw) {
-        return engine.search(text, topK);
-    }
-
-    private List<SpectorResult> queryEngine(String text, int topK) {
-        SearchResponse response = engine.search(text, topK);
-        return Arrays.stream(response.results())
-                .map(sr -> SpectorResult.fromSearch(sr.id(), "", sr.score(), sr.score()))
-                .toList();
-    }
-
-    private List<SpectorResult> queryMemory(String text, int topK) {
-        var options = RecallOptions.builder().topK(topK).build();
-        List<CognitiveResult> results = memory.recall(text, options);
-        return results.stream()
-                .map(r -> SpectorResult.fromMemory(
-                        r.id(), r.text(), r.score(),
-                        r.importance(), r.ageDays(),
-                        r.valence(), r.synapticTags(), r.memoryType()))
-                .toList();
-    }
-}
diff --git a/spector-runtime/src/main/java/com/spectrayan/spector/runtime/SpectorResult.java b/spector-runtime/src/main/java/com/spectrayan/spector/runtime/SpectorResult.java
deleted file mode 100644
index 312d30e..0000000
--- a/spector-runtime/src/main/java/com/spectrayan/spector/runtime/SpectorResult.java
+++ /dev/null
@@ -1,65 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.runtime;
-
-import com.spectrayan.spector.config.SpectorMode;
-import com.spectrayan.spector.memory.MemoryType;
-
-/**
- * Product-level result type for mode-aware queries.
- *
- * <p>Provides a unified view across both search mode and memory mode results.
- * In search mode, only search-specific fields are populated. In memory mode,
- * additional cognitive metadata (importance, age, valence) is included.</p>
- *
- * @param id              document or memory ID
- * @param text            text content
- * @param score           composite relevance score (0.0–1.0)
- * @param rawSimilarity   raw vector similarity (search-mode only, null in memory mode)
- * @param importance      memory importance score (memory-mode only, null in search mode)
- * @param ageDays         age of the memory in days (memory-mode only, null in search mode)
- * @param valence         emotional valence (-128 to 127, memory-mode only, null in search mode)
- * @param mode            which mode produced this result
- * @param tags            associated tags (memory mode, empty array in search mode)
- * @param memoryType      memory tier (memory-mode only, null in search mode)
- */
-public record SpectorResult(
-        String id,
-        String text,
-        float score,
-        Float rawSimilarity,
-        Float importance,
-        Float ageDays,
-        Byte valence,
-        SpectorMode mode,
-        String[] tags,
-        MemoryType memoryType
-) {
-
-    /** Creates a search-mode result. */
-    public static SpectorResult fromSearch(String id, String text, float score, float similarity) {
-        return new SpectorResult(id, text, score, similarity, null, null, null,
-                SpectorMode.SEARCH, new String[0], null);
-    }
-
-    /** Creates a memory-mode result. */
-    public static SpectorResult fromMemory(String id, String text, float score,
-                                            float importance, float ageDays,
-                                            byte valence, String[] tags, MemoryType memoryType) {
-        return new SpectorResult(id, text, score, null, importance, ageDays, valence,
-                SpectorMode.MEMORY, tags, memoryType);
-    }
-}
diff --git a/spector-runtime/src/main/java/com/spectrayan/spector/runtime/SpectorRuntime.java b/spector-runtime/src/main/java/com/spectrayan/spector/runtime/SpectorRuntime.java
deleted file mode 100644
index 013d3bc..0000000
--- a/spector-runtime/src/main/java/com/spectrayan/spector/runtime/SpectorRuntime.java
+++ /dev/null
@@ -1,218 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.runtime;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import com.spectrayan.spector.config.SpectorConfigFactory;
-import com.spectrayan.spector.config.SpectorMode;
-import com.spectrayan.spector.config.SpectorProperties;
-import com.spectrayan.spector.config.PersistenceMode;
-import com.spectrayan.spector.embed.EmbeddingProvider;
-import com.spectrayan.spector.config.SpectorConfig;
-import com.spectrayan.spector.engine.DefaultSpectorEngine;
-import com.spectrayan.spector.engine.SpectorEngine;
-import com.spectrayan.spector.memory.DefaultSpectorMemory;
-import com.spectrayan.spector.memory.MemoryPersistenceMode;
-import com.spectrayan.spector.memory.SpectorMemory;
-
-/**
- * Composition root for a Spector instance.
- *
- * <p><strong>This is the single entry point for all Spector consumers.</strong>
- * It creates, wires, and exposes the subsystem services. No business logic
- * lives here — each service owns its domain.</p>
- *
- * <h3>Services</h3>
- * <ul>
- *   <li>{@link #search()} — mode-aware search (engine or memory)</li>
- *   <li>{@link #ingestion()} — mode-aware ingestion (text, file, directory)</li>
- * </ul>
- *
- * <h3>Direct Subsystem Access</h3>
- * <ul>
- *   <li>{@link #engine()} — vector search engine (always available)</li>
- *   <li>{@link #memory()} — cognitive memory (null if not enabled)</li>
- * </ul>
- *
- * <h3>Usage</h3>
- * <pre>{@code
- *   try (SpectorRuntime runtime = SpectorRuntime.from(props, embedder)) {
- *       runtime.ingestion().ingest("doc1", "some text");
- *       runtime.ingestion().ingest(Path.of("/docs"), "**\/*.md", 800, 100, ".git");
- *       var results = runtime.search().query("something", 10);
- *   }
- * }</pre>
- */
-public final class SpectorRuntime implements AutoCloseable {
-
-    private static final Logger log = LoggerFactory.getLogger(SpectorRuntime.class);
-
-    private final SpectorEngine engine;
-    private final SpectorMemory memory;  // nullable
-    private final SpectorProperties properties;
-    private final SpectorMode mode;
-
-    // Lazily created services
-    private volatile SearchHandler searchService;
-    private volatile IngestionHandler ingestionService;
-
-    private SpectorRuntime(SpectorEngine engine, SpectorMemory memory,
-                           SpectorProperties properties, SpectorMode mode) {
-        this.engine = engine;
-        this.memory = memory;
-        this.properties = properties;
-        this.mode = mode;
-    }
-
-    // ─────────────── Factory ───────────────
-
-    /**
-     * Creates a runtime from configuration and embedding provider.
-     *
-     * @param props    hierarchical configuration
-     * @param embedder embedding provider (shared by engine and memory)
-     * @return initialized runtime (caller must close)
-     */
-    public static SpectorRuntime from(SpectorProperties props, EmbeddingProvider embedder) {
-        SpectorMode mode = SpectorConfigFactory.mode(props);
-
-        // ── Read memory config early (needed to configure engine in MEMORY mode) ──
-        var memoryConfig = SpectorConfigFactory.memoryDefaults(props);
-        boolean memoryEnabled = memoryConfig.enabled() || mode == SpectorMode.MEMORY;
-
-        // ── Engine ──
-        SpectorConfig engineConfig = SpectorConfig.from(props);
-        // In MEMORY mode the engine provides the shared HNSW index for semantic
-        // recall. Use DISK persistence so the HNSW graph + VectorStore survive
-        // restarts. Point engine data to .spector/index (sibling of memory path).
-        // Use the memory config's capacity so the HNSW can hold all semantic vectors.
-        if (mode == SpectorMode.MEMORY && memoryEnabled) {
-            java.nio.file.Path indexDir = memoryConfig.persistencePath()
-                    .resolveSibling("index");
-            engineConfig = engineConfig
-                    .withPersistence(PersistenceMode.DISK, indexDir)
-                    .withCapacity(memoryConfig.capacity());
-        }
-        SpectorEngine engine = new DefaultSpectorEngine(engineConfig, embedder);
-        log.info("[Runtime] Engine: dims={}, index={}, persistence={}, dataDir={}, mode={}",
-                engineConfig.dimensions(), engineConfig.indexType(),
-                engineConfig.persistenceMode(), engineConfig.dataDirectory(),
-                mode);
-
-        // ── Memory (opt-in or auto-enabled in MEMORY mode) ──
-        SpectorMemory memory = null;
-
-        if (memoryEnabled) {
-            var memoryBuilder = DefaultSpectorMemory.builder()
-                    .dimensions(engineConfig.dimensions())
-                    .embeddingProvider(embedder)
-                    .persistenceMode(MemoryPersistenceMode.valueOf(memoryConfig.persistenceMode()))
-                    .persistence(memoryConfig.persistencePath())
-                    .semanticCapacity(memoryConfig.capacity());
-
-            if (mode == SpectorMode.MEMORY) {
-                memoryBuilder.semanticIndex(engine.index());
-                memoryBuilder.vectorStore(engine.vectorStore());
-            }
-
-            memory = memoryBuilder.build();
-            log.info("[Runtime] Memory: persistence={}, path={}",
-                    memoryConfig.persistenceMode(), memoryConfig.persistencePath());
-        }
-
-        return new SpectorRuntime(engine, memory, props, mode);
-    }
-
-    /**
-     * Creates a runtime with engine only (no memory).
-     */
-    public static SpectorRuntime engineOnly(SpectorEngine engine, SpectorProperties props) {
-        return new SpectorRuntime(engine, null, props, SpectorMode.SEARCH);
-    }
-
-    // ─────────────── Service Accessors ───────────────
-
-    /** Returns the mode-aware search service. */
-    public SearchHandler search() {
-        if (searchService == null) {
-            searchService = new SearchHandler(engine, memory, mode);
-        }
-        return searchService;
-    }
-
-    /** Returns the mode-aware ingestion service. */
-    public IngestionHandler ingestion() {
-        if (ingestionService == null) {
-            var ingestionConfig = SpectorConfigFactory.ingestionDefaults(properties);
-
-            // Select target based on mode
-            com.spectrayan.spector.ingestion.IngestionTarget target =
-                    (mode == SpectorMode.MEMORY && memory != null)
-                    ? memory.target()
-                    : engine.target();
-
-            // Build unified pipeline from config
-            var pipeline = com.spectrayan.spector.ingestion.IngestionPipeline.builder()
-                    .target(target)
-                    .embeddingProvider(engine.embeddingProvider())
-                    .chunking(new com.spectrayan.spector.commons.TextChunker(
-                            ingestionConfig.chunkSize(), ingestionConfig.chunkOverlap()))
-                    .chunkThreshold(ingestionConfig.chunkSize())
-                    .build();
-
-            ingestionService = new IngestionHandler(pipeline, engine, memory, mode);
-        }
-        return ingestionService;
-    }
-
-    // ─────────────── Direct Subsystem Access ───────────────
-
-    /** Returns the search engine (never null). */
-    public SpectorEngine engine() { return engine; }
-
-    /** Returns the cognitive memory, or {@code null} if not enabled. */
-    public SpectorMemory memory() { return memory; }
-
-    /** Returns {@code true} if cognitive memory is available. */
-    public boolean hasMemory() { return memory != null; }
-
-    /** Returns the configuration properties. */
-    public SpectorProperties properties() { return properties; }
-
-    /** Returns the global operating mode. */
-    public SpectorMode mode() { return mode; }
-
-    // ─────────────── Lifecycle ───────────────
-
-    @Override
-    public void close() {
-        try {
-            engine.close();
-        } catch (Exception e) {
-            log.error("[Runtime] Error closing engine: {}", e.getMessage(), e);
-        }
-        if (memory != null) {
-            try {
-                memory.close();
-            } catch (Exception e) {
-                log.error("[Runtime] Error closing memory: {}", e.getMessage(), e);
-            }
-        }
-        log.info("[Runtime] Shutdown complete (mode={})", mode);
-    }
-}
diff --git a/spector-server/pom.xml b/spector-server/pom.xml
new file mode 100644
index 0000000..d12d99b
--- /dev/null
+++ b/spector-server/pom.xml
@@ -0,0 +1,66 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <parent>
+        <groupId>com.spectrayan</groupId>
+        <artifactId>spector-search</artifactId>
+        <version>0.1.0-SNAPSHOT</version>
+    </parent>
+
+    <artifactId>spector-server</artifactId>
+    <name>Spector Server</name>
+    <description>REST API server for Spector Search engine.</description>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.spectrayan</groupId>
+            <artifactId>spector-engine</artifactId>
+        </dependency>
+
+        <!-- Javalin REST framework -->
+        <dependency>
+            <groupId>io.javalin</groupId>
+            <artifactId>javalin</artifactId>
+        </dependency>
+
+        <!-- JSON serialization -->
+        <dependency>
+            <groupId>com.fasterxml.jackson.core</groupId>
+            <artifactId>jackson-databind</artifactId>
+        </dependency>
+
+        <!-- Logging runtime -->
+        <dependency>
+            <groupId>ch.qos.logback</groupId>
+            <artifactId>logback-classic</artifactId>
+            <scope>runtime</scope>
+        </dependency>
+
+        <!-- Test: Javalin test tools -->
+        <dependency>
+            <groupId>io.javalin</groupId>
+            <artifactId>javalin-testtools</artifactId>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-jar-plugin</artifactId>
+                <configuration>
+                    <archive>
+                        <manifest>
+                            <mainClass>com.spectrayan.spector.server.SpectorServer</mainClass>
+                        </manifest>
+                    </archive>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+
+</project>
diff --git a/spector-server/src/main/java/com/spectrayan/spector/server/RagHandler.java b/spector-server/src/main/java/com/spectrayan/spector/server/RagHandler.java
new file mode 100644
index 0000000..23ce5eb
--- /dev/null
+++ b/spector-server/src/main/java/com/spectrayan/spector/server/RagHandler.java
@@ -0,0 +1,215 @@
+package com.spectrayan.spector.server;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.spectrayan.spector.commons.TextChunk;
+import com.spectrayan.spector.embed.EmbeddingException;
+import com.spectrayan.spector.embed.ParallelEmbeddingPipeline;
+import com.spectrayan.spector.engine.SpectorEngine;
+import com.spectrayan.spector.engine.rag.ContextBuilder;
+import com.spectrayan.spector.engine.rag.ContextResult;
+import com.spectrayan.spector.engine.rag.ScoredChunk;
+import com.spectrayan.spector.index.ScoredResult;
+import com.spectrayan.spector.query.SearchQuery;
+import com.spectrayan.spector.query.SearchResponse;
+
+/**
+ * Handler for the RAG (Retrieval-Augmented Generation) endpoint.
+ *
+ * <p>Wires together the existing components:</p>
+ * <ul>
+ *   <li>{@link SpectorEngine} — for vector/hybrid search</li>
+ *   <li>{@link ParallelEmbeddingPipeline} — for query embedding</li>
+ *   <li>{@link ContextBuilder} — for assembling context within token limits</li>
+ * </ul>
+ *
+ * <p>Validates: Requirements 9.1, 9.2, 9.3, 9.4, 9.5</p>
+ */
+public class RagHandler {
+
+    private static final Logger log = LoggerFactory.getLogger(RagHandler.class);
+
+    private static final int MIN_QUERY_LENGTH = 1;
+    private static final int MAX_QUERY_LENGTH = 2000;
+    private static final int DEFAULT_TOP_K = 5;
+    private static final int MIN_TOP_K = 1;
+    private static final int MAX_TOP_K = 100;
+    private static final int DEFAULT_TOKEN_LIMIT = 4096;
+    private static final int MIN_TOKEN_LIMIT = 1;
+    private static final int MAX_TOKEN_LIMIT = 8192;
+
+    private final SpectorEngine engine;
+    private final ContextBuilder contextBuilder;
+
+    /**
+     * Creates a RAG handler backed by the given engine.
+     *
+     * @param engine the Spector engine instance
+     */
+    public RagHandler(SpectorEngine engine) {
+        this.engine = engine;
+        this.contextBuilder = new ContextBuilder();
+    }
+
+    /**
+     * Processes a RAG request and returns the assembled context with attributions.
+     *
+     * @param request the RAG request
+     * @return a result containing either a successful response or an error
+     */
+    public RagResult handle(RagRequest request) {
+        // Validate query (Requirement 9.5)
+        if (request.query == null || request.query.isBlank()) {
+            return RagResult.error(400, "A non-empty query is required");
+        }
+        if (request.query.length() > MAX_QUERY_LENGTH) {
+            return RagResult.error(400,
+                    "Query must not exceed " + MAX_QUERY_LENGTH + " characters");
+        }
+
+        // Resolve parameters with defaults (Requirement 9.2)
+        int topK = resolveTopK(request.topK);
+        int tokenLimit = resolveTokenLimit(request.tokenLimit);
+        String searchMode = resolveSearchMode(request.searchMode);
+
+        // Check embedding provider availability (Requirement 9.4)
+        if (!engine.hasEmbeddingProvider()) {
+            return RagResult.error(503, "Embedding service is unavailable");
+        }
+
+        // Embed the query
+        float[] queryVector;
+        try {
+            queryVector = engine.embeddingProvider().embed(request.query).vector();
+        } catch (EmbeddingException e) {
+            log.warn("Embedding failed for RAG query: {}", e.getMessage());
+            return RagResult.error(503, "Embedding service is unavailable");
+        } catch (Exception e) {
+            log.error("Unexpected error during query embedding", e);
+            return RagResult.error(503, "Embedding service is unavailable");
+        }
+
+        // Search using the engine
+        SearchResponse searchResponse;
+        try {
+            SearchQuery query = buildSearchQuery(request.query, queryVector, topK, searchMode);
+            searchResponse = engine.search(query);
+        } catch (Exception e) {
+            log.error("Search failed for RAG query", e);
+            return RagResult.error(500, "Search failed: " + e.getMessage());
+        }
+
+        // If no results, return empty context (Requirement 9.3)
+        if (searchResponse.results() == null || searchResponse.results().length == 0) {
+            RagResponse response = new RagResponse(
+                    "",
+                    List.of(),
+                    "No matching documents were found"
+            );
+            return RagResult.success(response);
+        }
+
+        // Convert search results to ScoredChunks for context building
+        List<ScoredChunk> scoredChunks = buildScoredChunks(searchResponse.results());
+
+        // Build context within token limit (Requirement 9.1)
+        ContextResult contextResult = contextBuilder.build(scoredChunks, tokenLimit);
+
+        // Handle empty context after filtering
+        if (contextResult.isEmpty()) {
+            RagResponse response = new RagResponse(
+                    "",
+                    List.of(),
+                    "No matching documents were found"
+            );
+            return RagResult.success(response);
+        }
+
+        // Map attributions to response format
+        List<RagResponse.Attribution> attributions = contextResult.attributions().stream()
+                .map(attr -> new RagResponse.Attribution(attr.documentId(), attr.chunkOffset()))
+                .toList();
+
+        RagResponse response = new RagResponse(
+                contextResult.contextText(),
+                attributions,
+                null
+        );
+        return RagResult.success(response);
+    }
+
+    private int resolveTopK(Integer topK) {
+        if (topK == null) return DEFAULT_TOP_K;
+        return Math.max(MIN_TOP_K, Math.min(MAX_TOP_K, topK));
+    }
+
+    private int resolveTokenLimit(Integer tokenLimit) {
+        if (tokenLimit == null) return DEFAULT_TOKEN_LIMIT;
+        return Math.max(MIN_TOKEN_LIMIT, Math.min(MAX_TOKEN_LIMIT, tokenLimit));
+    }
+
+    private String resolveSearchMode(String mode) {
+        if (mode == null || mode.isBlank()) return "vector";
+        String normalized = mode.toLowerCase().trim();
+        if ("hybrid".equals(normalized)) return "hybrid";
+        return "vector";
+    }
+
+    private SearchQuery buildSearchQuery(String text, float[] vector, int topK, String searchMode) {
+        if ("hybrid".equals(searchMode)) {
+            return SearchQuery.hybrid(text, vector, topK);
+        }
+        return SearchQuery.vector(vector, topK);
+    }
+
+    /**
+     * Converts search results into ScoredChunks for context assembly.
+     *
+     * <p>Each result is treated as a chunk whose content is retrieved from the
+     * engine's document store. If the document content cannot be found, the
+     * result is skipped.</p>
+     */
+    private List<ScoredChunk> buildScoredChunks(ScoredResult[] results) {
+        List<ScoredChunk> chunks = new ArrayList<>(results.length);
+        for (ScoredResult result : results) {
+            String id = result.id();
+            // Retrieve document content from the document store
+            var document = engine.documentStore().get(id);
+            if (document == null) {
+                continue;
+            }
+            String content = document.content();
+            if (content == null || content.isBlank()) {
+                continue;
+            }
+
+            // Create a TextChunk from the document content
+            int tokenCount = com.spectrayan.spector.commons.WordTokenizer.countTokens(content);
+            TextChunk textChunk = new TextChunk(content, tokenCount, 0, content.length(), id);
+            chunks.add(new ScoredChunk(textChunk, result.score()));
+        }
+        return chunks;
+    }
+
+    /**
+     * Encapsulates either a successful RAG response or an error.
+     */
+    public record RagResult(int statusCode, RagResponse response, String errorMessage) {
+
+        public static RagResult success(RagResponse response) {
+            return new RagResult(200, response, null);
+        }
+
+        public static RagResult error(int statusCode, String message) {
+            return new RagResult(statusCode, null, message);
+        }
+
+        public boolean isSuccess() {
+            return errorMessage == null;
+        }
+    }
+}
diff --git a/spector-server/src/main/java/com/spectrayan/spector/server/RagRequest.java b/spector-server/src/main/java/com/spectrayan/spector/server/RagRequest.java
new file mode 100644
index 0000000..f5fc2bd
--- /dev/null
+++ b/spector-server/src/main/java/com/spectrayan/spector/server/RagRequest.java
@@ -0,0 +1,21 @@
+package com.spectrayan.spector.server;
+
+/**
+ * Request DTO for the RAG endpoint ({@code POST /api/v1/rag}).
+ *
+ * <p>Accepts a query string plus optional retrieval parameters.</p>
+ */
+public class RagRequest {
+
+    /** The query text (1–2000 characters, required). */
+    public String query;
+
+    /** Maximum number of chunks to retrieve (1–100, default 5). */
+    public Integer topK;
+
+    /** Maximum token limit for assembled context (1–8192, default 4096). */
+    public Integer tokenLimit;
+
+    /** Search mode: "vector" or "hybrid" (default "vector"). */
+    public String searchMode;
+}
diff --git a/spector-server/src/main/java/com/spectrayan/spector/server/RagResponse.java b/spector-server/src/main/java/com/spectrayan/spector/server/RagResponse.java
new file mode 100644
index 0000000..1c453b0
--- /dev/null
+++ b/spector-server/src/main/java/com/spectrayan/spector/server/RagResponse.java
@@ -0,0 +1,41 @@
+package com.spectrayan.spector.server;
+
+import java.util.List;
+
+/**
+ * Response DTO for the RAG endpoint ({@code POST /api/v1/rag}).
+ */
+public class RagResponse {
+
+    /** The assembled context string. Empty when no matches found. */
+    public String context;
+
+    /** Source attributions for each chunk included in the context. */
+    public List<Attribution> attributions;
+
+    /** Message providing additional information (e.g., no matches found). */
+    public String message;
+
+    public RagResponse() {}
+
+    public RagResponse(String context, List<Attribution> attributions, String message) {
+        this.context = context;
+        this.attributions = attributions;
+        this.message = message;
+    }
+
+    /**
+     * Source attribution entry for a chunk in the assembled context.
+     */
+    public static class Attribution {
+        public String documentId;
+        public int chunkOffset;
+
+        public Attribution() {}
+
+        public Attribution(String documentId, int chunkOffset) {
+            this.documentId = documentId;
+            this.chunkOffset = chunkOffset;
+        }
+    }
+}
diff --git a/spector-server/src/main/java/com/spectrayan/spector/server/SpectorServer.java b/spector-server/src/main/java/com/spectrayan/spector/server/SpectorServer.java
new file mode 100644
index 0000000..1dd0e97
--- /dev/null
+++ b/spector-server/src/main/java/com/spectrayan/spector/server/SpectorServer.java
@@ -0,0 +1,433 @@
+package com.spectrayan.spector.server;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.concurrent.atomic.LongAdder;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.fasterxml.jackson.annotation.JsonInclude;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.SerializationFeature;
+import com.spectrayan.spector.core.SimdCapability;
+import com.spectrayan.spector.engine.SpectorConfig;
+import com.spectrayan.spector.engine.SpectorEngine;
+import com.spectrayan.spector.query.SearchQuery;
+import com.spectrayan.spector.query.SearchResponse;
+
+import io.javalin.Javalin;
+import io.javalin.http.Context;
+
+/**
+ * REST API server for the Spector Search engine.
+ *
+ * <p>Built on Javalin, a lightweight REST framework that uses virtual threads
+ * for request handling. Provides endpoints for document ingestion, search,
+ * deletion, bulk operations, and metrics.</p>
+ *
+ * <h3>Endpoints</h3>
+ * <ul>
+ *   <li>{@code GET  /health}              — Health check</li>
+ *   <li>{@code GET  /api/v1/status}       — Engine status &amp; SIMD info</li>
+ *   <li>{@code POST /api/v1/ingest}       — Ingest a document (vector required)</li>
+ *   <li>{@code POST /api/v1/ingest/auto}  — Ingest with auto-embedding (text only)</li>
+ *   <li>{@code POST /api/v1/ingest/bulk}  — Bulk ingest multiple documents</li>
+ *   <li>{@code POST /api/v1/search}       — Search (keyword/vector/hybrid)</li>
+ *   <li>{@code POST /api/v1/rag}          — RAG context retrieval</li>
+ *   <li>{@code DELETE /api/v1/documents/{id}} — Delete a document</li>
+ *   <li>{@code GET  /api/v1/metrics}      — Request metrics</li>
+ * </ul>
+ */
+public class SpectorServer {
+
+    private static final Logger log = LoggerFactory.getLogger(SpectorServer.class);
+    private static final ObjectMapper MAPPER = new ObjectMapper()
+            .setSerializationInclusion(JsonInclude.Include.NON_NULL)
+            .disable(SerializationFeature.FAIL_ON_EMPTY_BEANS);
+
+    private final SpectorEngine engine;
+    private final Javalin app;
+    private final int port;
+    private final String apiKey; // nullable — when set, requires X-API-Key header
+    private final RagHandler ragHandler;
+
+    // ── Metrics ──
+    private final LongAdder totalRequests = new LongAdder();
+    private final LongAdder totalSearches = new LongAdder();
+    private final LongAdder totalIngestions = new LongAdder();
+    private final LongAdder totalErrors = new LongAdder();
+    private final AtomicLong startTime = new AtomicLong();
+
+    /**
+     * Creates a server with the given engine, port, and optional API key.
+     */
+    public SpectorServer(SpectorEngine engine, int port, String apiKey) {
+        this.engine = engine;
+        this.port = port;
+        this.apiKey = apiKey;
+        this.ragHandler = new RagHandler(engine);
+
+        this.app = Javalin.create(config -> {
+            config.useVirtualThreads = true;
+            config.showJavalinBanner = false;
+
+            // ── CORS support ──
+            config.bundledPlugins.enableCors(cors -> {
+                cors.addRule(rule -> {
+                    rule.anyHost();
+                    rule.allowCredentials = false;
+                });
+            });
+        });
+
+        registerRoutes();
+    }
+
+    /**
+     * Creates a server with the given engine and port (no API key).
+     */
+    public SpectorServer(SpectorEngine engine, int port) {
+        this(engine, port, null);
+    }
+
+    /** Creates a server with default config on port 7070. */
+    public SpectorServer() {
+        this(new SpectorEngine(), 7070, null);
+    }
+
+    /**
+     * Starts the server.
+     */
+    public SpectorServer start() {
+        startTime.set(System.currentTimeMillis());
+        app.start(port);
+        log.info("SpectorServer started on port {} (CORS=enabled, auth={})",
+                port, apiKey != null ? "API-key" : "none");
+        return this;
+    }
+
+    /**
+     * Stops the server and closes the engine.
+     */
+    public void stop() {
+        app.stop();
+        engine.close();
+        log.info("SpectorServer stopped");
+    }
+
+    /** Returns the underlying Javalin app (for testing). */
+    public Javalin app() {
+        return app;
+    }
+
+    // ─────────────── Route Registration ───────────────
+
+    private void registerRoutes() {
+        // ── Authentication (before handler) ──
+        if (apiKey != null && !apiKey.isBlank()) {
+            app.before("/api/*", ctx -> {
+                String provided = ctx.header("X-API-Key");
+                if (!apiKey.equals(provided)) {
+                    ctx.status(401).json(Map.of("error", "Invalid or missing API key"));
+                    ctx.skipRemainingHandlers();
+                }
+            });
+        }
+
+        // ── Request counting (before handler) ──
+        app.before(ctx -> totalRequests.increment());
+
+        // ── Error handlers ──
+        app.exception(IllegalArgumentException.class, (e, ctx) -> {
+            totalErrors.increment();
+            ctx.status(400).json(Map.of("error", e.getMessage()));
+        });
+        app.exception(IllegalStateException.class, (e, ctx) -> {
+            totalErrors.increment();
+            ctx.status(409).json(Map.of("error", e.getMessage()));
+        });
+        app.exception(Exception.class, (e, ctx) -> {
+            totalErrors.increment();
+            log.error("Unhandled exception", e);
+            ctx.status(500).json(Map.of("error", "Internal server error"));
+        });
+
+        // ── Routes ──
+        // Health check
+        app.get("/health", ctx -> ctx.json(Map.of("status", "ok")));
+
+        // Status
+        app.get("/api/v1/status", this::handleStatus);
+
+        // Ingest (with vector)
+        app.post("/api/v1/ingest", this::handleIngest);
+
+        // Ingest with auto-embedding (text only)
+        app.post("/api/v1/ingest/auto", this::handleAutoIngest);
+
+        // Bulk ingest
+        app.post("/api/v1/ingest/bulk", this::handleBulkIngest);
+
+        // Search
+        app.post("/api/v1/search", this::handleSearch);
+
+        // RAG endpoint
+        app.post("/api/v1/rag", this::handleRag);
+
+        // Delete
+        app.delete("/api/v1/documents/{id}", this::handleDelete);
+
+        // Metrics
+        app.get("/api/v1/metrics", this::handleMetrics);
+    }
+
+    // ─────────────── Handlers ───────────────
+
+    private void handleStatus(Context ctx) {
+        var status = Map.of(
+                "engine", "spector-search",
+                "version", "0.1.0-SNAPSHOT",
+                "documents", engine.documentCount(),
+                "dimensions", engine.config().dimensions(),
+                "similarity", engine.config().similarityFunction().name(),
+                "indexType", engine.config().indexType().name(),
+                "gpu", engine.isGpuActive() ? "active" : "inactive",
+                "reranker", engine.isRerankerActive() ? engine.reranker().modelName() : "disabled",
+                "embedding", engine.hasEmbeddingProvider() ? "configured" : "none",
+                "simd", SimdCapability.report()
+        );
+        ctx.json(status);
+    }
+
+    private void handleIngest(Context ctx) throws Exception {
+        var request = MAPPER.readValue(ctx.body(), IngestRequest.class);
+
+        if (request.id == null || request.id.isEmpty()) {
+            ctx.status(400).json(Map.of("error", "id is required"));
+            return;
+        }
+        if (request.content == null || request.content.isEmpty()) {
+            ctx.status(400).json(Map.of("error", "content is required"));
+            return;
+        }
+        if (request.vector == null || request.vector.length == 0) {
+            ctx.status(400).json(Map.of("error", "vector is required (use /api/v1/ingest/auto for auto-embedding)"));
+            return;
+        }
+        if (request.vector.length != engine.config().dimensions()) {
+            ctx.status(400).json(Map.of("error",
+                    "vector dimension mismatch: expected " + engine.config().dimensions()
+                            + ", got " + request.vector.length));
+            return;
+        }
+
+        engine.ingest(request.id, request.title != null ? request.title : "", request.content, request.vector);
+        totalIngestions.increment();
+
+        ctx.status(201).json(Map.of(
+                "id", request.id,
+                "indexed", true
+        ));
+    }
+
+    private void handleAutoIngest(Context ctx) throws Exception {
+        var request = MAPPER.readValue(ctx.body(), AutoIngestRequest.class);
+
+        if (request.id == null || request.id.isEmpty()) {
+            ctx.status(400).json(Map.of("error", "id is required"));
+            return;
+        }
+        if (request.content == null || request.content.isEmpty()) {
+            ctx.status(400).json(Map.of("error", "content is required"));
+            return;
+        }
+        if (!engine.hasEmbeddingProvider()) {
+            ctx.status(409).json(Map.of("error",
+                    "Auto-embed requires an EmbeddingProvider. Configure the engine with an embedding provider."));
+            return;
+        }
+
+        if (request.title != null && !request.title.isEmpty()) {
+            engine.ingest(request.id, request.title, request.content);
+        } else {
+            engine.ingest(request.id, request.content);
+        }
+        totalIngestions.increment();
+
+        ctx.status(201).json(Map.of(
+                "id", request.id,
+                "indexed", true,
+                "autoEmbedded", true
+        ));
+    }
+
+    private void handleBulkIngest(Context ctx) throws Exception {
+        var request = MAPPER.readValue(ctx.body(), BulkIngestRequest.class);
+
+        if (request.documents == null || request.documents.isEmpty()) {
+            ctx.status(400).json(Map.of("error", "documents array is required"));
+            return;
+        }
+
+        int success = 0;
+        int failed = 0;
+        for (var doc : request.documents) {
+            try {
+                if (doc.id == null || doc.content == null) {
+                    failed++;
+                    continue;
+                }
+                if (doc.vector != null && doc.vector.length > 0) {
+                    engine.ingest(doc.id,
+                            doc.title != null ? doc.title : "",
+                            doc.content, doc.vector);
+                } else if (engine.hasEmbeddingProvider()) {
+                    engine.ingest(doc.id, doc.content);
+                } else {
+                    failed++;
+                    continue;
+                }
+                success++;
+            } catch (Exception e) {
+                failed++;
+                log.warn("Bulk ingest failed for doc '{}': {}", doc.id, e.getMessage());
+            }
+        }
+        totalIngestions.add(success);
+
+        ctx.status(201).json(Map.of(
+                "total", request.documents.size(),
+                "success", success,
+                "failed", failed
+        ));
+    }
+
+    private void handleSearch(Context ctx) throws Exception {
+        var request = MAPPER.readValue(ctx.body(), SearchRequest.class);
+
+        if (request.topK <= 0) request.topK = 10;
+
+        SearchQuery query = switch (request.resolvedMode()) {
+            case KEYWORD -> SearchQuery.keyword(request.text, request.topK);
+            case VECTOR -> SearchQuery.vector(request.vector, request.topK);
+            case HYBRID -> SearchQuery.hybrid(request.text, request.vector, request.topK);
+        };
+
+        SearchResponse response = engine.search(query);
+        totalSearches.increment();
+
+        var resultList = Arrays.stream(response.results())
+                .map(r -> Map.of(
+                        "id", (Object) r.id(),
+                        "score", (Object) r.score()
+                ))
+                .toList();
+
+        ctx.json(Map.of(
+                "results", resultList,
+                "totalHits", response.totalHits(),
+                "queryTimeMs", response.queryTimeMs(),
+                "mode", response.mode().name()
+        ));
+    }
+
+    private void handleDelete(Context ctx) {
+        String id = ctx.pathParam("id");
+        boolean deleted = engine.delete(id);
+
+        if (deleted) {
+            ctx.json(Map.of("id", id, "deleted", true));
+        } else {
+            ctx.status(404).json(Map.of("error", "Document not found: " + id));
+        }
+    }
+
+    private void handleRag(Context ctx) throws Exception {
+        var request = MAPPER.readValue(ctx.body(), RagRequest.class);
+        RagHandler.RagResult result = ragHandler.handle(request);
+
+        if (result.isSuccess()) {
+            ctx.json(result.response());
+        } else {
+            ctx.status(result.statusCode()).json(Map.of("error", result.errorMessage()));
+        }
+    }
+
+    private void handleMetrics(Context ctx) {
+        long uptimeMs = System.currentTimeMillis() - startTime.get();
+        ctx.json(Map.of(
+                "uptimeMs", uptimeMs,
+                "totalRequests", totalRequests.sum(),
+                "totalSearches", totalSearches.sum(),
+                "totalIngestions", totalIngestions.sum(),
+                "totalErrors", totalErrors.sum(),
+                "documents", engine.documentCount(),
+                "gpu", engine.isGpuActive(),
+                "reranker", engine.isRerankerActive()
+        ));
+    }
+
+    // ─────────────── Request DTOs ───────────────
+
+    /** Ingest request body. */
+    public static class IngestRequest {
+        public String id;
+        public String title;
+        public String content;
+        public float[] vector;
+    }
+
+    /** Auto-embed ingest request body (no vector needed). */
+    public static class AutoIngestRequest {
+        public String id;
+        public String title;
+        public String content;
+    }
+
+    /** Bulk ingest request body. */
+    public static class BulkIngestRequest {
+        public List<IngestRequest> documents;
+    }
+
+    /** Search request body. */
+    public static class SearchRequest {
+        public String text;
+        public float[] vector;
+        public String mode;  // "KEYWORD", "VECTOR", "HYBRID"
+        public int topK;
+
+        SearchQuery.SearchMode resolvedMode() {
+            if (mode != null) {
+                try {
+                    return SearchQuery.SearchMode.valueOf(mode.toUpperCase());
+                } catch (IllegalArgumentException e) {
+                    // fall through
+                }
+            }
+            // Auto-detect based on what's provided
+            if (text != null && vector != null) return SearchQuery.SearchMode.HYBRID;
+            if (vector != null) return SearchQuery.SearchMode.VECTOR;
+            return SearchQuery.SearchMode.KEYWORD;
+        }
+    }
+
+    // ─────────────── Main ───────────────
+
+    public static void main(String[] args) {
+        int port = args.length > 0 ? Integer.parseInt(args[0]) : 7070;
+        int dims = args.length > 1 ? Integer.parseInt(args[1]) : 384;
+        String apiKey = args.length > 2 ? args[2] : null;
+
+        var config = SpectorConfig.DEFAULT.withDimensions(dims);
+        var engine = new SpectorEngine(config);
+        var server = new SpectorServer(engine, port, apiKey);
+
+        Runtime.getRuntime().addShutdownHook(new Thread(server::stop));
+        server.start();
+
+        log.info("Spector Search ready — http://localhost:{}/health", port);
+    }
+}
diff --git a/spector-server/src/main/java/com/spectrayan/spector/server/package-info.java b/spector-server/src/main/java/com/spectrayan/spector/server/package-info.java
new file mode 100644
index 0000000..6486f01
--- /dev/null
+++ b/spector-server/src/main/java/com/spectrayan/spector/server/package-info.java
@@ -0,0 +1,7 @@
+/**
+ * Spector Server — REST API server for the Spector Search engine.
+ *
+ * <p>Exposes search and index management endpoints via Javalin,
+ * backed by a virtual-thread executor for massive concurrency.</p>
+ */
+package com.spectrayan.spector.server;
diff --git a/spector-node/src/main/resources/logback.xml b/spector-server/src/main/resources/logback.xml
similarity index 100%
rename from spector-node/src/main/resources/logback.xml
rename to spector-server/src/main/resources/logback.xml
diff --git a/spector-server/src/test/java/com/spectrayan/spector/server/RagHandlerTest.java b/spector-server/src/test/java/com/spectrayan/spector/server/RagHandlerTest.java
new file mode 100644
index 0000000..35c8454
--- /dev/null
+++ b/spector-server/src/test/java/com/spectrayan/spector/server/RagHandlerTest.java
@@ -0,0 +1,160 @@
+package com.spectrayan.spector.server;
+
+import java.util.Map;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import org.junit.jupiter.api.Test;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.spectrayan.spector.engine.SpectorConfig;
+import com.spectrayan.spector.engine.SpectorEngine;
+
+import io.javalin.testtools.JavalinTest;
+
+/**
+ * Tests for the RAG endpoint ({@code POST /api/v1/rag}).
+ *
+ * <p>Validates: Requirements 9.1, 9.2, 9.3, 9.4, 9.5</p>
+ */
+class RagHandlerTest {
+
+    private static final int DIM = 4;
+    private static final ObjectMapper MAPPER = new ObjectMapper();
+
+    private SpectorEngine createEngine() {
+        return new SpectorEngine(SpectorConfig.DEFAULT.withDimensions(DIM).withCapacity(100));
+    }
+
+    @Test
+    void ragEndpoint_missingQuery_returns400() {
+        var engine = createEngine();
+        var server = new SpectorServer(engine, 0);
+
+        JavalinTest.test(server.app(), (srv, client) -> {
+            // Empty body with no query
+            String body = MAPPER.writeValueAsString(Map.of());
+            var response = client.post("/api/v1/rag", body);
+            assertThat(response.code()).isEqualTo(400);
+            assertThat(response.body().string()).contains("error");
+        });
+        engine.close();
+    }
+
+    @Test
+    void ragEndpoint_blankQuery_returns400() {
+        var engine = createEngine();
+        var server = new SpectorServer(engine, 0);
+
+        JavalinTest.test(server.app(), (srv, client) -> {
+            String body = MAPPER.writeValueAsString(Map.of("query", "   "));
+            var response = client.post("/api/v1/rag", body);
+            assertThat(response.code()).isEqualTo(400);
+            assertThat(response.body().string()).contains("error");
+        });
+        engine.close();
+    }
+
+    @Test
+    void ragEndpoint_queryTooLong_returns400() {
+        var engine = createEngine();
+        var server = new SpectorServer(engine, 0);
+
+        JavalinTest.test(server.app(), (srv, client) -> {
+            String longQuery = "a".repeat(2001);
+            String body = MAPPER.writeValueAsString(Map.of("query", longQuery));
+            var response = client.post("/api/v1/rag", body);
+            assertThat(response.code()).isEqualTo(400);
+            assertThat(response.body().string()).contains("2000");
+        });
+        engine.close();
+    }
+
+    @Test
+    void ragEndpoint_noEmbeddingProvider_returns503() {
+        // Engine without embedding provider
+        var engine = createEngine();
+        var server = new SpectorServer(engine, 0);
+
+        JavalinTest.test(server.app(), (srv, client) -> {
+            String body = MAPPER.writeValueAsString(Map.of("query", "test query"));
+            var response = client.post("/api/v1/rag", body);
+            assertThat(response.code()).isEqualTo(503);
+            assertThat(response.body().string()).contains("unavailable");
+        });
+        engine.close();
+    }
+
+    @Test
+    void ragHandler_directInvocation_missingQuery() {
+        var engine = createEngine();
+        var handler = new RagHandler(engine);
+
+        var request = new RagRequest();
+        request.query = null;
+
+        var result = handler.handle(request);
+        assertThat(result.isSuccess()).isFalse();
+        assertThat(result.statusCode()).isEqualTo(400);
+        assertThat(result.errorMessage()).contains("query");
+    }
+
+    @Test
+    void ragHandler_directInvocation_noEmbeddingProvider() {
+        var engine = createEngine();
+        var handler = new RagHandler(engine);
+
+        var request = new RagRequest();
+        request.query = "test query";
+        request.topK = 5;
+        request.tokenLimit = 4096;
+        request.searchMode = "vector";
+
+        var result = handler.handle(request);
+        assertThat(result.isSuccess()).isFalse();
+        assertThat(result.statusCode()).isEqualTo(503);
+    }
+
+    @Test
+    void ragHandler_directInvocation_clampsTopK() {
+        var engine = createEngine();
+        var handler = new RagHandler(engine);
+
+        // topK > 100 should be clamped - but it requires embedding provider
+        // so this tests the validation order: query → embedding availability → search
+        var request = new RagRequest();
+        request.query = "test";
+        request.topK = 200;
+
+        var result = handler.handle(request);
+        // Without embedding provider, should return 503 (validation passes, then embedding check)
+        assertThat(result.statusCode()).isEqualTo(503);
+    }
+
+    @Test
+    void ragHandler_directInvocation_clampsTokenLimit() {
+        var engine = createEngine();
+        var handler = new RagHandler(engine);
+
+        var request = new RagRequest();
+        request.query = "test";
+        request.tokenLimit = 10000; // exceeds max, should be clamped to 8192
+
+        var result = handler.handle(request);
+        // Without embedding provider, should return 503
+        assertThat(result.statusCode()).isEqualTo(503);
+    }
+
+    @Test
+    void ragHandler_directInvocation_defaultSearchMode() {
+        var engine = createEngine();
+        var handler = new RagHandler(engine);
+
+        var request = new RagRequest();
+        request.query = "test";
+        request.searchMode = null; // Should default to "vector"
+
+        var result = handler.handle(request);
+        // Without embedding provider, should return 503
+        assertThat(result.statusCode()).isEqualTo(503);
+    }
+}
diff --git a/spector-server/src/test/java/com/spectrayan/spector/server/SpectorServerTest.java b/spector-server/src/test/java/com/spectrayan/spector/server/SpectorServerTest.java
new file mode 100644
index 0000000..ca5cdd4
--- /dev/null
+++ b/spector-server/src/test/java/com/spectrayan/spector/server/SpectorServerTest.java
@@ -0,0 +1,133 @@
+package com.spectrayan.spector.server;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+
+import com.spectrayan.spector.core.SimilarityFunction;
+import com.spectrayan.spector.engine.SpectorConfig;
+import com.spectrayan.spector.engine.SpectorEngine;
+
+import io.javalin.testtools.JavalinTest;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.Map;
+
+/**
+ * Integration tests for {@link SpectorServer} REST endpoints.
+ */
+class SpectorServerTest {
+
+    private static final int DIM = 4;
+    private static final ObjectMapper MAPPER = new ObjectMapper();
+
+    private SpectorEngine createEngine() {
+        return new SpectorEngine(SpectorConfig.DEFAULT.withDimensions(DIM).withCapacity(100));
+    }
+
+    @Test
+    void healthEndpoint() {
+        var engine = createEngine();
+        var server = new SpectorServer(engine, 0);
+
+        JavalinTest.test(server.app(), (srv, client) -> {
+            var response = client.get("/health");
+            assertThat(response.code()).isEqualTo(200);
+            assertThat(response.body().string()).contains("ok");
+        });
+        engine.close();
+    }
+
+    @Test
+    void statusEndpoint() {
+        var engine = createEngine();
+        var server = new SpectorServer(engine, 0);
+
+        JavalinTest.test(server.app(), (srv, client) -> {
+            var response = client.get("/api/v1/status");
+            assertThat(response.code()).isEqualTo(200);
+            String body = response.body().string();
+            assertThat(body).contains("spector-search");
+            assertThat(body).contains("dimensions");
+        });
+        engine.close();
+    }
+
+    @Test
+    void ingestAndSearch() {
+        var engine = createEngine();
+        var server = new SpectorServer(engine, 0);
+
+        JavalinTest.test(server.app(), (srv, client) -> {
+            // Ingest
+            String ingestBody = MAPPER.writeValueAsString(Map.of(
+                    "id", "doc-1",
+                    "content", "java search engine",
+                    "vector", new float[]{0.5f, 0.3f, 0.1f, 0.2f}
+            ));
+
+            var ingestResponse = client.post("/api/v1/ingest", ingestBody);
+            assertThat(ingestResponse.code()).isEqualTo(201);
+            assertThat(ingestResponse.body().string()).contains("indexed");
+
+            // Search keyword
+            String searchBody = MAPPER.writeValueAsString(Map.of(
+                    "text", "java",
+                    "topK", 10
+            ));
+            var searchResponse = client.post("/api/v1/search", searchBody);
+            assertThat(searchResponse.code()).isEqualTo(200);
+            String searchResult = searchResponse.body().string();
+            assertThat(searchResult).contains("doc-1");
+        });
+        engine.close();
+    }
+
+    @Test
+    void ingestValidationMissingId() {
+        var engine = createEngine();
+        var server = new SpectorServer(engine, 0);
+
+        JavalinTest.test(server.app(), (srv, client) -> {
+            String body = MAPPER.writeValueAsString(Map.of(
+                    "content", "test",
+                    "vector", new float[]{1, 0, 0, 0}
+            ));
+            var response = client.post("/api/v1/ingest", body);
+            assertThat(response.code()).isEqualTo(400);
+            assertThat(response.body().string()).contains("error");
+        });
+        engine.close();
+    }
+
+    @Test
+    void ingestValidationMissingContent() {
+        var engine = createEngine();
+        var server = new SpectorServer(engine, 0);
+
+        JavalinTest.test(server.app(), (srv, client) -> {
+            String body = MAPPER.writeValueAsString(Map.of(
+                    "id", "doc-1",
+                    "vector", new float[]{1, 0, 0, 0}
+            ));
+            var response = client.post("/api/v1/ingest", body);
+            assertThat(response.code()).isEqualTo(400);
+        });
+        engine.close();
+    }
+
+    @Test
+    void searchEmptyIndexReturnsEmptyResults() {
+        var engine = createEngine();
+        var server = new SpectorServer(engine, 0);
+
+        JavalinTest.test(server.app(), (srv, client) -> {
+            String body = MAPPER.writeValueAsString(Map.of("text", "nothing", "topK", 10));
+            var response = client.post("/api/v1/search", body);
+            assertThat(response.code()).isEqualTo(200);
+            assertThat(response.body().string()).contains("\"results\":[]");
+        });
+        engine.close();
+    }
+}
diff --git a/spector-spring/README.md b/spector-spring/README.md
deleted file mode 100644
index f858fab..0000000
--- a/spector-spring/README.md
+++ /dev/null
@@ -1,51 +0,0 @@
-# spector-spring 🍃
-
-> **Spring Boot starter and Spring AI integration auto-configurations for Spector.**
-
-`spector-spring` registers Spector as a native Spring Boot starter dependency. It auto-configures the in-process `SpectorEngine` bean, maps application properties, and implements Spring AI's core `VectorStore` interfaces for plug-and-play RAG architectures.
-
----
-
-## 🏗️ Core Architecture & Roles
-
-1. **Auto-Configuration (`SpectorAutoConfiguration`):** Reads environment configurations from `application.yml` and instantiates the `SpectorEngine` lifecycle beans automatically.
-2. **Spring AI Integration (`SpectorVectorStore`):** Implements Spring AI's standard `VectorStore` contract:
-   - `add(List<Document> documents)`
-   - `similaritySearch(SearchRequest request)`
-
----
-
-## 🚀 Spring Configurations
-
-### 1. Register Starter Dependency (Maven)
-```xml
-<dependency>
-    <groupId>com.spectrayan</groupId>
-    <artifactId>spector-spring-boot-starter</artifactId>
-    <version>0.1.0-SNAPSHOT</version>
-</dependency>
-```
-
-### 2. Configure Properties (`application.yml`)
-```yaml
-spring:
-  ai:
-    vector:
-      spector:
-        dimensions: 384
-        capacity: 100000
-        quantization: SCALAR_INT8
-        gpu-enabled: true
-```
-
-### 3. Autowire and Search
-```java
-@Autowired
-private VectorStore vectorStore;
-
-public List<Document> search(String query) {
-    return vectorStore.similaritySearch(
-        SearchRequest.query(query).withTopK(5)
-    );
-}
-```
diff --git a/spector-spring/pom.xml b/spector-spring/pom.xml
index e88517e..6de06e6 100644
--- a/spector-spring/pom.xml
+++ b/spector-spring/pom.xml
@@ -6,13 +6,13 @@
 
     <parent>
         <groupId>com.spectrayan</groupId>
-        <artifactId>spector</artifactId>
+        <artifactId>spector-search</artifactId>
         <version>0.1.0-SNAPSHOT</version>
     </parent>
 
-    <artifactId>spring-ai-starter-vector-store-spector</artifactId>
+    <artifactId>spring-ai-starter-vector-store-spector-search</artifactId>
     <name>Spector Spring AI Integration</name>
-    <description>Spring AI VectorStore implementation backed by Spector engine.</description>
+    <description>Spring AI VectorStore implementation backed by Spector Search engine.</description>
 
     <dependencies>
         <!-- Spring AI Vector Store (VectorStore, SearchRequest, Filter) -->
@@ -60,18 +60,6 @@
             <artifactId>spector-engine</artifactId>
         </dependency>
 
-        <!-- Spector GPU (required on classpath for Spring field introspection) -->
-        <dependency>
-            <groupId>com.spectrayan</groupId>
-            <artifactId>spector-gpu</artifactId>
-        </dependency>
-
-        <!-- Spector RAG (context assembly) -->
-        <dependency>
-            <groupId>com.spectrayan</groupId>
-            <artifactId>spector-rag</artifactId>
-        </dependency>
-
         <!-- Spector Client (remote mode) -->
         <dependency>
             <groupId>com.spectrayan</groupId>
@@ -80,45 +68,10 @@
 
         <!-- Jackson for metadata serialization -->
         <dependency>
-            <groupId>tools.jackson.core</groupId>
+            <groupId>com.fasterxml.jackson.core</groupId>
             <artifactId>jackson-databind</artifactId>
         </dependency>
 
-        <!-- ── Spector Metrics (metered decorators) ── -->
-        <dependency>
-            <groupId>com.spectrayan</groupId>
-            <artifactId>spector-metrics</artifactId>
-        </dependency>
-
-        <!-- ── Spector Memory (embedded cognitive memory) ── -->
-        <dependency>
-            <groupId>com.spectrayan</groupId>
-            <artifactId>spector-memory</artifactId>
-        </dependency>
-
-        <!-- ── Spring Boot Auto-Configuration ── -->
-        <dependency>
-            <groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-autoconfigure</artifactId>
-            <version>3.5.3</version>
-            <optional>true</optional>
-        </dependency>
-
-        <!-- ── Spring Boot Actuator (health indicators, /actuator/metrics) ── -->
-        <dependency>
-            <groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-actuator</artifactId>
-            <version>3.5.3</version>
-            <optional>true</optional>
-        </dependency>
-
-        <!-- ── Micrometer (for Spring Boot Actuator metrics bridge) ── -->
-        <dependency>
-            <groupId>io.micrometer</groupId>
-            <artifactId>micrometer-core</artifactId>
-            <optional>true</optional>
-        </dependency>
-
         <!-- Test -->
         <dependency>
             <groupId>net.jqwik</groupId>
@@ -126,16 +79,6 @@
             <version>1.9.2</version>
             <scope>test</scope>
         </dependency>
-        <dependency>
-            <groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-starter-test</artifactId>
-            <version>3.5.3</version>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>com.spectrayan</groupId>
-            <artifactId>spector-commons</artifactId>
-        </dependency>
     </dependencies>
 
 </project>
diff --git a/spector-spring/src/main/java/com/spectrayan/spector/spring/autoconfigure/SpectorAutoConfiguration.java b/spector-spring/src/main/java/com/spectrayan/spector/spring/autoconfigure/SpectorAutoConfiguration.java
deleted file mode 100644
index 7b10c15..0000000
--- a/spector-spring/src/main/java/com/spectrayan/spector/spring/autoconfigure/SpectorAutoConfiguration.java
+++ /dev/null
@@ -1,155 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.spring.autoconfigure;
-
-import com.spectrayan.spector.config.SpectorConfig;
-import com.spectrayan.spector.embed.EmbeddingProvider;
-import com.spectrayan.spector.engine.DefaultSpectorEngine;
-import com.spectrayan.spector.engine.SpectorEngine;
-import com.spectrayan.spector.memory.DefaultSpectorMemory;
-import com.spectrayan.spector.memory.MemoryPersistenceMode;
-import com.spectrayan.spector.memory.SpectorMemory;
-import com.spectrayan.spector.metrics.MeteredSpectorEngine;
-import com.spectrayan.spector.metrics.MeteredSpectorMemory;
-import com.spectrayan.spector.metrics.SpectorMetrics;
-
-import io.micrometer.core.instrument.MeterRegistry;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import org.springframework.beans.factory.ObjectProvider;
-import org.springframework.boot.autoconfigure.AutoConfiguration;
-import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
-import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
-import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
-import org.springframework.boot.context.properties.EnableConfigurationProperties;
-import org.springframework.context.annotation.Bean;
-
-import java.nio.file.Path;
-import com.spectrayan.spector.commons.error.SpectorInternalException;
-import com.spectrayan.spector.commons.error.ErrorCode;
-
-/**
- * Spring Boot auto-configuration for embedded Spector.
- *
- * <p>Automatically creates and wires {@link SpectorEngine} and optionally
- * {@link SpectorMemory} beans when Spector is on the classpath. If a
- * {@link MeterRegistry} is available (e.g., from Spring Boot Actuator),
- * the beans are automatically wrapped with metered decorators for
- * observability through {@code /actuator/metrics}.</p>
- *
- * <h3>Usage</h3>
- * <p>Add {@code spector-spring} to your Spring Boot application's dependencies.
- * Configure via {@code application.yml}:</p>
- * <pre>{@code
- *   spector:
- *     engine:
- *       dimensions: 768
- *       capacity: 100000
- *     metrics:
- *       enabled: true
- * }</pre>
- *
- * <h3>Bean Hierarchy</h3>
- * <ul>
- *   <li>{@code SpectorEngine} — metered wrapper (if metrics enabled) around {@code DefaultSpectorEngine}</li>
- *   <li>{@code SpectorMemory} — metered wrapper (if metrics enabled) around {@code DefaultSpectorMemory}</li>
- *   <li>{@code SpectorVectorStore} — Spring AI VectorStore bridge (if Spring AI on classpath)</li>
- * </ul>
- *
- * @see SpectorConfigProperties
- */
-@AutoConfiguration
-@EnableConfigurationProperties(SpectorConfigProperties.class)
-@ConditionalOnClass(SpectorEngine.class)
-public class SpectorAutoConfiguration {
-
-    private static final Logger log = LoggerFactory.getLogger(SpectorAutoConfiguration.class);
-
-    /**
-     * Creates the core {@link SpectorEngine} bean.
-     *
-     * <p>If a {@link MeterRegistry} is available and metrics are enabled,
-     * the engine is wrapped with a {@link MeteredSpectorEngine} decorator.
-     * Also initializes the global {@link SpectorMetrics} registry.</p>
-     */
-    @Bean
-    @ConditionalOnMissingBean
-    SpectorEngine spectorEngine(SpectorConfigProperties props,
-                                 ObjectProvider<EmbeddingProvider> embedderProvider,
-                                 ObjectProvider<MeterRegistry> registryProvider) {
-
-        SpectorConfig config = props.toEngineConfig();
-        EmbeddingProvider embedder = embedderProvider.getIfAvailable();
-
-        DefaultSpectorEngine raw = new DefaultSpectorEngine(config, embedder);
-        log.info("SpectorEngine auto-configured: dims={}, capacity={}, embedding={}",
-                config.dimensions(), config.capacity(),
-                embedder != null ? embedder.modelName() : "none");
-
-        MeterRegistry registry = registryProvider.getIfAvailable();
-        if (registry != null && props.getMetrics().isEnabled()) {
-            SpectorMetrics.init(registry);
-            log.info("Spector metrics enabled via Spring MeterRegistry");
-            return new MeteredSpectorEngine(raw, registry);
-        }
-
-        return raw;
-    }
-
-    /**
-     * Creates the {@link SpectorMemory} bean when memory is enabled.
-     *
-     * <p>Optionally wrapped with {@link MeteredSpectorMemory} when metrics
-     * are available.</p>
-     */
-    @Bean
-    @ConditionalOnMissingBean
-    @ConditionalOnProperty(prefix = "spector.memory", name = "enabled", havingValue = "true")
-    SpectorMemory spectorMemory(SpectorConfigProperties props,
-                                 ObjectProvider<EmbeddingProvider> embedderProvider,
-                                 ObjectProvider<MeterRegistry> registryProvider) {
-
-        var memoryProps = props.getMemory();
-        EmbeddingProvider embedder = embedderProvider.getIfAvailable();
-
-        if (embedder == null) {
-            throw new SpectorInternalException(ErrorCode.ARGUMENT_NULL, "EmbeddingProvider bean (configure provider or set spector.memory.enabled=false)");
-        }
-
-        var builder = DefaultSpectorMemory.builder()
-                .dimensions(memoryProps.getDimensions())
-                .embeddingProvider(embedder)
-                .persistenceMode(MemoryPersistenceMode.valueOf(memoryProps.getPersistenceMode()))
-                .semanticCapacity(memoryProps.getCapacity());
-
-        if (memoryProps.getPersistencePath() != null) {
-            builder.persistence(Path.of(memoryProps.getPersistencePath()));
-        }
-
-        SpectorMemory raw = builder.build();
-        log.info("SpectorMemory auto-configured: dims={}, persistence={}, path={}",
-                memoryProps.getDimensions(), memoryProps.getPersistenceMode(),
-                memoryProps.getPersistencePath());
-
-        MeterRegistry registry = registryProvider.getIfAvailable();
-        if (registry != null && props.getMetrics().isEnabled()) {
-            return new MeteredSpectorMemory(raw, registry);
-        }
-
-        return raw;
-    }
-}
diff --git a/spector-spring/src/main/java/com/spectrayan/spector/spring/autoconfigure/SpectorConfigProperties.java b/spector-spring/src/main/java/com/spectrayan/spector/spring/autoconfigure/SpectorConfigProperties.java
deleted file mode 100644
index 78e6576..0000000
--- a/spector-spring/src/main/java/com/spectrayan/spector/spring/autoconfigure/SpectorConfigProperties.java
+++ /dev/null
@@ -1,145 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.spring.autoconfigure;
-
-import org.springframework.boot.context.properties.ConfigurationProperties;
-
-import java.nio.file.Path;
-
-/**
- * Spring Boot configuration properties for Spector.
- *
- * <p>Maps to the {@code spector.*} namespace in {@code application.yml} /
- * {@code application.properties}. Mirrors the existing {@code spector.yml}
- * schema so users can use the same property names they're familiar with.</p>
- *
- * <h3>Example</h3>
- * <pre>{@code
- *   spector:
- *     engine:
- *       dimensions: 768
- *       capacity: 100000
- *       similarity: COSINE
- *     memory:
- *       enabled: true
- *       persistence-mode: DISK
- *       persistence-path: /data/spector/memory
- *     metrics:
- *       enabled: true
- * }</pre>
- */
-@ConfigurationProperties("spector")
-public class SpectorConfigProperties {
-
-    private Engine engine = new Engine();
-    private Memory memory = new Memory();
-    private Metrics metrics = new Metrics();
-    private Embedding embedding = new Embedding();
-
-    public Engine getEngine() { return engine; }
-    public void setEngine(Engine engine) { this.engine = engine; }
-    public Memory getMemory() { return memory; }
-    public void setMemory(Memory memory) { this.memory = memory; }
-    public Metrics getMetrics() { return metrics; }
-    public void setMetrics(Metrics metrics) { this.metrics = metrics; }
-    public Embedding getEmbedding() { return embedding; }
-    public void setEmbedding(Embedding embedding) { this.embedding = embedding; }
-
-    // ─────────────── Engine ───────────────
-
-    public static class Engine {
-        private int dimensions = 768;
-        private int capacity = 100_000;
-        private String similarity = "COSINE";
-        private String indexType = "HNSW";
-        private String persistenceMode = "DISK";
-        private String dataDirectory;
-
-        public int getDimensions() { return dimensions; }
-        public void setDimensions(int dimensions) { this.dimensions = dimensions; }
-        public int getCapacity() { return capacity; }
-        public void setCapacity(int capacity) { this.capacity = capacity; }
-        public String getSimilarity() { return similarity; }
-        public void setSimilarity(String similarity) { this.similarity = similarity; }
-        public String getIndexType() { return indexType; }
-        public void setIndexType(String indexType) { this.indexType = indexType; }
-        public String getPersistenceMode() { return persistenceMode; }
-        public void setPersistenceMode(String persistenceMode) { this.persistenceMode = persistenceMode; }
-        public String getDataDirectory() { return dataDirectory; }
-        public void setDataDirectory(String dataDirectory) { this.dataDirectory = dataDirectory; }
-    }
-
-    // ─────────────── Memory ───────────────
-
-    public static class Memory {
-        private boolean enabled = false;
-        private String persistenceMode = "DISK";
-        private String persistencePath;
-        private int dimensions = 768;
-        private int capacity = 100_000;
-
-        public boolean isEnabled() { return enabled; }
-        public void setEnabled(boolean enabled) { this.enabled = enabled; }
-        public String getPersistenceMode() { return persistenceMode; }
-        public void setPersistenceMode(String persistenceMode) { this.persistenceMode = persistenceMode; }
-        public String getPersistencePath() { return persistencePath; }
-        public void setPersistencePath(String persistencePath) { this.persistencePath = persistencePath; }
-        public int getDimensions() { return dimensions; }
-        public void setDimensions(int dimensions) { this.dimensions = dimensions; }
-        public int getCapacity() { return capacity; }
-        public void setCapacity(int capacity) { this.capacity = capacity; }
-    }
-
-    // ─────────────── Metrics ───────────────
-
-    public static class Metrics {
-        private boolean enabled = true;
-
-        public boolean isEnabled() { return enabled; }
-        public void setEnabled(boolean enabled) { this.enabled = enabled; }
-    }
-
-    // ─────────────── Embedding ───────────────
-
-    public static class Embedding {
-        private String model = "nomic-embed-text";
-        private String baseUrl = "http://localhost:11434";
-
-        public String getModel() { return model; }
-        public void setModel(String model) { this.model = model; }
-        public String getBaseUrl() { return baseUrl; }
-        public void setBaseUrl(String baseUrl) { this.baseUrl = baseUrl; }
-    }
-
-    /**
-     * Converts engine properties to a {@link com.spectrayan.spector.config.SpectorConfig}.
-     */
-    public com.spectrayan.spector.config.SpectorConfig toEngineConfig() {
-        var config = com.spectrayan.spector.config.SpectorConfig.DEFAULT
-                .withDimensions(engine.dimensions)
-                .withCapacity(engine.capacity)
-                .withSimilarityFunction(
-                        com.spectrayan.spector.core.similarity.SimilarityFunction.valueOf(engine.similarity));
-
-        if (engine.dataDirectory != null) {
-            config = config.withPersistence(
-                    com.spectrayan.spector.config.PersistenceMode.valueOf(engine.persistenceMode),
-                    Path.of(engine.dataDirectory));
-        }
-
-        return config;
-    }
-}
diff --git a/spector-spring/src/main/java/com/spectrayan/spector/spring/autoconfigure/SpectorHealthIndicator.java b/spector-spring/src/main/java/com/spectrayan/spector/spring/autoconfigure/SpectorHealthIndicator.java
deleted file mode 100644
index 624d527..0000000
--- a/spector-spring/src/main/java/com/spectrayan/spector/spring/autoconfigure/SpectorHealthIndicator.java
+++ /dev/null
@@ -1,96 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.spring.autoconfigure;
-
-import com.spectrayan.spector.core.simd.SimdCapability;
-import com.spectrayan.spector.engine.SpectorEngine;
-import com.spectrayan.spector.memory.SpectorMemory;
-
-import org.springframework.beans.factory.ObjectProvider;
-import org.springframework.boot.actuate.health.Health;
-import org.springframework.boot.actuate.health.HealthIndicator;
-import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
-import org.springframework.stereotype.Component;
-
-/**
- * Spring Boot Actuator health indicator for Spector.
- *
- * <p>Reports engine status, document count, SIMD capability, and optional
- * memory tier counts at {@code /actuator/health}.</p>
- *
- * <h3>Example Output</h3>
- * <pre>{@code
- *   "spector": {
- *     "status": "UP",
- *     "details": {
- *       "engine.documents": 42000,
- *       "engine.gpu": false,
- *       "engine.reranker": false,
- *       "engine.embedding": "nomic-embed-text",
- *       "simd": "AVX-512 (512-bit, preferred species: 16 floats)",
- *       "memory.total": 1500,
- *       "memory.episodic": 800,
- *       "memory.semantic": 700
- *     }
- *   }
- * }</pre>
- */
-@Component
-@ConditionalOnClass({HealthIndicator.class, SpectorEngine.class})
-public class SpectorHealthIndicator implements HealthIndicator {
-
-    private final SpectorEngine engine;
-    private final SpectorMemory memory; // nullable
-
-    public SpectorHealthIndicator(SpectorEngine engine,
-                                   ObjectProvider<SpectorMemory> memoryProvider) {
-        this.engine = engine;
-        this.memory = memoryProvider.getIfAvailable();
-    }
-
-    @Override
-    public Health health() {
-        try {
-            var builder = Health.up()
-                    .withDetail("engine.documents", engine.documentCount())
-                    .withDetail("engine.gpu", engine.isGpuActive())
-                    .withDetail("engine.reranker", engine.isRerankerActive())
-                    .withDetail("engine.embedding",
-                            engine.hasEmbeddingProvider()
-                                    ? engine.embeddingProvider().modelName()
-                                    : "none")
-                    .withDetail("simd", SimdCapability.report());
-
-            if (memory != null) {
-                builder.withDetail("memory.total", memory.totalMemories());
-                builder.withDetail("memory.working",
-                        memory.memoryCount(com.spectrayan.spector.memory.MemoryType.WORKING));
-                builder.withDetail("memory.episodic",
-                        memory.memoryCount(com.spectrayan.spector.memory.MemoryType.EPISODIC));
-                builder.withDetail("memory.semantic",
-                        memory.memoryCount(com.spectrayan.spector.memory.MemoryType.SEMANTIC));
-                builder.withDetail("memory.procedural",
-                        memory.memoryCount(com.spectrayan.spector.memory.MemoryType.PROCEDURAL));
-            }
-
-            return builder.build();
-        } catch (Exception e) {
-            return Health.down()
-                    .withException(e)
-                    .build();
-        }
-    }
-}
diff --git a/spector-spring/src/main/java/org/springframework/ai/vectorstore/spector/SpectorFilterEvaluator.java b/spector-spring/src/main/java/org/springframework/ai/vectorstore/spector/SpectorFilterEvaluator.java
index 2639c63..4548b33 100644
--- a/spector-spring/src/main/java/org/springframework/ai/vectorstore/spector/SpectorFilterEvaluator.java
+++ b/spector-spring/src/main/java/org/springframework/ai/vectorstore/spector/SpectorFilterEvaluator.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package org.springframework.ai.vectorstore.spector;
 
 import org.springframework.ai.vectorstore.filter.Filter;
diff --git a/spector-spring/src/main/java/org/springframework/ai/vectorstore/spector/SpectorFilterExpressionConverter.java b/spector-spring/src/main/java/org/springframework/ai/vectorstore/spector/SpectorFilterExpressionConverter.java
index 4dcd868..363c79e 100644
--- a/spector-spring/src/main/java/org/springframework/ai/vectorstore/spector/SpectorFilterExpressionConverter.java
+++ b/spector-spring/src/main/java/org/springframework/ai/vectorstore/spector/SpectorFilterExpressionConverter.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package org.springframework.ai.vectorstore.spector;
 
 import org.springframework.ai.vectorstore.filter.Filter;
@@ -24,11 +9,9 @@
 import org.springframework.ai.vectorstore.filter.FilterExpressionConverter;
 
 import java.util.List;
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-import com.spectrayan.spector.commons.error.ErrorCode;
 
 /**
- * Converts Spring AI {@link Filter.Expression} into Spector filter query strings.
+ * Converts Spring AI {@link Filter.Expression} into Spector Search filter query strings.
  *
  * <p>Supports:
  * <ul>
@@ -107,7 +90,7 @@ private String mapOperator(ExpressionType type) {
             case GTE -> ">=";
             case LT -> "<";
             case LTE -> "<=";
-            default -> throw new SpectorValidationException(ErrorCode.ARGUMENT_INVALID, "comparisonType", type);
+            default -> throw new IllegalArgumentException("Unsupported comparison type: " + type);
         };
     }
 
diff --git a/spector-spring/src/main/java/org/springframework/ai/vectorstore/spector/SpectorVectorStore.java b/spector-spring/src/main/java/org/springframework/ai/vectorstore/spector/SpectorVectorStore.java
index bf7014d..aef5fa3 100644
--- a/spector-spring/src/main/java/org/springframework/ai/vectorstore/spector/SpectorVectorStore.java
+++ b/spector-spring/src/main/java/org/springframework/ai/vectorstore/spector/SpectorVectorStore.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package org.springframework.ai.vectorstore.spector;
 
 import com.spectrayan.spector.client.SpectorClient;
@@ -34,19 +19,17 @@
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-import com.spectrayan.spector.commons.error.ErrorCode;
 
 /**
- * Spring AI {@link VectorStore} implementation backed by Spector.
+ * Spring AI {@link VectorStore} implementation backed by Spector Search.
  *
  * <p>Supports two modes of operation:
  * <ul>
  *   <li><b>Embedded</b> — uses a local {@link SpectorEngine} instance directly</li>
- *   <li><b>Remote</b> — communicates with a remote Spector instance via {@link SpectorClient}</li>
+ *   <li><b>Remote</b> — communicates with a remote Spector Search instance via {@link SpectorClient}</li>
  * </ul>
  *
- * <p>Since Spector is a vector-native engine, documents must have their embeddings
+ * <p>Since Spector Search is a vector-native engine, documents must have their embeddings
  * pre-computed and stored in metadata under the key {@code "embedding"} (as a {@code float[]}).
  * The {@link #similaritySearch(SearchRequest)} method requires a pre-computed query embedding
  * to be stored in the search request's metadata or passed via the query text that the engine
@@ -132,7 +115,8 @@ public void delete(List<String> idList) {
     public void delete(Filter.Expression filterExpression) {
         // Filter-based deletion is not directly supported by Spector engine.
         // This implementation could be extended to query matching docs and delete them.
-        throw new SpectorValidationException(ErrorCode.ARGUMENT_INVALID, "SpectorVectorStore", "filter-based deletion is not yet supported");
+        throw new UnsupportedOperationException(
+                "Filter-based deletion is not yet supported by SpectorVectorStore");
     }
 
     @Override
@@ -150,7 +134,7 @@ public List<Document> similaritySearch(SearchRequest request) {
             return Collections.emptyList();
         }
 
-        // Spector is vector-native and doesn't embed text internally.
+        // Spector Search is vector-native and doesn't embed text internally.
         // Text-based similarity search requires an external embedding provider.
         // For now, we cannot convert text to vector without an embedder.
         LOG.debug("Text-based similarity search not supported without embedding provider; query='{}'", queryText);
diff --git a/spector-spring/src/main/java/org/springframework/ai/vectorstore/spector/SpectorVectorStoreException.java b/spector-spring/src/main/java/org/springframework/ai/vectorstore/spector/SpectorVectorStoreException.java
index 3592686..a25e9e9 100644
--- a/spector-spring/src/main/java/org/springframework/ai/vectorstore/spector/SpectorVectorStoreException.java
+++ b/spector-spring/src/main/java/org/springframework/ai/vectorstore/spector/SpectorVectorStoreException.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package org.springframework.ai.vectorstore.spector;
 
 /**
diff --git a/spector-spring/src/main/java/org/springframework/ai/vectorstore/spector/rag/RagConfig.java b/spector-spring/src/main/java/org/springframework/ai/vectorstore/spector/rag/RagConfig.java
index 1e3816f..4469fd3 100644
--- a/spector-spring/src/main/java/org/springframework/ai/vectorstore/spector/rag/RagConfig.java
+++ b/spector-spring/src/main/java/org/springframework/ai/vectorstore/spector/rag/RagConfig.java
@@ -1,23 +1,5 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package org.springframework.ai.vectorstore.spector.rag;
 
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-import com.spectrayan.spector.commons.error.ErrorCode;
-
 /**
  * Configuration for RAG retrieval operations in {@link SpectorRagService}.
  *
@@ -38,13 +20,14 @@ public record RagConfig(int topK, float similarityThreshold, int tokenLimit) {
 
     public RagConfig {
         if (topK < 1 || topK > 100) {
-            throw new SpectorValidationException(ErrorCode.TOP_K_INVALID, 1, topK);
+            throw new IllegalArgumentException("topK must be between 1 and 100, got: " + topK);
         }
         if (similarityThreshold < 0.0f || similarityThreshold > 1.0f) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_OUT_OF_RANGE, "similarityThreshold", 0.0, 1.0, similarityThreshold);
+            throw new IllegalArgumentException(
+                    "similarityThreshold must be between 0.0 and 1.0, got: " + similarityThreshold);
         }
         if (tokenLimit < 1 || tokenLimit > 8192) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_OUT_OF_RANGE, "tokenLimit", 1, 8192, tokenLimit);
+            throw new IllegalArgumentException("tokenLimit must be between 1 and 8192, got: " + tokenLimit);
         }
     }
 
diff --git a/spector-spring/src/main/java/org/springframework/ai/vectorstore/spector/rag/RetrievalResult.java b/spector-spring/src/main/java/org/springframework/ai/vectorstore/spector/rag/RetrievalResult.java
index 6797ca1..d921a1e 100644
--- a/spector-spring/src/main/java/org/springframework/ai/vectorstore/spector/rag/RetrievalResult.java
+++ b/spector-spring/src/main/java/org/springframework/ai/vectorstore/spector/rag/RetrievalResult.java
@@ -1,25 +1,8 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package org.springframework.ai.vectorstore.spector.rag;
 
-import com.spectrayan.spector.rag.ChunkAttribution;
+import com.spectrayan.spector.engine.rag.ChunkAttribution;
 
 import java.util.List;
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-import com.spectrayan.spector.commons.error.ErrorCode;
 
 /**
  * Result of a RAG retrieval operation from {@link SpectorRagService}.
@@ -36,13 +19,13 @@ public record RetrievalResult(
 
     public RetrievalResult {
         if (documents == null) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_NULL, "documents");
+            throw new IllegalArgumentException("documents must not be null");
         }
         if (contextText == null) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_NULL, "contextText");
+            throw new IllegalArgumentException("contextText must not be null");
         }
         if (attributions == null) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_NULL, "attributions");
+            throw new IllegalArgumentException("attributions must not be null");
         }
         documents = List.copyOf(documents);
         attributions = List.copyOf(attributions);
diff --git a/spector-spring/src/main/java/org/springframework/ai/vectorstore/spector/rag/ScoredDocument.java b/spector-spring/src/main/java/org/springframework/ai/vectorstore/spector/rag/ScoredDocument.java
index be60693..b5135b2 100644
--- a/spector-spring/src/main/java/org/springframework/ai/vectorstore/spector/rag/ScoredDocument.java
+++ b/spector-spring/src/main/java/org/springframework/ai/vectorstore/spector/rag/ScoredDocument.java
@@ -1,23 +1,5 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package org.springframework.ai.vectorstore.spector.rag;
 
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-import com.spectrayan.spector.commons.error.ErrorCode;
-
 /**
  * A document result with a relevance score from RAG retrieval.
  *
@@ -30,13 +12,13 @@ public record ScoredDocument(String documentId, String content, float score, int
 
     public ScoredDocument {
         if (documentId == null || documentId.isBlank()) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_NULL, "documentId");
+            throw new IllegalArgumentException("documentId must not be null or blank");
         }
         if (score < 0.0f || score > 1.0f) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_OUT_OF_RANGE, "score", 0, 1, score);
+            throw new IllegalArgumentException("score must be between 0.0 and 1.0, got: " + score);
         }
         if (chunkOffset < 0) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_NEGATIVE, "chunkOffset", 0);
+            throw new IllegalArgumentException("chunkOffset must not be negative");
         }
     }
 }
diff --git a/spector-spring/src/main/java/org/springframework/ai/vectorstore/spector/rag/SpectorRagService.java b/spector-spring/src/main/java/org/springframework/ai/vectorstore/spector/rag/SpectorRagService.java
index 814422e..6af43b0 100644
--- a/spector-spring/src/main/java/org/springframework/ai/vectorstore/spector/rag/SpectorRagService.java
+++ b/spector-spring/src/main/java/org/springframework/ai/vectorstore/spector/rag/SpectorRagService.java
@@ -1,25 +1,10 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package org.springframework.ai.vectorstore.spector.rag;
 
 import com.spectrayan.spector.commons.TextChunk;
 import com.spectrayan.spector.commons.WordTokenizer;
-import com.spectrayan.spector.rag.ContextBuilder;
-import com.spectrayan.spector.rag.ContextResult;
-import com.spectrayan.spector.rag.ScoredChunk;
+import com.spectrayan.spector.engine.rag.ContextBuilder;
+import com.spectrayan.spector.engine.rag.ContextResult;
+import com.spectrayan.spector.engine.rag.ScoredChunk;
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -30,11 +15,9 @@
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-import com.spectrayan.spector.commons.error.ErrorCode;
 
 /**
- * Spring AI RAG service that integrates Spector vector retrieval with
+ * Spring AI RAG service that integrates Spector Search vector retrieval with
  * context assembly for retrieval-augmented generation.
  *
  * <p>Delegates vector retrieval to {@link SpectorVectorStore} and context assembly
@@ -59,14 +42,14 @@ public class SpectorRagService {
      *
      * @param vectorStore    the vector store for similarity search
      * @param contextBuilder the context builder for assembling retrieval context
-     * @throws SpectorValidationException if vectorStore or contextBuilder is null
+     * @throws IllegalArgumentException if vectorStore or contextBuilder is null
      */
     public SpectorRagService(SpectorVectorStore vectorStore, ContextBuilder contextBuilder) {
         if (vectorStore == null) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_NULL, "vectorStore");
+            throw new IllegalArgumentException("vectorStore must not be null");
         }
         if (contextBuilder == null) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_NULL, "contextBuilder");
+            throw new IllegalArgumentException("contextBuilder must not be null");
         }
         this.vectorStore = vectorStore;
         this.contextBuilder = contextBuilder;
@@ -81,15 +64,15 @@ public SpectorRagService(SpectorVectorStore vectorStore, ContextBuilder contextB
      * @param queryEmbedding the query vector embedding to search for
      * @param config         the RAG configuration (topK, threshold, tokenLimit)
      * @return the retrieval result containing scored documents, context text, and attributions
-     * @throws SpectorValidationException if queryEmbedding is null/empty or config is null
+     * @throws IllegalArgumentException if queryEmbedding is null/empty or config is null
      * @throws SpectorRagServiceException if a dependency (vector store or context builder) fails
      */
     public RetrievalResult retrieve(float[] queryEmbedding, RagConfig config) {
         if (queryEmbedding == null || queryEmbedding.length == 0) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_NULL, "queryEmbedding");
+            throw new IllegalArgumentException("queryEmbedding must not be null or empty");
         }
         if (config == null) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_NULL, "config");
+            throw new IllegalArgumentException("config must not be null");
         }
 
         List<Document> searchResults;
diff --git a/spector-spring/src/main/java/org/springframework/ai/vectorstore/spector/rag/SpectorRagServiceException.java b/spector-spring/src/main/java/org/springframework/ai/vectorstore/spector/rag/SpectorRagServiceException.java
index 2885412..f45f3d9 100644
--- a/spector-spring/src/main/java/org/springframework/ai/vectorstore/spector/rag/SpectorRagServiceException.java
+++ b/spector-spring/src/main/java/org/springframework/ai/vectorstore/spector/rag/SpectorRagServiceException.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package org.springframework.ai.vectorstore.spector.rag;
 
 /**
diff --git a/spector-spring/src/main/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports b/spector-spring/src/main/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports
deleted file mode 100644
index 0e5545c..0000000
--- a/spector-spring/src/main/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports
+++ /dev/null
@@ -1 +0,0 @@
-com.spectrayan.spector.spring.autoconfigure.SpectorAutoConfiguration
diff --git a/spector-spring/src/test/java/com/spectrayan/spector/spring/autoconfigure/SpectorAutoConfigurationTest.java b/spector-spring/src/test/java/com/spectrayan/spector/spring/autoconfigure/SpectorAutoConfigurationTest.java
deleted file mode 100644
index f886e64..0000000
--- a/spector-spring/src/test/java/com/spectrayan/spector/spring/autoconfigure/SpectorAutoConfigurationTest.java
+++ /dev/null
@@ -1,68 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.spring.autoconfigure;
-
-import com.spectrayan.spector.engine.SpectorEngine;
-import com.spectrayan.spector.metrics.MeteredSpectorEngine;
-import io.micrometer.core.instrument.MeterRegistry;
-import io.micrometer.core.instrument.simple.SimpleMeterRegistry;
-import org.junit.jupiter.api.Test;
-import org.springframework.boot.autoconfigure.AutoConfigurations;
-import org.springframework.boot.test.context.runner.ApplicationContextRunner;
-import org.springframework.context.annotation.Bean;
-import org.springframework.context.annotation.Configuration;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-/**
- * Integration and unit tests for {@link SpectorAutoConfiguration} using {@link ApplicationContextRunner}.
- */
-class SpectorAutoConfigurationTest {
-
-    private final ApplicationContextRunner contextRunner = new ApplicationContextRunner()
-            .withConfiguration(AutoConfigurations.of(SpectorAutoConfiguration.class));
-
-    @Test
-    void defaultConfiguration_createsEngineBean() {
-        this.contextRunner
-                .withPropertyValues("spector.engine.dimensions=384")
-                .run(context -> {
-                    assertThat(context).hasSingleBean(SpectorEngine.class);
-                    SpectorEngine engine = context.getBean(SpectorEngine.class);
-                    assertThat(engine.config().dimensions()).isEqualTo(384);
-                });
-    }
-
-    @Test
-    void withMeterRegistry_wrapsEngineWithMeteredDecorator() {
-        this.contextRunner
-                .withUserConfiguration(TestMeterRegistryConfiguration.class)
-                .withPropertyValues("spector.engine.dimensions=384", "spector.metrics.enabled=true")
-                .run(context -> {
-                    assertThat(context).hasSingleBean(SpectorEngine.class);
-                    SpectorEngine engine = context.getBean(SpectorEngine.class);
-                    assertThat(engine).isInstanceOf(MeteredSpectorEngine.class);
-                });
-    }
-
-    @Configuration(proxyBeanMethods = false)
-    static class TestMeterRegistryConfiguration {
-        @Bean
-        MeterRegistry meterRegistry() {
-            return new SimpleMeterRegistry();
-        }
-    }
-}
diff --git a/spector-spring/src/test/java/org/springframework/ai/vectorstore/spector/SpectorFilterEvaluatorTest.java b/spector-spring/src/test/java/org/springframework/ai/vectorstore/spector/SpectorFilterEvaluatorTest.java
index df5fb15..66f0d90 100644
--- a/spector-spring/src/test/java/org/springframework/ai/vectorstore/spector/SpectorFilterEvaluatorTest.java
+++ b/spector-spring/src/test/java/org/springframework/ai/vectorstore/spector/SpectorFilterEvaluatorTest.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package org.springframework.ai.vectorstore.spector;
 
 import org.junit.jupiter.api.Test;
diff --git a/spector-spring/src/test/java/org/springframework/ai/vectorstore/spector/SpectorFilterExpressionConverterTest.java b/spector-spring/src/test/java/org/springframework/ai/vectorstore/spector/SpectorFilterExpressionConverterTest.java
index db8bb77..7318c5e 100644
--- a/spector-spring/src/test/java/org/springframework/ai/vectorstore/spector/SpectorFilterExpressionConverterTest.java
+++ b/spector-spring/src/test/java/org/springframework/ai/vectorstore/spector/SpectorFilterExpressionConverterTest.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package org.springframework.ai.vectorstore.spector;
 
 import org.junit.jupiter.api.BeforeEach;
diff --git a/spector-spring/src/test/java/org/springframework/ai/vectorstore/spector/SpectorVectorStoreTest.java b/spector-spring/src/test/java/org/springframework/ai/vectorstore/spector/SpectorVectorStoreTest.java
index 369ded7..cecfb1f 100644
--- a/spector-spring/src/test/java/org/springframework/ai/vectorstore/spector/SpectorVectorStoreTest.java
+++ b/spector-spring/src/test/java/org/springframework/ai/vectorstore/spector/SpectorVectorStoreTest.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package org.springframework.ai.vectorstore.spector;
 
 import com.spectrayan.spector.engine.SpectorEngine;
diff --git a/spector-spring/src/test/java/org/springframework/ai/vectorstore/spector/rag/SpectorRagServiceTest.java b/spector-spring/src/test/java/org/springframework/ai/vectorstore/spector/rag/SpectorRagServiceTest.java
index 4ea6403..10d6565 100644
--- a/spector-spring/src/test/java/org/springframework/ai/vectorstore/spector/rag/SpectorRagServiceTest.java
+++ b/spector-spring/src/test/java/org/springframework/ai/vectorstore/spector/rag/SpectorRagServiceTest.java
@@ -1,24 +1,7 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package org.springframework.ai.vectorstore.spector.rag;
 
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-
 import com.spectrayan.spector.engine.SpectorEngine;
-import com.spectrayan.spector.rag.ContextBuilder;
+import com.spectrayan.spector.engine.rag.ContextBuilder;
 
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
@@ -133,7 +116,7 @@ void retrieve_withNullQuery_throwsException() {
         RagConfig config = RagConfig.defaults();
 
         assertThatThrownBy(() -> ragService.retrieve(null, config))
-                .isInstanceOf(SpectorValidationException.class)
+                .isInstanceOf(IllegalArgumentException.class)
                 .hasMessageContaining("queryEmbedding");
     }
 
@@ -142,7 +125,7 @@ void retrieve_withEmptyQuery_throwsException() {
         RagConfig config = RagConfig.defaults();
 
         assertThatThrownBy(() -> ragService.retrieve(new float[0], config))
-                .isInstanceOf(SpectorValidationException.class)
+                .isInstanceOf(IllegalArgumentException.class)
                 .hasMessageContaining("queryEmbedding");
     }
 
@@ -151,21 +134,21 @@ void retrieve_withNullConfig_throwsException() {
         float[] query = {1.0f, 0.0f, 0.0f, 0.0f};
 
         assertThatThrownBy(() -> ragService.retrieve(query, null))
-                .isInstanceOf(SpectorValidationException.class)
+                .isInstanceOf(IllegalArgumentException.class)
                 .hasMessageContaining("config");
     }
 
     @Test
     void constructor_withNullVectorStore_throwsException() {
         assertThatThrownBy(() -> new SpectorRagService(null, contextBuilder))
-                .isInstanceOf(SpectorValidationException.class)
+                .isInstanceOf(IllegalArgumentException.class)
                 .hasMessageContaining("vectorStore");
     }
 
     @Test
     void constructor_withNullContextBuilder_throwsException() {
         assertThatThrownBy(() -> new SpectorRagService(vectorStore, null))
-                .isInstanceOf(SpectorValidationException.class)
+                .isInstanceOf(IllegalArgumentException.class)
                 .hasMessageContaining("contextBuilder");
     }
 
@@ -181,25 +164,25 @@ void ragConfig_defaults() {
     @Test
     void ragConfig_invalidTopK_throwsException() {
         assertThatThrownBy(() -> new RagConfig(0, 0.5f, 4096))
-                .isInstanceOf(SpectorValidationException.class);
+                .isInstanceOf(IllegalArgumentException.class);
         assertThatThrownBy(() -> new RagConfig(101, 0.5f, 4096))
-                .isInstanceOf(SpectorValidationException.class);
+                .isInstanceOf(IllegalArgumentException.class);
     }
 
     @Test
     void ragConfig_invalidThreshold_throwsException() {
         assertThatThrownBy(() -> new RagConfig(5, -0.1f, 4096))
-                .isInstanceOf(SpectorValidationException.class);
+                .isInstanceOf(IllegalArgumentException.class);
         assertThatThrownBy(() -> new RagConfig(5, 1.1f, 4096))
-                .isInstanceOf(SpectorValidationException.class);
+                .isInstanceOf(IllegalArgumentException.class);
     }
 
     @Test
     void ragConfig_invalidTokenLimit_throwsException() {
         assertThatThrownBy(() -> new RagConfig(5, 0.5f, 0))
-                .isInstanceOf(SpectorValidationException.class);
+                .isInstanceOf(IllegalArgumentException.class);
         assertThatThrownBy(() -> new RagConfig(5, 0.5f, 8193))
-                .isInstanceOf(SpectorValidationException.class);
+                .isInstanceOf(IllegalArgumentException.class);
     }
 
     // ─── Helpers ───
diff --git a/spector-storage/README.md b/spector-storage/README.md
deleted file mode 100644
index f114ef1..0000000
--- a/spector-storage/README.md
+++ /dev/null
@@ -1,41 +0,0 @@
-# spector-storage 💾
-
-> **Zero-copy, off-heap vector storage built on Panama Foreign Function & Memory (FFM) API.**
-
-`spector-storage` implements high-speed vector allocation, memory segment layouts, and memory-mapped persistence layers. By using Project Panama's off-heap `MemorySegment` capabilities, it completely avoids JVM garbage collection pressure, even when storing millions of high-dimensional embeddings in memory.
-
----
-
-## 🏗️ Core Architecture & Roles
-
-1. **Off-Heap Storage (`MemorySegmentStore`):** Stores uncompressed float32 vectors directly in contiguous off-heap virtual memory segments.
-2. **Memory-Mapped Persistence (`MmapStore`):** Uses OS-level page cache via `mmap` to persist vector segments directly to disk, allowing files to survive JVM restarts and load instantaneously.
-3. **Quantized Vector Store (`QuantizedVectorStore`):** Compresses vectors using low-level layouts. Integrates directly with SVASQ (INT8, INT4, INT2) formats, storing compressed coordinates and scaling metadata in space-efficient off-heap bit-packed segments.
-
----
-
-## 🚀 Key APIs
-
-### Allocating Off-Heap Store
-```java
-int dimensions = 384;
-int capacity = 100_000;
-
-try (VectorStore store = new MemorySegmentStore(dimensions, capacity)) {
-    float[] vector = new float[384];
-    
-    // Store vector at a specific index
-    store.put(42, vector);
-    
-    // Retrieve vector without heap allocation
-    float[] retrieved = store.get(42);
-}
-```
-
-### Memory-Mapped Vector Persistence
-```java
-Path filePath = Path.of("vectors.mmap");
-try (VectorStore mmapStore = new MmapStore(filePath, dimensions, capacity)) {
-    mmapStore.put(99, queryVector);
-} // Flushed and saved instantly
-```
diff --git a/spector-storage/pom.xml b/spector-storage/pom.xml
index 501ece9..aa9293a 100644
--- a/spector-storage/pom.xml
+++ b/spector-storage/pom.xml
@@ -6,7 +6,7 @@
 
     <parent>
         <groupId>com.spectrayan</groupId>
-        <artifactId>spector</artifactId>
+        <artifactId>spector-search</artifactId>
         <version>0.1.0-SNAPSHOT</version>
     </parent>
 
@@ -15,19 +15,10 @@
     <description>Panama MemorySegment-based zero-copy vector and document storage.</description>
 
     <dependencies>
-
-        <dependency>
-            <groupId>com.spectrayan</groupId>
-            <artifactId>spector-config</artifactId>
-        </dependency>
         <dependency>
             <groupId>com.spectrayan</groupId>
             <artifactId>spector-core</artifactId>
         </dependency>
-        <dependency>
-            <groupId>com.spectrayan</groupId>
-            <artifactId>spector-commons</artifactId>
-        </dependency>
     </dependencies>
 
 </project>
diff --git a/spector-storage/src/main/java/com/spectrayan/spector/storage/Document.java b/spector-storage/src/main/java/com/spectrayan/spector/storage/Document.java
index 60e8b36..ecb4454 100644
--- a/spector-storage/src/main/java/com/spectrayan/spector/storage/Document.java
+++ b/spector-storage/src/main/java/com/spectrayan/spector/storage/Document.java
@@ -1,23 +1,5 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.storage;
 
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-import com.spectrayan.spector.commons.error.ErrorCode;
-
 import java.util.Map;
 import java.util.Objects;
 
@@ -40,8 +22,8 @@ public record Document(
         Map<String, Object> metadata
 ) {
     public Document {
-        if (id == null) { throw new SpectorValidationException(ErrorCode.ARGUMENT_NULL, "id"); }
-        if (content == null) { throw new SpectorValidationException(ErrorCode.ARGUMENT_NULL, "content"); }
+        Objects.requireNonNull(id, "id must not be null");
+        Objects.requireNonNull(content, "content must not be null");
         if (title == null) title = "";
         if (metadata == null) metadata = Map.of();
     }
diff --git a/spector-storage/src/main/java/com/spectrayan/spector/storage/DocumentStore.java b/spector-storage/src/main/java/com/spectrayan/spector/storage/DocumentStore.java
index 3bb3cda..db85fc9 100644
--- a/spector-storage/src/main/java/com/spectrayan/spector/storage/DocumentStore.java
+++ b/spector-storage/src/main/java/com/spectrayan/spector/storage/DocumentStore.java
@@ -1,58 +1,16 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.storage;
 
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.io.IOException;
-import java.io.UncheckedIOException;
-import java.nio.ByteBuffer;
-import java.nio.channels.FileChannel;
-import java.nio.charset.StandardCharsets;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.nio.file.StandardOpenOption;
-import java.util.HashMap;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
 
 /**
- * In-memory document metadata store with optional disk persistence.
+ * In-memory document metadata store.
  *
  * <p>Provides a simple ID-keyed store for {@link Document} objects.
  * Designed for concurrent access from virtual threads.</p>
- *
- * <h3>Persistence</h3>
- * <p>Supports binary serialization via {@link #save(Path)} and {@link #load(Path)}.
- * Uses a "DOCS" magic header followed by variable-length records.</p>
  */
 public class DocumentStore implements AutoCloseable {
 
-    private static final Logger log = LoggerFactory.getLogger(DocumentStore.class);
-
-    /** File magic: "DOCS" in ASCII. */
-    private static final int DOCS_MAGIC = 0x444F4353;
-
-    /** File format version. */
-    private static final int DOCS_VERSION = 1;
-
-    /** File header: 4B magic + 4B version + 4B count + 4B reserved = 16 bytes. */
-    private static final int FILE_HEADER_BYTES = 16;
-
     private final Map<String, Document> documents;
 
     public DocumentStore() {
@@ -124,157 +82,4 @@ public Map<String, Document> all() {
     public void close() {
         documents.clear();
     }
-
-    // ══════════════════════════════════════════════════════════════
-    // PERSISTENCE: save / load
-    // ══════════════════════════════════════════════════════════════
-
-    /**
-     * Saves all documents to a binary file.
-     *
-     * @param filePath path to write
-     */
-    public void save(Path filePath) {
-        Path parent = filePath.getParent();
-        if (parent != null) {
-            try {
-                Files.createDirectories(parent);
-            } catch (IOException e) {
-                throw new UncheckedIOException("Cannot create document store directory", e);
-            }
-        }
-
-        try (FileChannel ch = FileChannel.open(filePath,
-                StandardOpenOption.CREATE, StandardOpenOption.WRITE,
-                StandardOpenOption.TRUNCATE_EXISTING)) {
-
-            ByteBuffer header = ByteBuffer.allocate(FILE_HEADER_BYTES);
-            header.putInt(DOCS_MAGIC);
-            header.putInt(DOCS_VERSION);
-            header.putInt(documents.size());
-            header.putInt(0);
-            header.flip();
-            ch.write(header);
-
-            for (Document doc : documents.values()) {
-                writeDocument(ch, doc);
-            }
-
-            ch.force(true);
-            log.info("DocumentStore saved: {} documents → {}", documents.size(), filePath);
-
-        } catch (IOException e) {
-            throw new UncheckedIOException("Failed to save DocumentStore: " + filePath, e);
-        }
-    }
-
-    /**
-     * Loads documents from a binary file, or returns a new empty store.
-     *
-     * @param filePath path to read
-     * @return populated DocumentStore (or empty if file missing)
-     */
-    public static DocumentStore load(Path filePath) {
-        DocumentStore store = new DocumentStore();
-
-        if (filePath == null || !Files.exists(filePath)) {
-            log.info("DocumentStore file not found, starting fresh: {}", filePath);
-            return store;
-        }
-
-        try (FileChannel ch = FileChannel.open(filePath, StandardOpenOption.READ)) {
-            if (ch.size() < FILE_HEADER_BYTES) {
-                log.warn("DocumentStore file too small, starting fresh");
-                return store;
-            }
-
-            ByteBuffer header = ByteBuffer.allocate(FILE_HEADER_BYTES);
-            ch.read(header);
-            header.flip();
-
-            int magic = header.getInt();
-            int version = header.getInt();
-            int count = header.getInt();
-            header.getInt();
-
-            if (magic != DOCS_MAGIC || version != DOCS_VERSION) {
-                log.warn("Invalid DocumentStore file header, starting fresh");
-                return store;
-            }
-
-            for (int i = 0; i < count; i++) {
-                Document doc = readDocument(ch);
-                store.put(doc);
-            }
-
-            log.info("DocumentStore loaded: {} documents from {}", store.size(), filePath);
-
-        } catch (IOException e) {
-            log.error("Failed to load DocumentStore, starting fresh: {}", e.getMessage());
-        }
-
-        return store;
-    }
-
-    private static void writeDocument(FileChannel ch, Document doc) throws IOException {
-        byte[] idBytes = doc.id().getBytes(StandardCharsets.UTF_8);
-        byte[] titleBytes = doc.title().getBytes(StandardCharsets.UTF_8);
-        byte[] contentBytes = doc.content().getBytes(StandardCharsets.UTF_8);
-
-        int size = 4 + idBytes.length + 4 + titleBytes.length + 4 + contentBytes.length + 4;
-        for (var entry : doc.metadata().entrySet()) {
-            size += 4 + entry.getKey().getBytes(StandardCharsets.UTF_8).length
-                    + 4 + String.valueOf(entry.getValue()).getBytes(StandardCharsets.UTF_8).length;
-        }
-
-        ByteBuffer buf = ByteBuffer.allocate(size);
-        writeStringToBuf(buf, idBytes);
-        writeStringToBuf(buf, titleBytes);
-        writeStringToBuf(buf, contentBytes);
-        buf.putInt(doc.metadata().size());
-        for (var entry : doc.metadata().entrySet()) {
-            writeStringToBuf(buf, entry.getKey().getBytes(StandardCharsets.UTF_8));
-            writeStringToBuf(buf, String.valueOf(entry.getValue()).getBytes(StandardCharsets.UTF_8));
-        }
-        buf.flip();
-        ch.write(buf);
-    }
-
-    private static Document readDocument(FileChannel ch) throws IOException {
-        String id = readString(ch);
-        String title = readString(ch);
-        String content = readString(ch);
-
-        ByteBuffer countBuf = ByteBuffer.allocate(4);
-        ch.read(countBuf);
-        countBuf.flip();
-        int metaCount = countBuf.getInt();
-
-        Map<String, Object> metadata = new HashMap<>();
-        for (int i = 0; i < metaCount; i++) {
-            String key = readString(ch);
-            String value = readString(ch);
-            metadata.put(key, value);
-        }
-
-        return new Document(id, title, content, metadata);
-    }
-
-    private static void writeStringToBuf(ByteBuffer buf, byte[] bytes) {
-        buf.putInt(bytes.length);
-        buf.put(bytes);
-    }
-
-    private static String readString(FileChannel ch) throws IOException {
-        ByteBuffer lenBuf = ByteBuffer.allocate(4);
-        ch.read(lenBuf);
-        lenBuf.flip();
-        int len = lenBuf.getInt();
-        if (len == 0) return "";
-        ByteBuffer strBuf = ByteBuffer.allocate(len);
-        ch.read(strBuf);
-        strBuf.flip();
-        return new String(strBuf.array(), 0, len, StandardCharsets.UTF_8);
-    }
 }
-
diff --git a/spector-storage/src/main/java/com/spectrayan/spector/storage/InMemoryVectorStore.java b/spector-storage/src/main/java/com/spectrayan/spector/storage/InMemoryVectorStore.java
index 3aa6eb8..b05e3db 100644
--- a/spector-storage/src/main/java/com/spectrayan/spector/storage/InMemoryVectorStore.java
+++ b/spector-storage/src/main/java/com/spectrayan/spector/storage/InMemoryVectorStore.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.storage;
 
 import java.lang.foreign.Arena;
@@ -25,10 +10,6 @@
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-import com.spectrayan.spector.storage.error.SpectorStoreFullException;
-import com.spectrayan.spector.storage.error.SpectorSegmentClosedException;
-import com.spectrayan.spector.commons.error.ErrorCode;
 
 /**
  * In-memory vector store backed by a contiguous off-heap {@link MemorySegment}.
@@ -68,7 +49,7 @@ public class InMemoryVectorStore implements VectorStore {
      */
     public InMemoryVectorStore(int dimensions, int capacity) {
         if (capacity <= 0) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_OUT_OF_RANGE, "capacity", 1, Integer.MAX_VALUE, capacity);
+            throw new IllegalArgumentException("capacity must be positive: " + capacity);
         }
 
         this.layout = new VectorStoreLayout(dimensions);
@@ -90,7 +71,8 @@ public int put(String id, float[] vector) {
         try {
             ensureOpen();
             if (vector.length != layout.dimensions()) {
-                throw new SpectorValidationException(ErrorCode.DIMENSIONS_MISMATCH, "Expected " + layout.dimensions() + " dimensions, got " + vector.length);
+                throw new IllegalArgumentException(
+                        "Expected " + layout.dimensions() + " dimensions, got " + vector.length);
             }
 
             // Check if ID already exists (update in-place)
@@ -104,7 +86,8 @@ public int put(String id, float[] vector) {
             int index = count.getAndIncrement();
             if (index >= capacity) {
                 count.decrementAndGet();
-                throw new SpectorStoreFullException(capacity);
+                throw new IllegalStateException(
+                        "Store is full: capacity=" + capacity);
             }
 
             layout.writeVector(segment, index, vector);
@@ -178,14 +161,14 @@ public void close() {
 
     private void ensureOpen() {
         if (closed) {
-            throw new SpectorSegmentClosedException();
+            throw new IllegalStateException("VectorStore is closed");
         }
     }
 
     private void validateIndex(int index) {
         if (index < 0 || index >= count.get()) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_OUT_OF_RANGE, 
+            throw new IndexOutOfBoundsException(
                     "index=" + index + ", size=" + count.get());
         }
     }
-}
\ No newline at end of file
+}
diff --git a/spector-storage/src/main/java/com/spectrayan/spector/storage/IndexFileFormat.java b/spector-storage/src/main/java/com/spectrayan/spector/storage/IndexFileFormat.java
index f35e478..fc6470c 100644
--- a/spector-storage/src/main/java/com/spectrayan/spector/storage/IndexFileFormat.java
+++ b/spector-storage/src/main/java/com/spectrayan/spector/storage/IndexFileFormat.java
@@ -1,28 +1,11 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.storage;
 
-import com.spectrayan.spector.core.quantization.QuantizationType;
-import com.spectrayan.spector.core.similarity.SimilarityFunction;
+import com.spectrayan.spector.core.QuantizationType;
+import com.spectrayan.spector.core.SimilarityFunction;
 
 import java.lang.foreign.MemorySegment;
 import java.lang.foreign.ValueLayout;
 import java.nio.charset.StandardCharsets;
-import com.spectrayan.spector.commons.error.ErrorCode;
-import com.spectrayan.spector.commons.error.SpectorValidationException;
 
 /**
  * Binary file format for persisting HNSW indexes to disk.
@@ -102,10 +85,13 @@ public record Header(
         /** Validates the header. */
         public void validate() {
             if (magic != MAGIC) {
-                throw new SpectorValidationException(ErrorCode.ARGUMENT_INVALID, "Invalid magic: expected 0x" + Integer.toHexString(MAGIC) + ", got 0x" + Integer.toHexString(magic));
+                throw new IllegalArgumentException(
+                        "Invalid magic: expected 0x" + Integer.toHexString(MAGIC)
+                                + ", got 0x" + Integer.toHexString(magic));
             }
             if (version != VERSION) {
-                throw new SpectorValidationException(ErrorCode.ARGUMENT_INVALID, "Unsupported version: " + version + " (expected " + VERSION + ")");
+                throw new IllegalArgumentException(
+                        "Unsupported version: " + version + " (expected " + VERSION + ")");
             }
         }
 
@@ -219,4 +205,4 @@ public static int computeGraphBlockSize(int maxLevel0, int m, int maxLevels) {
     public static long alignToPage(long offset) {
         return (offset + HEADER_SIZE - 1) & ~(HEADER_SIZE - 1L);
     }
-}
\ No newline at end of file
+}
diff --git a/spector-storage/src/main/java/com/spectrayan/spector/storage/MappedVectorStore.java b/spector-storage/src/main/java/com/spectrayan/spector/storage/MappedVectorStore.java
index 5835b26..13fa45c 100644
--- a/spector-storage/src/main/java/com/spectrayan/spector/storage/MappedVectorStore.java
+++ b/spector-storage/src/main/java/com/spectrayan/spector/storage/MappedVectorStore.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.storage;
 
 import java.io.IOException;
@@ -30,10 +15,6 @@
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-import com.spectrayan.spector.storage.error.SpectorStoreFullException;
-import com.spectrayan.spector.storage.error.SpectorSegmentClosedException;
-import com.spectrayan.spector.commons.error.ErrorCode;
 
 /**
  * Memory-mapped vector store backed by a file via {@link FileChannel#map}.
@@ -68,7 +49,6 @@ public class MappedVectorStore implements VectorStore {
     private final AtomicInteger count;
     private final ReentrantLock writeLock = new ReentrantLock();
     private volatile boolean closed;
-    private volatile long lastAccessed;
 
     /**
      * Creates or opens a memory-mapped vector store.
@@ -80,7 +60,7 @@ public class MappedVectorStore implements VectorStore {
      */
     public MappedVectorStore(Path filePath, int dimensions, int capacity) throws IOException {
         if (capacity <= 0) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_OUT_OF_RANGE, "capacity", 1, Integer.MAX_VALUE, capacity);
+            throw new IllegalArgumentException("capacity must be positive: " + capacity);
         }
 
         this.layout = new VectorStoreLayout(dimensions);
@@ -89,7 +69,6 @@ public MappedVectorStore(Path filePath, int dimensions, int capacity) throws IOE
         this.idToIndex = new ConcurrentHashMap<>(capacity);
         this.count = new AtomicInteger(0);
         this.closed = false;
-        this.lastAccessed = System.currentTimeMillis();
 
         // Ensure parent directories exist
         Path parent = filePath.getParent();
@@ -108,8 +87,6 @@ public MappedVectorStore(Path filePath, int dimensions, int capacity) throws IOE
         this.arena = Arena.ofShared();
         this.segment = channel.map(FileChannel.MapMode.READ_WRITE, 0, totalBytes, arena);
 
-        warmup(); // Warm up asynchronously on creation
-
         log.info("MappedVectorStore created: path={}, dimensions={}, capacity={}, bytes={}",
                 filePath, dimensions, capacity, totalBytes);
     }
@@ -119,9 +96,9 @@ public int put(String id, float[] vector) {
         writeLock.lock();
         try {
             ensureOpen();
-            this.lastAccessed = System.currentTimeMillis();
             if (vector.length != layout.dimensions()) {
-                throw new SpectorValidationException(ErrorCode.DIMENSIONS_MISMATCH, "Expected " + layout.dimensions() + " dimensions, got " + vector.length);
+                throw new IllegalArgumentException(
+                        "Expected " + layout.dimensions() + " dimensions, got " + vector.length);
             }
 
             // Update in-place if ID exists
@@ -135,7 +112,7 @@ public int put(String id, float[] vector) {
             int index = count.getAndIncrement();
             if (index >= capacity) {
                 count.decrementAndGet();
-                throw new SpectorStoreFullException(capacity);
+                throw new IllegalStateException("Store is full: capacity=" + capacity);
             }
 
             layout.writeVector(segment, index, vector);
@@ -149,7 +126,6 @@ public int put(String id, float[] vector) {
     @Override
     public float[] get(String id) {
         ensureOpen();
-        this.lastAccessed = System.currentTimeMillis();
         Integer index = idToIndex.get(id);
         return index == null ? null : layout.readVector(segment, index);
     }
@@ -158,7 +134,6 @@ public float[] get(String id) {
     public float[] getByIndex(int index) {
         ensureOpen();
         validateIndex(index);
-        this.lastAccessed = System.currentTimeMillis();
         return layout.readVector(segment, index);
     }
 
@@ -166,13 +141,11 @@ public float[] getByIndex(int index) {
     public void getByIndex(int index, float[] dst, int dstOffset) {
         ensureOpen();
         validateIndex(index);
-        this.lastAccessed = System.currentTimeMillis();
         layout.readVector(segment, index, dst, dstOffset);
     }
 
     @Override
     public int indexOf(String id) {
-        this.lastAccessed = System.currentTimeMillis();
         Integer index = idToIndex.get(id);
         return index == null ? -1 : index;
     }
@@ -215,10 +188,6 @@ public void close() {
                 try {
                     // Force pending writes to disk
                     segment.force();
-                    if (segment.isMapped()) {
-                        com.spectrayan.spector.commons.concurrent.MemoryPinning.unlock(segment);
-                        segment.unload();
-                    }
                     arena.close();
                     channel.close();
                     raf.close();
@@ -233,183 +202,15 @@ public void close() {
         }
     }
 
-    /**
-     * Pre-touches and loads the mapped memory segment into physical memory
-     * to prevent cold-start page fault latency spikes during initial queries.
-     * Performs a best-effort asynchronous load using a virtual thread.
-     */
-    public void warmup() {
-        if (segment.isMapped()) {
-            Thread.startVirtualThread(() -> {
-                long start = System.nanoTime();
-                try {
-                    segment.load();
-                    boolean pinned = com.spectrayan.spector.commons.concurrent.MemoryPinning.lock(segment);
-                    long elapsedMs = (System.nanoTime() - start) / 1_000_000;
-                    log.info("MappedVectorStore warmed up successfully (pinned={}) in {} ms (file={})",
-                            pinned, elapsedMs, filePath);
-                } catch (Exception e) {
-                    log.warn("Failed to warm up MappedVectorStore: {}", e.getMessage());
-                }
-            });
-        }
-    }
-
-    /**
-     * Evicts the mapped segment pages from physical memory if it has been inactive
-     * for at least the specified grace period.
-     *
-     * @param gracePeriodMs threshold of inactivity in milliseconds
-     * @return true if successfully evicted, false if segment is active or not mapped
-     */
-    public boolean unloadIdle(long gracePeriodMs) {
-        writeLock.lock();
-        try {
-            if (!closed && segment.isMapped()) {
-                long idleMs = System.currentTimeMillis() - lastAccessed;
-                if (idleMs >= gracePeriodMs) {
-                    com.spectrayan.spector.commons.concurrent.MemoryPinning.unlock(segment);
-                    segment.unload();
-                    log.info("MappedVectorStore idle-evicted: file={} (idle for {} ms)", filePath, idleMs);
-                    return true;
-                }
-            }
-            return false;
-        } finally {
-            writeLock.unlock();
-        }
-    }
-
     private void ensureOpen() {
         if (closed) {
-            throw new SpectorSegmentClosedException();
+            throw new IllegalStateException("VectorStore is closed");
         }
     }
 
     private void validateIndex(int index) {
         if (index < 0 || index >= count.get()) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_OUT_OF_RANGE, "index", 0, count.get() - 1, index);
-        }
-    }
-
-    // ══════════════════════════════════════════════════════════════
-    // ID MAPPING PERSISTENCE
-    // ══════════════════════════════════════════════════════════════
-
-    /** File magic: "VIDS" in ASCII. */
-    private static final int VIDS_MAGIC = 0x56494453;
-
-    /** File format version. */
-    private static final int VIDS_VERSION = 1;
-
-    /** File header: 4B magic + 4B version + 4B count + 4B reserved = 16 bytes. */
-    private static final int VIDS_HEADER_BYTES = 16;
-
-    /**
-     * Saves the id→index mapping to a binary file.
-     *
-     * @param mappingPath path to write the ID mapping file
-     */
-    public void saveIdMappings(Path mappingPath) {
-        Path parent = mappingPath.getParent();
-        if (parent != null) {
-            try {
-                Files.createDirectories(parent);
-            } catch (IOException e) {
-                log.warn("Cannot create id-mappings directory: {}", e.getMessage());
-                return;
-            }
-        }
-
-        try (var ch = FileChannel.open(mappingPath,
-                java.nio.file.StandardOpenOption.CREATE,
-                java.nio.file.StandardOpenOption.WRITE,
-                java.nio.file.StandardOpenOption.TRUNCATE_EXISTING)) {
-
-            java.nio.ByteBuffer header = java.nio.ByteBuffer.allocate(VIDS_HEADER_BYTES);
-            header.putInt(VIDS_MAGIC);
-            header.putInt(VIDS_VERSION);
-            header.putInt(idToIndex.size());
-            header.putInt(0);
-            header.flip();
-            ch.write(header);
-
-            for (var entry : idToIndex.entrySet()) {
-                byte[] idBytes = entry.getKey().getBytes(java.nio.charset.StandardCharsets.UTF_8);
-                java.nio.ByteBuffer buf = java.nio.ByteBuffer.allocate(4 + idBytes.length + 4);
-                buf.putInt(idBytes.length);
-                buf.put(idBytes);
-                buf.putInt(entry.getValue());
-                buf.flip();
-                ch.write(buf);
-            }
-
-            ch.force(true);
-            log.info("MappedVectorStore ID mappings saved: {} entries → {}", idToIndex.size(), mappingPath);
-
-        } catch (IOException e) {
-            log.error("Failed to save ID mappings: {}", e.getMessage());
-        }
-    }
-
-    /**
-     * Loads id→index mappings from a binary file.
-     *
-     * @param mappingPath path to read the ID mapping file
-     */
-    public void loadIdMappings(Path mappingPath) {
-        if (mappingPath == null || !Files.exists(mappingPath)) {
-            log.info("ID mappings file not found: {}", mappingPath);
-            return;
-        }
-
-        try (var ch = FileChannel.open(mappingPath, java.nio.file.StandardOpenOption.READ)) {
-            if (ch.size() < VIDS_HEADER_BYTES) return;
-
-            java.nio.ByteBuffer header = java.nio.ByteBuffer.allocate(VIDS_HEADER_BYTES);
-            ch.read(header);
-            header.flip();
-
-            int magic = header.getInt();
-            int version = header.getInt();
-            int entryCount = header.getInt();
-            header.getInt();
-
-            if (magic != VIDS_MAGIC || version != VIDS_VERSION) {
-                log.warn("Invalid ID mappings file header, skipping");
-                return;
-            }
-
-            int maxIdx = -1;
-            for (int i = 0; i < entryCount; i++) {
-                java.nio.ByteBuffer lenBuf = java.nio.ByteBuffer.allocate(4);
-                ch.read(lenBuf);
-                lenBuf.flip();
-                int idLen = lenBuf.getInt();
-
-                java.nio.ByteBuffer idBuf = java.nio.ByteBuffer.allocate(idLen);
-                ch.read(idBuf);
-                idBuf.flip();
-                String id = new String(idBuf.array(), 0, idLen, java.nio.charset.StandardCharsets.UTF_8);
-
-                java.nio.ByteBuffer idxBuf = java.nio.ByteBuffer.allocate(4);
-                ch.read(idxBuf);
-                idxBuf.flip();
-                int idx = idxBuf.getInt();
-
-                idToIndex.put(id, idx);
-                if (idx > maxIdx) maxIdx = idx;
-            }
-
-            // Restore the count to one past the highest loaded index
-            if (maxIdx >= 0) {
-                count.set(maxIdx + 1);
-            }
-
-            log.info("MappedVectorStore ID mappings loaded: {} entries from {}", idToIndex.size(), mappingPath);
-
-        } catch (IOException e) {
-            log.error("Failed to load ID mappings: {}", e.getMessage());
+            throw new IndexOutOfBoundsException("index=" + index + ", size=" + count.get());
         }
     }
 }
diff --git a/spector-storage/src/main/java/com/spectrayan/spector/storage/PersistenceMode.java b/spector-storage/src/main/java/com/spectrayan/spector/storage/PersistenceMode.java
new file mode 100644
index 0000000..2ed443c
--- /dev/null
+++ b/spector-storage/src/main/java/com/spectrayan/spector/storage/PersistenceMode.java
@@ -0,0 +1,13 @@
+package com.spectrayan.spector.storage;
+
+/**
+ * Supported persistence modes for the search engine.
+ */
+public enum PersistenceMode {
+
+    /** All data in memory — lost on shutdown. */
+    IN_MEMORY,
+
+    /** Data persisted to disk via memory-mapped files. Survives restarts. */
+    DISK
+}
diff --git a/spector-storage/src/main/java/com/spectrayan/spector/storage/QuantizedVectorStore.java b/spector-storage/src/main/java/com/spectrayan/spector/storage/QuantizedVectorStore.java
index 973fff7..40fef95 100644
--- a/spector-storage/src/main/java/com/spectrayan/spector/storage/QuantizedVectorStore.java
+++ b/spector-storage/src/main/java/com/spectrayan/spector/storage/QuantizedVectorStore.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.storage;
 
 import java.lang.foreign.Arena;
@@ -26,43 +11,27 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import com.spectrayan.spector.core.quantization.NonUniformQuantizer;
-import com.spectrayan.spector.core.quantization.QuantizationType;
-import com.spectrayan.spector.core.quantization.ScalarQuantizer;
-import com.spectrayan.spector.core.quantization.TurboQuantizer;
-import com.spectrayan.spector.core.quantization.strategy.DistanceContext;
-import com.spectrayan.spector.core.quantization.strategy.QuantizationStrategy;
-import com.spectrayan.spector.core.quantization.strategy.QuantizationStrategyFactory;
-import com.spectrayan.spector.core.quantization.svasq.SvasqEncoder;
-import com.spectrayan.spector.core.quantization.svasq.SvasqParams;
-import com.spectrayan.spector.core.similarity.SimilarityFunction;
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-import com.spectrayan.spector.storage.error.SpectorStoreFullException;
-import com.spectrayan.spector.storage.error.SpectorSegmentClosedException;
-import com.spectrayan.spector.commons.error.ErrorCode;
+import com.spectrayan.spector.core.CrumbPacker;
+import com.spectrayan.spector.core.NibblePacker;
+import com.spectrayan.spector.core.NonUniformQuantizer;
+import com.spectrayan.spector.core.QuantizationType;
+import com.spectrayan.spector.core.ScalarQuantizer;
 
 /**
  * Off-heap vector store that stores quantized vectors via Panama {@link MemorySegment}.
  *
- * <p>Supports multiple quantization types via the {@link QuantizationStrategy} SPI:</p>
+ * <p>Supports multiple quantization types:</p>
  * <ul>
  *   <li><b>INT8</b> — one byte per dimension, using linear {@link ScalarQuantizer}</li>
- *   <li><b>INT4</b> — nibble-packed (2 values/byte), using {@link NonUniformQuantizer}</li>
- *   <li><b>INT2</b> — crumb-packed (4 values/byte), using {@link NonUniformQuantizer}</li>
- *   <li><b>SVASQ</b> — FWHT-rotated affine INT8 with exact-norm header, using {@link SvasqEncoder}</li>
+ *   <li><b>INT4</b> — nibble-packed (2 values/byte), using {@link NonUniformQuantizer} + {@link NibblePacker}</li>
+ *   <li><b>INT2</b> — crumb-packed (4 values/byte), using {@link NonUniformQuantizer} + {@link CrumbPacker}</li>
  * </ul>
  *
- * <h3>Design</h3>
- * <p>All quantization-specific logic is delegated to the {@link QuantizationStrategy} instance
- * created by {@link QuantizationStrategyFactory}. Adding a new quantization type requires
- * only a new strategy class — this class does not change (Open/Closed Principle).</p>
- *
  * <h3>Memory Layout (per vector)</h3>
  * <pre>
- *   INT8:      [byte × dimensions]
- *   INT4:      [byte × ceil(dimensions/2)]
- *   INT2:      [byte × ceil(dimensions/4)]
- *   SVASQ:      [float32 exactNormSq (4 bytes)] [INT8 × paddedDim]
+ *   INT8: [byte × dimensions]
+ *   INT4: [byte × ceil(dimensions/2)]
+ *   INT2: [byte × ceil(dimensions/4)]
  * </pre>
  *
  * <h3>Thread Safety</h3>
@@ -79,16 +48,8 @@ public class QuantizedVectorStore implements AutoCloseable {
     private final int capacity;
     private final QuantizationType quantizationType;
     private final int bytesPerVector;
-
-    /** Strategy encapsulating all quantization-type-specific encode/decode/distance logic. */
-    private final QuantizationStrategy strategy;
-
-    // Retained for backward-compat accessors and for SVASQ zero-copy access from index layer
-    private final ScalarQuantizer quantizer;
-    private final NonUniformQuantizer nonUniformQuantizer;
-    private final TurboQuantizer turboQuantizer;
-    private final SvasqEncoder svasqEncoder;
-
+    private final ScalarQuantizer quantizer;            // used for INT8
+    private final NonUniformQuantizer nonUniformQuantizer; // used for INT4/INT2
     private final Arena arena;
     private final MemorySegment segment;
     private final Map<String, Integer> idToIndex;
@@ -96,8 +57,6 @@ public class QuantizedVectorStore implements AutoCloseable {
     private final ReentrantLock writeLock = new ReentrantLock();
     private volatile boolean closed;
 
-    // ─────────────── Constructors ───────────────
-
     /**
      * Creates a quantized vector store for INT8 (backward-compatible constructor).
      *
@@ -106,89 +65,60 @@ public class QuantizedVectorStore implements AutoCloseable {
      * @param quantizer  the scalar quantizer (must be calibrated)
      */
     public QuantizedVectorStore(int dimensions, int capacity, ScalarQuantizer quantizer) {
-        this(dimensions, capacity, QuantizationType.SCALAR_INT8, quantizer, null, null, null,
-                SimilarityFunction.COSINE);
-    }
-
-    /**
-     * Creates a quantized vector store for TurboQuant.
-     *
-     * @param dimensions      vector dimensionality
-     * @param capacity        max number of vectors
-     * @param turboQuantizer  the calibrated TurboQuantizer
-     */
-    public QuantizedVectorStore(int dimensions, int capacity, TurboQuantizer turboQuantizer) {
-        this(dimensions, capacity, QuantizationType.TURBO_QUANT, null, null, turboQuantizer, null,
-                SimilarityFunction.COSINE);
-    }
-
-    /**
-     * Creates a SVASQ-mode vector store.
-     *
-     * <p>Vectors are stored as: {@code [4b float32 exactNormSq][paddedDim × signed INT8]}.</p>
-     *
-     * @param dimensions  vector dimensionality
-     * @param capacity    max number of vectors
-     * @param svasqParams  calibrated SVASQ parameters
-     */
-    public QuantizedVectorStore(int dimensions, int capacity, SvasqParams svasqParams) {
-        this(dimensions, capacity, QuantizationType.SVASQ, null, null, null,
-                new SvasqEncoder(svasqParams), SimilarityFunction.COSINE);
-    }
-
-    /**
-     * Creates a quantized vector store with a specified quantization type (backward-compatible).
-     *
-     * @param dimensions          vector dimensionality
-     * @param capacity            max number of vectors
-     * @param quantizationType    the quantization type
-     * @param quantizer           the scalar quantizer for INT8
-     * @param nonUniformQuantizer the non-uniform quantizer for INT4/INT2
-     */
-    public QuantizedVectorStore(int dimensions, int capacity, QuantizationType quantizationType,
-                                 ScalarQuantizer quantizer, NonUniformQuantizer nonUniformQuantizer) {
-        this(dimensions, capacity, quantizationType, quantizer, nonUniformQuantizer, null, null,
-                SimilarityFunction.COSINE);
+        this(dimensions, capacity, QuantizationType.SCALAR_INT8, quantizer, null);
     }
 
     /**
-     * Full constructor — creates a quantized vector store with any quantization type.
+     * Creates a quantized vector store with a specified quantization type.
      *
      * <p>For INT8, a {@link ScalarQuantizer} is required. For INT4 and INT2, a
-     * {@link NonUniformQuantizer} is required. For TURBO_QUANT, a {@link TurboQuantizer}
-     * is required. For SVASQ, a {@link SvasqEncoder} is required.</p>
+     * {@link NonUniformQuantizer} is required.</p>
      *
      * @param dimensions          vector dimensionality
      * @param capacity            max number of vectors
-     * @param quantizationType    the quantization type
+     * @param quantizationType    the quantization type (SCALAR_INT8, SCALAR_INT4, or SCALAR_INT2)
      * @param quantizer           the scalar quantizer for INT8 (may be null if not INT8)
-     * @param nonUniformQuantizer the non-uniform quantizer for INT4/INT2 (may be null if not INT4/INT2)
-     * @param turboQuantizer      the TurboQuantizer (may be null if not TURBO_QUANT)
-     * @param svasqEncoder         the SVASQ encoder (may be null if not SVASQ)
-     * @param similarityFunction  the similarity function used for distance context preparation
-     * @throws SpectorValidationException if capacity is not positive, or if required quantizer is missing
+     * @param nonUniformQuantizer the non-uniform quantizer for INT4/INT2 (may be null if INT8)
+     * @throws IllegalArgumentException if capacity is not positive, or if required quantizer is missing
      */
     public QuantizedVectorStore(int dimensions, int capacity, QuantizationType quantizationType,
-                                 ScalarQuantizer quantizer, NonUniformQuantizer nonUniformQuantizer,
-                                 TurboQuantizer turboQuantizer, SvasqEncoder svasqEncoder,
-                                 SimilarityFunction similarityFunction) {
-        if (capacity <= 0) throw new SpectorValidationException(ErrorCode.DIMENSIONS_INVALID, 0);
-        if (quantizationType == null) throw new SpectorValidationException(ErrorCode.ARGUMENT_NULL, "quantizationType");
-
-        // Delegate validation + strategy creation to the Abstract Factory (with dimension checks)
-        this.strategy = QuantizationStrategyFactory.createWithDimCheck(
-                quantizationType, dimensions, quantizer, nonUniformQuantizer, turboQuantizer,
-                svasqEncoder, similarityFunction);
+                                 ScalarQuantizer quantizer, NonUniformQuantizer nonUniformQuantizer) {
+        if (capacity <= 0) throw new IllegalArgumentException("capacity must be positive");
+        if (quantizationType == null) throw new IllegalArgumentException("quantizationType must not be null");
+
+        switch (quantizationType) {
+            case SCALAR_INT8 -> {
+                if (quantizer == null) {
+                    throw new IllegalArgumentException("ScalarQuantizer is required for INT8");
+                }
+                if (quantizer.dimensions() != dimensions) {
+                    throw new IllegalArgumentException("Quantizer dims " + quantizer.dimensions()
+                            + " != store dims " + dimensions);
+                }
+            }
+            case SCALAR_INT4, SCALAR_INT2 -> {
+                if (nonUniformQuantizer == null) {
+                    throw new IllegalArgumentException("NonUniformQuantizer is required for " + quantizationType);
+                }
+                if (nonUniformQuantizer.dimensions() != dimensions) {
+                    throw new IllegalArgumentException("NonUniformQuantizer dims " + nonUniformQuantizer.dimensions()
+                            + " != store dims " + dimensions);
+                }
+                int expectedLevels = quantizationType.levels();
+                if (nonUniformQuantizer.levels() != expectedLevels) {
+                    throw new IllegalArgumentException("NonUniformQuantizer levels " + nonUniformQuantizer.levels()
+                            + " != expected levels " + expectedLevels + " for " + quantizationType);
+                }
+            }
+            default -> throw new IllegalArgumentException("Unsupported quantization type: " + quantizationType);
+        }
 
         this.dimensions = dimensions;
         this.capacity = capacity;
         this.quantizationType = quantizationType;
         this.quantizer = quantizer;
         this.nonUniformQuantizer = nonUniformQuantizer;
-        this.turboQuantizer = turboQuantizer;
-        this.svasqEncoder = svasqEncoder;
-
-        this.bytesPerVector = strategy.bytesPerVector();
+        this.bytesPerVector = quantizationType.bytesPerVector(dimensions);
         this.arena = Arena.ofShared();
 
         long totalBytes = (long) capacity * bytesPerVector;
@@ -197,26 +127,17 @@ public QuantizedVectorStore(int dimensions, int capacity, QuantizationType quant
         this.count = new AtomicInteger(0);
         this.closed = false;
 
-        int compressionFactor = strategy.compressionFactor(dimensions);
+        int compressionFactor = switch (quantizationType) {
+            case SCALAR_INT8 -> 4;
+            case SCALAR_INT4 -> 8;
+            case SCALAR_INT2 -> 16;
+            default -> 1;
+        };
+
         log.info("QuantizedVectorStore created: dims={}, capacity={}, type={}, bytesPerVector={}, totalBytes={} ({}× smaller than float32)",
                 dimensions, capacity, quantizationType, bytesPerVector, totalBytes, compressionFactor);
     }
 
-    /**
-     * Backward-compatible 7-arg constructor (no similarity function — defaults to COSINE).
-     *
-     * @deprecated Use the 8-arg constructor with explicit {@link SimilarityFunction}.
-     */
-    @Deprecated
-    public QuantizedVectorStore(int dimensions, int capacity, QuantizationType quantizationType,
-                                 ScalarQuantizer quantizer, NonUniformQuantizer nonUniformQuantizer,
-                                 TurboQuantizer turboQuantizer, SvasqEncoder svasqEncoder) {
-        this(dimensions, capacity, quantizationType, quantizer, nonUniformQuantizer,
-                turboQuantizer, svasqEncoder, SimilarityFunction.COSINE);
-    }
-
-    // ─────────────── Write ───────────────
-
     /**
      * Stores a float vector, quantizing it internally.
      *
@@ -229,7 +150,8 @@ public int put(String id, float[] vector) {
         try {
             ensureOpen();
             if (vector.length != dimensions) {
-                throw new SpectorValidationException(ErrorCode.DIMENSIONS_MISMATCH, dimensions, vector.length);
+                throw new IllegalArgumentException(
+                        "Expected " + dimensions + " dims, got " + vector.length);
             }
 
             Integer existing = idToIndex.get(id);
@@ -241,7 +163,7 @@ public int put(String id, float[] vector) {
             int index = count.getAndIncrement();
             if (index >= capacity) {
                 count.decrementAndGet();
-                throw new SpectorStoreFullException(capacity);
+                throw new IllegalStateException("Store is full: capacity=" + capacity);
             }
 
             writeQuantized(index, vector);
@@ -252,8 +174,6 @@ public int put(String id, float[] vector) {
         }
     }
 
-    // ─────────────── Read ───────────────
-
     /**
      * Returns the quantized bytes for the given index.
      *
@@ -276,10 +196,19 @@ public byte[] getQuantized(int index) {
      * @return dequantized float array
      */
     public float[] getFloat(int index) {
-        ensureOpen();
-        validateIndex(index);
-        long offset = (long) index * bytesPerVector;
-        return strategy.decode(segment, offset, dimensions);
+        byte[] packed = getQuantized(index);
+        return switch (quantizationType) {
+            case SCALAR_INT8 -> quantizer.decode(packed);
+            case SCALAR_INT4 -> {
+                int[] levels = NibblePacker.unpack(packed, dimensions);
+                yield nonUniformQuantizer.decode(levels);
+            }
+            case SCALAR_INT2 -> {
+                int[] levels = CrumbPacker.unpack(packed, dimensions);
+                yield nonUniformQuantizer.decode(levels);
+            }
+            default -> throw new IllegalStateException("Unsupported type: " + quantizationType);
+        };
     }
 
     /**
@@ -296,34 +225,6 @@ public void getQuantized(int index, byte[] dst, int dstOffset) {
         MemorySegment.copy(segment, ValueLayout.JAVA_BYTE, offset, dst, dstOffset, bytesPerVector);
     }
 
-    /**
-     * Prepares a per-query {@link DistanceContext} for use with {@link #distance}.
-     *
-     * <p>Call this once per search; reuse the context for every candidate.</p>
-     *
-     * @param query float32 query vector
-     * @return a per-query distance context
-     */
-    public DistanceContext prepareQueryContext(float[] query) {
-        return strategy.prepareQueryContext(query);
-    }
-
-    /**
-     * Computes quantized distance from a stored vector to the pre-prepared query context.
-     *
-     * @param index internal vector index
-     * @param ctx   context from {@link #prepareQueryContext(float[])}
-     * @return approximate distance
-     */
-    public float distance(int index, DistanceContext ctx) {
-        ensureOpen();
-        validateIndex(index);
-        long offset = (long) index * bytesPerVector;
-        return strategy.distance(segment, offset, ctx);
-    }
-
-    // ─────────────── Accessors ───────────────
-
     /** Returns the index for a given ID, or -1. */
     public int indexOf(String id) {
         Integer index = idToIndex.get(id);
@@ -345,32 +246,12 @@ public int indexOf(String id) {
     /** Returns the number of bytes stored per vector. */
     public int bytesPerVector() { return bytesPerVector; }
 
-    /** Returns the active {@link QuantizationStrategy} (useful for testing and inspection). */
-    public QuantizationStrategy strategy() { return strategy; }
-
     /** Returns the scalar quantizer (INT8 path), or null if not INT8. */
     public ScalarQuantizer quantizer() { return quantizer; }
 
     /** Returns the non-uniform quantizer (INT4/INT2 path), or null if INT8. */
     public NonUniformQuantizer nonUniformQuantizer() { return nonUniformQuantizer; }
 
-    /** Returns the TurboQuantizer (TURBO_QUANT path), or null if not TurboQuant. */
-    public TurboQuantizer turboQuantizer() { return turboQuantizer; }
-
-    /** Returns the SVASQ encoder, or null if not SVASQ mode. */
-    public SvasqEncoder svasqEncoder() { return svasqEncoder; }
-
-    /**
-     * Returns the underlying off-heap {@link MemorySegment}.
-     *
-     * <p>Used by the HNSW index layer to pass the segment directly to
-     * {@link com.spectrayan.spector.core.quantization.svasq.SvasqSimdKernel} without
-     * copying — zero extra allocations in the hot path.</p>
-     *
-     * @return the off-heap segment
-     */
-    public MemorySegment segment() { return segment; }
-
     /** Returns true if closed. */
     public boolean isClosed() { return closed; }
 
@@ -391,17 +272,29 @@ public void close() {
     // ─────────────── Internals ───────────────
 
     private void writeQuantized(int index, float[] vector) {
+        byte[] packed = switch (quantizationType) {
+            case SCALAR_INT8 -> quantizer.encode(vector);
+            case SCALAR_INT4 -> {
+                int[] levels = nonUniformQuantizer.encode(vector);
+                yield NibblePacker.pack(levels, dimensions);
+            }
+            case SCALAR_INT2 -> {
+                int[] levels = nonUniformQuantizer.encode(vector);
+                yield CrumbPacker.pack(levels, dimensions);
+            }
+            default -> throw new IllegalStateException("Unsupported type: " + quantizationType);
+        };
         long offset = (long) index * bytesPerVector;
-        strategy.encode(vector, segment, offset);
+        MemorySegment.copy(packed, 0, segment, ValueLayout.JAVA_BYTE, offset, bytesPerVector);
     }
 
     private void ensureOpen() {
-        if (closed) throw new SpectorSegmentClosedException();
+        if (closed) throw new IllegalStateException("QuantizedVectorStore is closed");
     }
 
     private void validateIndex(int index) {
         if (index < 0 || index >= count.get()) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_OUT_OF_RANGE, "index", 0, count.get() - 1, index);
+            throw new IndexOutOfBoundsException("index=" + index + ", size=" + count.get());
         }
     }
 }
diff --git a/spector-storage/src/main/java/com/spectrayan/spector/storage/ShardedIndexFormat.java b/spector-storage/src/main/java/com/spectrayan/spector/storage/ShardedIndexFormat.java
deleted file mode 100644
index 61a554d..0000000
--- a/spector-storage/src/main/java/com/spectrayan/spector/storage/ShardedIndexFormat.java
+++ /dev/null
@@ -1,297 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.storage;
-
-import java.io.IOException;
-import java.io.RandomAccessFile;
-import java.nio.ByteBuffer;
-import java.nio.channels.FileChannel;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-import com.spectrayan.spector.commons.error.ErrorCode;
-
-/**
- * Binary format for the sharded HNSW index manifest.
- *
- * <p>Defines a self-describing manifest that catalogs a collection of
- * {@link IndexFileFormat}-compatible shard files. Each shard contains a
- * subset of nodes by index range, but all neighbor indices remain
- * <b>global</b> — the search layer resolves cross-shard references
- * transparently via {@code globalNodeIdx / nodesPerShard}.</p>
- *
- * <h3>File Layout</h3>
- * <pre>
- *   Manifest: index.spct.manifest
- *     [4B magic: "SPSI"]
- *     [4B version: 1]
- *     [4B shard_count]
- *     [4B dimensions]
- *     [4B total_node_count]
- *     [4B nodes_per_shard]
- *     [4B M]
- *     [4B maxLevel0Connections]
- *     [4B global_entry_point]
- *     [4B global_max_level]
- *     [4B similarity_function ordinal]
- *     [4B quantization_type ordinal]
- *     Per-shard entry (repeated shard_count times):
- *       [4B shard_node_count]
- *       [8B shard_file_size]
- *
- *   Shard files: index-000000.spct, index-000001.spct, ...
- *     Each uses the standard IndexFileFormat layout.
- *     Neighbor indices are GLOBAL (not shard-local).
- * </pre>
- *
- * @see IndexFileFormat
- */
-public final class ShardedIndexFormat {
-
-    /** Magic bytes: "SPSI" — Sharded SPector Index. */
-    public static final int MAGIC = 0x53505349;
-
-    /** Current manifest format version. */
-    public static final int VERSION = 1;
-
-    /** Fixed header size in the manifest (before per-shard entries). */
-    public static final int MANIFEST_HEADER_SIZE = 48; // 12 × 4 bytes
-
-    /** Size of each per-shard entry in the manifest. */
-    public static final int SHARD_ENTRY_SIZE = 12; // 4 + 8 bytes
-
-    /** Default manifest file name. */
-    public static final String MANIFEST_NAME = "index.spct.manifest";
-
-    /** Shard file name format: index-000000.spct */
-    public static final String SHARD_NAME_FORMAT = "index-%06d.spct";
-
-    /** Default shard directory name. */
-    public static final String SHARD_DIR_NAME = "index_shards";
-
-    private ShardedIndexFormat() {}
-
-    /**
-     * Immutable manifest describing the sharded index structure.
-     *
-     * @param magic              must be {@link #MAGIC}
-     * @param version            format version
-     * @param shardCount         total number of shard files
-     * @param dimensions         vector dimensionality
-     * @param totalNodeCount     total nodes across all shards
-     * @param nodesPerShard      max nodes per shard (last shard may have fewer)
-     * @param m                  HNSW M parameter
-     * @param maxLevel0Connections HNSW max layer-0 connections
-     * @param globalEntryPoint   HNSW entry point (global node index)
-     * @param globalMaxLevel     HNSW maximum level
-     * @param similarity         SimilarityFunction ordinal
-     * @param quantization       QuantizationType ordinal
-     * @param shardEntries       per-shard metadata
-     */
-    public record Manifest(
-            int magic,
-            int version,
-            int shardCount,
-            int dimensions,
-            int totalNodeCount,
-            int nodesPerShard,
-            int m,
-            int maxLevel0Connections,
-            int globalEntryPoint,
-            int globalMaxLevel,
-            int similarity,
-            int quantization,
-            ShardEntry[] shardEntries
-    ) {
-        /** Validates manifest integrity. */
-        public void validate() {
-            if (magic != MAGIC) {
-                throw new SpectorValidationException(ErrorCode.ARGUMENT_INVALID, "Invalid sharded index magic: expected 0x" + Integer.toHexString(MAGIC) + ", got 0x" + Integer.toHexString(magic));
-            }
-            if (version != VERSION) {
-                throw new SpectorValidationException(ErrorCode.ARGUMENT_INVALID, "Unsupported sharded index version: " + version + " (expected " + VERSION + ")");
-            }
-            if (shardCount <= 0 || shardCount != shardEntries.length) {
-                throw new SpectorValidationException(ErrorCode.LENGTH_MISMATCH, "header", shardCount, "entries", shardEntries.length);
-            }
-        }
-
-        /**
-         * Returns the shard index for a given global node index.
-         *
-         * @param globalNodeIdx the global node index
-         * @return shard index (0-based)
-         */
-        public int shardFor(int globalNodeIdx) {
-            return globalNodeIdx / nodesPerShard;
-        }
-
-        /**
-         * Returns the local node index within a shard.
-         *
-         * @param globalNodeIdx the global node index
-         * @return local node index within the shard
-         */
-        public int localIndex(int globalNodeIdx) {
-            return globalNodeIdx % nodesPerShard;
-        }
-
-        /**
-         * Returns the number of nodes in the given shard.
-         *
-         * @param shardIdx the shard index
-         * @return node count for that shard
-         */
-        public int shardNodeCount(int shardIdx) {
-            return shardEntries[shardIdx].nodeCount();
-        }
-    }
-
-    /**
-     * Per-shard metadata entry in the manifest.
-     *
-     * @param nodeCount number of nodes in this shard
-     * @param fileSize  byte size of the shard file on disk
-     */
-    public record ShardEntry(int nodeCount, long fileSize) {}
-
-    // ─────────────── File naming ───────────────
-
-    /**
-     * Returns the shard file name for the given shard index.
-     *
-     * @param shardIdx zero-based shard index
-     * @return file name like "index-000000.spct"
-     */
-    public static String shardFileName(int shardIdx) {
-        return String.format(SHARD_NAME_FORMAT, shardIdx);
-    }
-
-    /**
-     * Resolves the shard directory within a data directory.
-     *
-     * @param dataDir the engine data directory
-     * @return path to the shard directory
-     */
-    public static Path resolveShardDir(Path dataDir) {
-        return dataDir.resolve(SHARD_DIR_NAME);
-    }
-
-    /**
-     * Resolves the manifest file path within the shard directory.
-     *
-     * @param shardDir the shard directory
-     * @return path to the manifest file
-     */
-    public static Path resolveManifest(Path shardDir) {
-        return shardDir.resolve(MANIFEST_NAME);
-    }
-
-    // ─────────────── I/O ───────────────
-
-    /**
-     * Writes a manifest to disk.
-     *
-     * @param manifest the manifest to write
-     * @param shardDir the shard directory (created if absent)
-     * @throws IOException if writing fails
-     */
-    public static void writeManifest(Manifest manifest, Path shardDir) throws IOException {
-        Files.createDirectories(shardDir);
-        Path manifestPath = resolveManifest(shardDir);
-
-        int totalSize = MANIFEST_HEADER_SIZE + manifest.shardCount() * SHARD_ENTRY_SIZE;
-        ByteBuffer buf = ByteBuffer.allocate(totalSize);
-
-        // Header
-        buf.putInt(manifest.magic());
-        buf.putInt(manifest.version());
-        buf.putInt(manifest.shardCount());
-        buf.putInt(manifest.dimensions());
-        buf.putInt(manifest.totalNodeCount());
-        buf.putInt(manifest.nodesPerShard());
-        buf.putInt(manifest.m());
-        buf.putInt(manifest.maxLevel0Connections());
-        buf.putInt(manifest.globalEntryPoint());
-        buf.putInt(manifest.globalMaxLevel());
-        buf.putInt(manifest.similarity());
-        buf.putInt(manifest.quantization());
-
-        // Per-shard entries
-        for (ShardEntry entry : manifest.shardEntries()) {
-            buf.putInt(entry.nodeCount());
-            buf.putLong(entry.fileSize());
-        }
-
-        buf.flip();
-        try (var ch = FileChannel.open(manifestPath,
-                java.nio.file.StandardOpenOption.CREATE,
-                java.nio.file.StandardOpenOption.WRITE,
-                java.nio.file.StandardOpenOption.TRUNCATE_EXISTING)) {
-            ch.write(buf);
-            ch.force(true);
-        }
-    }
-
-    /**
-     * Reads a manifest from disk.
-     *
-     * @param shardDir the shard directory containing the manifest
-     * @return the parsed manifest
-     * @throws IOException if reading fails or the file is invalid
-     */
-    public static Manifest readManifest(Path shardDir) throws IOException {
-        Path manifestPath = resolveManifest(shardDir);
-
-        try (var raf = new RandomAccessFile(manifestPath.toFile(), "r");
-             var ch = raf.getChannel()) {
-
-            // Read header
-            ByteBuffer headerBuf = ByteBuffer.allocate(MANIFEST_HEADER_SIZE);
-            ch.read(headerBuf);
-            headerBuf.flip();
-
-            int magic = headerBuf.getInt();
-            int version = headerBuf.getInt();
-            int shardCount = headerBuf.getInt();
-            int dimensions = headerBuf.getInt();
-            int totalNodeCount = headerBuf.getInt();
-            int nodesPerShard = headerBuf.getInt();
-            int m = headerBuf.getInt();
-            int maxLevel0 = headerBuf.getInt();
-            int entryPoint = headerBuf.getInt();
-            int maxLevel = headerBuf.getInt();
-            int similarity = headerBuf.getInt();
-            int quantization = headerBuf.getInt();
-
-            // Read per-shard entries
-            ByteBuffer entryBuf = ByteBuffer.allocate(shardCount * SHARD_ENTRY_SIZE);
-            ch.read(entryBuf);
-            entryBuf.flip();
-
-            ShardEntry[] entries = new ShardEntry[shardCount];
-            for (int i = 0; i < shardCount; i++) {
-                int nodeCount = entryBuf.getInt();
-                long fileSize = entryBuf.getLong();
-                entries[i] = new ShardEntry(nodeCount, fileSize);
-            }
-
-            return new Manifest(magic, version, shardCount, dimensions,
-                    totalNodeCount, nodesPerShard, m, maxLevel0,
-                    entryPoint, maxLevel, similarity, quantization, entries);
-        }
-    }
-}
\ No newline at end of file
diff --git a/spector-storage/src/main/java/com/spectrayan/spector/storage/ShardedMappedVectorStore.java b/spector-storage/src/main/java/com/spectrayan/spector/storage/ShardedMappedVectorStore.java
deleted file mode 100644
index 687b24c..0000000
--- a/spector-storage/src/main/java/com/spectrayan/spector/storage/ShardedMappedVectorStore.java
+++ /dev/null
@@ -1,498 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.storage;
-
-import java.io.IOException;
-import java.io.RandomAccessFile;
-import java.lang.foreign.Arena;
-import java.lang.foreign.MemorySegment;
-import java.lang.foreign.ValueLayout;
-import java.nio.channels.FileChannel;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.util.Map;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.atomic.AtomicInteger;
-import java.util.concurrent.locks.ReentrantLock;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-import com.spectrayan.spector.storage.error.SpectorStoreFullException;
-import com.spectrayan.spector.storage.error.SpectorSegmentClosedException;
-import com.spectrayan.spector.commons.error.ErrorCode;
-
-/**
- * Memory-mapped vector store that spreads vectors across multiple shard files.
- *
- * <p>Each shard file holds up to {@code nodesPerShard} vectors. Shards are
- * <b>lazily allocated</b> — a new shard file is created only when the current
- * shard fills up. This eliminates the pre-allocation of the full capacity
- * upfront (which caused a 1.6 GB file for 100K × 384-dim vectors).</p>
- *
- * <p>Shard resolution is trivial: {@code shardIdx = vectorIndex / nodesPerShard},
- * {@code localIdx = vectorIndex % nodesPerShard}. This matches the HNSW index
- * sharding boundary so index shard N contains the graph for the same vectors
- * that live in vector shard N.</p>
- *
- * <h3>File Naming</h3>
- * <pre>
- *   index_shards/vectors-000000.mmap
- *   index_shards/vectors-000001.mmap
- *   ...
- * </pre>
- *
- * <h3>Thread Safety</h3>
- * <ul>
- *   <li>Concurrent reads are safe (shared arenas).</li>
- *   <li>Writes are serialized via {@link ReentrantLock}.</li>
- * </ul>
- */
-public class ShardedMappedVectorStore implements VectorStore {
-
-    private static final Logger log = LoggerFactory.getLogger(ShardedMappedVectorStore.class);
-
-    /** Shard file name format: vectors-000000.mmap */
-    private static final String SHARD_NAME_FORMAT = "vectors-%06d.mmap";
-
-    private final VectorStoreLayout layout;
-    private final int capacity;
-    private final int nodesPerShard;
-    private final Path shardDir;
-    private final Map<String, Integer> idToIndex;
-    private final AtomicInteger count;
-    private final ReentrantLock writeLock = new ReentrantLock();
-    private volatile boolean closed;
-    private volatile long lastAccessed;
-
-    /**
-     * Per-shard mmap context. Lazily allocated.
-     */
-    private static final class VectorShard {
-        final Path filePath;
-        final int shardCapacity;
-        final Arena arena;
-        final MemorySegment segment;
-        final RandomAccessFile raf;
-        final FileChannel channel;
-
-        VectorShard(Path filePath, int shardCapacity, Arena arena,
-                    MemorySegment segment, RandomAccessFile raf, FileChannel channel) {
-            this.filePath = filePath;
-            this.shardCapacity = shardCapacity;
-            this.arena = arena;
-            this.segment = segment;
-            this.raf = raf;
-            this.channel = channel;
-        }
-
-        void close() throws IOException {
-            if (segment.isMapped()) {
-                segment.force();
-                com.spectrayan.spector.commons.concurrent.MemoryPinning.unlock(segment);
-                segment.unload();
-            }
-            arena.close();
-            channel.close();
-            raf.close();
-        }
-    }
-
-    /** Lazily-growing array of shard contexts. */
-    private VectorShard[] shards;
-    private int activeShardCount;
-
-    /**
-     * Creates a sharded vector store.
-     *
-     * @param shardDir      directory for shard files (created if absent)
-     * @param dimensions    number of float elements per vector
-     * @param capacity      maximum total number of vectors
-     * @param nodesPerShard maximum vectors per shard file
-     * @throws IOException if directory creation fails
-     */
-    public ShardedMappedVectorStore(Path shardDir, int dimensions, int capacity,
-                                     int nodesPerShard) throws IOException {
-        if (capacity <= 0) throw new SpectorValidationException(ErrorCode.ARGUMENT_OUT_OF_RANGE, "capacity", 1, Integer.MAX_VALUE, capacity);
-        if (nodesPerShard <= 0) throw new SpectorValidationException(ErrorCode.ARGUMENT_OUT_OF_RANGE, "nodesPerShard", 1, Integer.MAX_VALUE, nodesPerShard);
-
-        this.layout = new VectorStoreLayout(dimensions);
-        this.capacity = capacity;
-        this.nodesPerShard = nodesPerShard;
-        this.shardDir = shardDir;
-        this.idToIndex = new ConcurrentHashMap<>(capacity);
-        this.count = new AtomicInteger(0);
-        this.closed = false;
-        this.lastAccessed = System.currentTimeMillis();
-
-        Files.createDirectories(shardDir);
-
-        int maxShards = (capacity + nodesPerShard - 1) / nodesPerShard;
-        this.shards = new VectorShard[maxShards];
-        this.activeShardCount = 0;
-
-        // Open any existing shard files (for restart recovery)
-        for (int s = 0; s < maxShards; s++) {
-            Path shardPath = shardDir.resolve(shardFileName(s));
-            if (Files.exists(shardPath)) {
-                shards[s] = openShard(shardPath, s);
-                activeShardCount = s + 1;
-            } else {
-                break; // Shards are contiguous
-            }
-        }
-
-        log.info("ShardedMappedVectorStore created: dir={}, dims={}, capacity={}, nodesPerShard={}, existingShards={}",
-                shardDir, dimensions, capacity, nodesPerShard, activeShardCount);
-    }
-
-    @Override
-    public int put(String id, float[] vector) {
-        writeLock.lock();
-        try {
-            ensureOpen();
-            this.lastAccessed = System.currentTimeMillis();
-            if (vector.length != layout.dimensions()) {
-                throw new SpectorValidationException(ErrorCode.DIMENSIONS_MISMATCH, "Expected " + layout.dimensions() + " dimensions, got " + vector.length);
-            }
-
-            // Update in-place if ID exists
-            Integer existingIndex = idToIndex.get(id);
-            if (existingIndex != null) {
-                writeVectorAt(existingIndex, vector);
-                return existingIndex;
-            }
-
-            // Allocate new slot
-            int index = count.getAndIncrement();
-            if (index >= capacity) {
-                count.decrementAndGet();
-                throw new SpectorStoreFullException(capacity);
-            }
-
-            // Ensure the target shard exists
-            int shardIdx = index / nodesPerShard;
-            ensureShardOpen(shardIdx);
-
-            writeVectorAt(index, vector);
-            idToIndex.put(id, index);
-            return index;
-        } catch (IOException e) {
-            throw new java.io.UncheckedIOException("Failed to open vector shard", e);
-        } finally {
-            writeLock.unlock();
-        }
-    }
-
-    @Override
-    public float[] get(String id) {
-        ensureOpen();
-        this.lastAccessed = System.currentTimeMillis();
-        Integer index = idToIndex.get(id);
-        return index == null ? null : readVectorAt(index);
-    }
-
-    @Override
-    public float[] getByIndex(int index) {
-        ensureOpen();
-        validateIndex(index);
-        this.lastAccessed = System.currentTimeMillis();
-        return readVectorAt(index);
-    }
-
-    @Override
-    public void getByIndex(int index, float[] dst, int dstOffset) {
-        ensureOpen();
-        validateIndex(index);
-        this.lastAccessed = System.currentTimeMillis();
-        int shardIdx = index / nodesPerShard;
-        int localIdx = index % nodesPerShard;
-        layout.readVector(shards[shardIdx].segment, localIdx, dst, dstOffset);
-    }
-
-    @Override
-    public int indexOf(String id) {
-        this.lastAccessed = System.currentTimeMillis();
-        Integer index = idToIndex.get(id);
-        return index == null ? -1 : index;
-    }
-
-    @Override
-    public int size() { return count.get(); }
-
-    @Override
-    public int dimensions() { return layout.dimensions(); }
-
-    @Override
-    public int capacity() { return capacity; }
-
-    @Override
-    public boolean isClosed() { return closed; }
-
-    /** Returns the path to the shard directory. */
-    public Path shardDir() { return shardDir; }
-
-    /** Returns the nodes-per-shard configuration. */
-    public int nodesPerShard() { return nodesPerShard; }
-
-    /** Returns the number of active (open) shard files. */
-    public int activeShardCount() { return activeShardCount; }
-
-    @Override
-    public void close() {
-        writeLock.lock();
-        try {
-            if (!closed) {
-                closed = true;
-                for (int s = 0; s < activeShardCount; s++) {
-                    if (shards[s] != null) {
-                        try {
-                            shards[s].close();
-                        } catch (IOException e) {
-                            log.warn("Error closing vector shard {}", shards[s].filePath, e);
-                        }
-                    }
-                }
-                log.info("ShardedMappedVectorStore closed: {} vectors across {} shards, dir={}",
-                        count.get(), activeShardCount, shardDir);
-            }
-        } finally {
-            writeLock.unlock();
-        }
-    }
-
-    /**
-     * Pre-touches all shard segments on virtual threads for warm page cache.
-     */
-    public void warmup() {
-        for (int s = 0; s < activeShardCount; s++) {
-            final VectorShard shard = shards[s];
-            if (shard != null && shard.segment.isMapped()) {
-                Thread.startVirtualThread(() -> {
-                    long start = System.nanoTime();
-                    try {
-                        shard.segment.load();
-                        boolean pinned = com.spectrayan.spector.commons.concurrent.MemoryPinning.lock(shard.segment);
-                        long elapsedMs = (System.nanoTime() - start) / 1_000_000;
-                        log.debug("Vector shard warmed up (pinned={}) in {} ms: {}",
-                                pinned, elapsedMs, shard.filePath);
-                    } catch (Exception e) {
-                        log.warn("Failed to warm up vector shard {}: {}", shard.filePath, e.getMessage());
-                    }
-                });
-            }
-        }
-    }
-
-    /**
-     * Evicts idle shard pages from physical memory.
-     *
-     * @param gracePeriodMs threshold of inactivity in milliseconds
-     * @return true if any shards were evicted
-     */
-    public boolean unloadIdle(long gracePeriodMs) {
-        writeLock.lock();
-        try {
-            if (closed) return false;
-            long idleMs = System.currentTimeMillis() - lastAccessed;
-            if (idleMs < gracePeriodMs) return false;
-
-            boolean evicted = false;
-            for (int s = 0; s < activeShardCount; s++) {
-                if (shards[s] != null && shards[s].segment.isMapped()) {
-                    com.spectrayan.spector.commons.concurrent.MemoryPinning.unlock(shards[s].segment);
-                    shards[s].segment.unload();
-                    evicted = true;
-                }
-            }
-            if (evicted) {
-                log.info("ShardedMappedVectorStore idle-evicted all shards (idle for {} ms)", idleMs);
-            }
-            return evicted;
-        } finally {
-            writeLock.unlock();
-        }
-    }
-
-    // ══════════════════════════════════════════════════════════════
-    // ID MAPPING PERSISTENCE (same format as MappedVectorStore)
-    // ══════════════════════════════════════════════════════════════
-
-    /** File magic: "VIDS" in ASCII. */
-    private static final int VIDS_MAGIC = 0x56494453;
-    private static final int VIDS_VERSION = 1;
-    private static final int VIDS_HEADER_BYTES = 16;
-
-    /**
-     * Saves the id→index mapping to a binary file.
-     *
-     * @param mappingPath path to write the ID mapping file
-     */
-    public void saveIdMappings(Path mappingPath) {
-        Path parent = mappingPath.getParent();
-        if (parent != null) {
-            try { Files.createDirectories(parent); } catch (IOException e) {
-                log.warn("Cannot create id-mappings directory: {}", e.getMessage());
-                return;
-            }
-        }
-
-        try (var ch = FileChannel.open(mappingPath,
-                java.nio.file.StandardOpenOption.CREATE,
-                java.nio.file.StandardOpenOption.WRITE,
-                java.nio.file.StandardOpenOption.TRUNCATE_EXISTING)) {
-
-            java.nio.ByteBuffer header = java.nio.ByteBuffer.allocate(VIDS_HEADER_BYTES);
-            header.putInt(VIDS_MAGIC);
-            header.putInt(VIDS_VERSION);
-            header.putInt(idToIndex.size());
-            header.putInt(0);
-            header.flip();
-            ch.write(header);
-
-            for (var entry : idToIndex.entrySet()) {
-                byte[] idBytes = entry.getKey().getBytes(java.nio.charset.StandardCharsets.UTF_8);
-                java.nio.ByteBuffer buf = java.nio.ByteBuffer.allocate(4 + idBytes.length + 4);
-                buf.putInt(idBytes.length);
-                buf.put(idBytes);
-                buf.putInt(entry.getValue());
-                buf.flip();
-                ch.write(buf);
-            }
-
-            ch.force(true);
-            log.info("ShardedMappedVectorStore ID mappings saved: {} entries → {}", idToIndex.size(), mappingPath);
-        } catch (IOException e) {
-            log.error("Failed to save ID mappings: {}", e.getMessage());
-        }
-    }
-
-    /**
-     * Loads id→index mappings from a binary file.
-     *
-     * @param mappingPath path to read the ID mapping file
-     */
-    public void loadIdMappings(Path mappingPath) {
-        if (mappingPath == null || !Files.exists(mappingPath)) {
-            log.info("ID mappings file not found: {}", mappingPath);
-            return;
-        }
-
-        try (var ch = FileChannel.open(mappingPath, java.nio.file.StandardOpenOption.READ)) {
-            if (ch.size() < VIDS_HEADER_BYTES) return;
-
-            java.nio.ByteBuffer header = java.nio.ByteBuffer.allocate(VIDS_HEADER_BYTES);
-            ch.read(header);
-            header.flip();
-
-            int magic = header.getInt();
-            int version = header.getInt();
-            int entryCount = header.getInt();
-            header.getInt(); // reserved
-
-            if (magic != VIDS_MAGIC || version != VIDS_VERSION) {
-                log.warn("Invalid ID mappings file header, skipping");
-                return;
-            }
-
-            int maxIdx = -1;
-            for (int i = 0; i < entryCount; i++) {
-                java.nio.ByteBuffer lenBuf = java.nio.ByteBuffer.allocate(4);
-                ch.read(lenBuf);
-                lenBuf.flip();
-                int idLen = lenBuf.getInt();
-
-                java.nio.ByteBuffer idBuf = java.nio.ByteBuffer.allocate(idLen);
-                ch.read(idBuf);
-                idBuf.flip();
-                String id = new String(idBuf.array(), 0, idLen, java.nio.charset.StandardCharsets.UTF_8);
-
-                java.nio.ByteBuffer idxBuf = java.nio.ByteBuffer.allocate(4);
-                ch.read(idxBuf);
-                idxBuf.flip();
-                int idx = idxBuf.getInt();
-
-                idToIndex.put(id, idx);
-                if (idx > maxIdx) maxIdx = idx;
-            }
-
-            if (maxIdx >= 0) {
-                count.set(maxIdx + 1);
-            }
-
-            log.info("ShardedMappedVectorStore ID mappings loaded: {} entries from {}", idToIndex.size(), mappingPath);
-        } catch (IOException e) {
-            log.error("Failed to load ID mappings: {}", e.getMessage());
-        }
-    }
-
-    // ─────────────── Internal helpers ───────────────
-
-    private void writeVectorAt(int globalIndex, float[] vector) {
-        int shardIdx = globalIndex / nodesPerShard;
-        int localIdx = globalIndex % nodesPerShard;
-        layout.writeVector(shards[shardIdx].segment, localIdx, vector);
-    }
-
-    private float[] readVectorAt(int globalIndex) {
-        int shardIdx = globalIndex / nodesPerShard;
-        int localIdx = globalIndex % nodesPerShard;
-        return layout.readVector(shards[shardIdx].segment, localIdx);
-    }
-
-    private void ensureShardOpen(int shardIdx) throws IOException {
-        if (shardIdx < activeShardCount && shards[shardIdx] != null) {
-            return; // Already open
-        }
-        // Open shards up to and including shardIdx
-        for (int s = activeShardCount; s <= shardIdx; s++) {
-            Path shardPath = shardDir.resolve(shardFileName(s));
-            shards[s] = openShard(shardPath, s);
-        }
-        activeShardCount = shardIdx + 1;
-    }
-
-    private VectorShard openShard(Path shardPath, int shardIdx) throws IOException {
-        int shardCapacity = Math.min(nodesPerShard,
-                capacity - shardIdx * nodesPerShard);
-        long totalBytes = layout.totalByteSize(shardCapacity);
-
-        var raf = new RandomAccessFile(shardPath.toFile(), "rw");
-        raf.setLength(totalBytes);
-        var channel = raf.getChannel();
-        var arena = Arena.ofShared();
-        var segment = channel.map(FileChannel.MapMode.READ_WRITE, 0, totalBytes, arena);
-
-        log.debug("Opened vector shard {}: path={}, capacity={}, bytes={}",
-                shardIdx, shardPath, shardCapacity, totalBytes);
-
-        return new VectorShard(shardPath, shardCapacity, arena, segment, raf, channel);
-    }
-
-    private static String shardFileName(int shardIdx) {
-        return String.format(SHARD_NAME_FORMAT, shardIdx);
-    }
-
-    private void ensureOpen() {
-        if (closed) throw new SpectorSegmentClosedException();
-    }
-
-    private void validateIndex(int index) {
-        if (index < 0 || index >= count.get()) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_OUT_OF_RANGE, "index", 0, count.get() - 1, index);
-        }
-    }
-}
\ No newline at end of file
diff --git a/spector-storage/src/main/java/com/spectrayan/spector/storage/VectorStore.java b/spector-storage/src/main/java/com/spectrayan/spector/storage/VectorStore.java
index 1134754..510ce63 100644
--- a/spector-storage/src/main/java/com/spectrayan/spector/storage/VectorStore.java
+++ b/spector-storage/src/main/java/com/spectrayan/spector/storage/VectorStore.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.storage;
 
 /**
@@ -30,8 +15,8 @@ public interface VectorStore extends AutoCloseable {
      * @param id     unique identifier for the vector
      * @param vector the float array (must match the store's configured dimensions)
      * @return the internal integer index assigned to this vector
-     * @throws SpectorValidationException if vector dimensions don't match
-     * @throws SpectorValidationException    if the store is full or closed
+     * @throws IllegalArgumentException if vector dimensions don't match
+     * @throws IllegalStateException    if the store is full or closed
      */
     int put(String id, float[] vector);
 
@@ -48,7 +33,7 @@ public interface VectorStore extends AutoCloseable {
      *
      * @param index the internal integer index (returned by {@link #put})
      * @return a copy of the stored float array
-     * @throws SpectorValidationException if index is invalid
+     * @throws IndexOutOfBoundsException if index is invalid
      */
     float[] getByIndex(int index);
 
@@ -58,7 +43,7 @@ public interface VectorStore extends AutoCloseable {
      * @param index     the internal integer index
      * @param dst       destination array
      * @param dstOffset offset into destination
-     * @throws SpectorValidationException if index is invalid
+     * @throws IndexOutOfBoundsException if index is invalid
      */
     void getByIndex(int index, float[] dst, int dstOffset);
 
diff --git a/spector-storage/src/main/java/com/spectrayan/spector/storage/VectorStoreLayout.java b/spector-storage/src/main/java/com/spectrayan/spector/storage/VectorStoreLayout.java
index 54a8e9d..0680584 100644
--- a/spector-storage/src/main/java/com/spectrayan/spector/storage/VectorStoreLayout.java
+++ b/spector-storage/src/main/java/com/spectrayan/spector/storage/VectorStoreLayout.java
@@ -1,26 +1,9 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.storage;
 
 import java.lang.foreign.MemoryLayout;
 import java.lang.foreign.MemorySegment;
 import java.lang.foreign.ValueLayout;
 import java.lang.invoke.VarHandle;
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-import com.spectrayan.spector.commons.error.ErrorCode;
 
 /**
  * Defines the memory layout for contiguous vector storage using Panama's
@@ -45,7 +28,7 @@ public record VectorStoreLayout(int dimensions) {
 
     public VectorStoreLayout {
         if (dimensions <= 0) {
-            throw new SpectorValidationException(ErrorCode.ARGUMENT_OUT_OF_RANGE, "dimensions", 1, Integer.MAX_VALUE, dimensions);
+            throw new IllegalArgumentException("dimensions must be positive: " + dimensions);
         }
     }
 
@@ -98,7 +81,8 @@ public long totalByteSize(int count) {
      */
     public void writeVector(MemorySegment segment, int vectorIndex, float[] vector) {
         if (vector.length != dimensions) {
-            throw new SpectorValidationException(ErrorCode.DIMENSIONS_MISMATCH, dimensions, vector.length);
+            throw new IllegalArgumentException(
+                    "Expected " + dimensions + " dimensions, got " + vector.length);
         }
         long offset = vectorOffset(vectorIndex);
         MemorySegment.copy(vector, 0, segment, ValueLayout.JAVA_FLOAT, offset, dimensions);
diff --git a/spector-storage/src/main/java/com/spectrayan/spector/storage/error/SpectorDiskIoException.java b/spector-storage/src/main/java/com/spectrayan/spector/storage/error/SpectorDiskIoException.java
deleted file mode 100644
index ab27db3..0000000
--- a/spector-storage/src/main/java/com/spectrayan/spector/storage/error/SpectorDiskIoException.java
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.storage.error;
-
-import com.spectrayan.spector.commons.error.*;
-
-/**
- * Exception thrown when a disk read, write, or sync operation fails.
- *
- * @see SpectorStorageException
- */
-public class SpectorDiskIoException extends SpectorStorageException {
-
-    private final String details;
-
-    public SpectorDiskIoException(String details) {
-        super(ErrorCode.DISK_IO_FAILED, details);
-        this.details = details;
-    }
-
-    public SpectorDiskIoException(String details, Throwable cause) {
-        super(ErrorCode.DISK_IO_FAILED, cause, details);
-        this.details = details;
-    }
-
-    /** Returns the details of the disk I/O failure. */
-    public String getDetails() {
-        return details;
-    }
-}
diff --git a/spector-storage/src/main/java/com/spectrayan/spector/storage/error/SpectorMmapException.java b/spector-storage/src/main/java/com/spectrayan/spector/storage/error/SpectorMmapException.java
deleted file mode 100644
index 14720b2..0000000
--- a/spector-storage/src/main/java/com/spectrayan/spector/storage/error/SpectorMmapException.java
+++ /dev/null
@@ -1,51 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.storage.error;
-
-import com.spectrayan.spector.commons.error.*;
-
-/**
- * Exception thrown when a memory-mapped file creation or mapping fails.
- *
- * @see SpectorStorageException
- */
-public class SpectorMmapException extends SpectorStorageException {
-
-    private final String path;
-    private final String details;
-
-    public SpectorMmapException(String path, String details) {
-        super(ErrorCode.MMAP_FAILED, path + ": " + details);
-        this.path = path;
-        this.details = details;
-    }
-
-    public SpectorMmapException(String path, String details, Throwable cause) {
-        super(ErrorCode.MMAP_FAILED, cause, path + ": " + details);
-        this.path = path;
-        this.details = details;
-    }
-
-    /** Returns the path of the file that failed to map. */
-    public String getPath() {
-        return path;
-    }
-
-    /** Returns details of the mapping failure. */
-    public String getDetails() {
-        return details;
-    }
-}
diff --git a/spector-storage/src/main/java/com/spectrayan/spector/storage/error/SpectorSegmentClosedException.java b/spector-storage/src/main/java/com/spectrayan/spector/storage/error/SpectorSegmentClosedException.java
deleted file mode 100644
index 5bc37d1..0000000
--- a/spector-storage/src/main/java/com/spectrayan/spector/storage/error/SpectorSegmentClosedException.java
+++ /dev/null
@@ -1,34 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.storage.error;
-
-import com.spectrayan.spector.commons.error.*;
-
-/**
- * Exception thrown when an operation is attempted on a closed memory segment or store.
- *
- * @see SpectorStorageException
- */
-public class SpectorSegmentClosedException extends SpectorStorageException {
-
-    public SpectorSegmentClosedException() {
-        super(ErrorCode.SEGMENT_CLOSED);
-    }
-
-    public SpectorSegmentClosedException(Throwable cause) {
-        super(ErrorCode.SEGMENT_CLOSED, cause);
-    }
-}
diff --git a/spector-storage/src/main/java/com/spectrayan/spector/storage/error/SpectorStoreFullException.java b/spector-storage/src/main/java/com/spectrayan/spector/storage/error/SpectorStoreFullException.java
deleted file mode 100644
index f734e0d..0000000
--- a/spector-storage/src/main/java/com/spectrayan/spector/storage/error/SpectorStoreFullException.java
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.storage.error;
-
-import com.spectrayan.spector.commons.error.*;
-
-/**
- * Exception thrown when the vector store has reached its capacity limits.
- *
- * @see SpectorStorageException
- */
-public class SpectorStoreFullException extends SpectorStorageException {
-
-    private final int maxCapacity;
-
-    public SpectorStoreFullException(int maxCapacity) {
-        super(ErrorCode.STORE_FULL, maxCapacity);
-        this.maxCapacity = maxCapacity;
-    }
-
-    public SpectorStoreFullException(int maxCapacity, Throwable cause) {
-        super(ErrorCode.STORE_FULL, cause, maxCapacity);
-        this.maxCapacity = maxCapacity;
-    }
-
-    /** Returns the maximum capacity of the vector store. */
-    public int getMaxCapacity() {
-        return maxCapacity;
-    }
-}
diff --git a/spector-storage/src/main/java/com/spectrayan/spector/storage/error/SpectorWalException.java b/spector-storage/src/main/java/com/spectrayan/spector/storage/error/SpectorWalException.java
deleted file mode 100644
index 2996729..0000000
--- a/spector-storage/src/main/java/com/spectrayan/spector/storage/error/SpectorWalException.java
+++ /dev/null
@@ -1,53 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.storage.error;
-
-import com.spectrayan.spector.commons.error.*;
-
-/**
- * Exception thrown when a write-ahead log (WAL) write or replay operation fails.
- *
- * @see SpectorStorageException
- */
-public class SpectorWalException extends SpectorStorageException {
-
-    private final String details;
-
-    public SpectorWalException(String details) {
-        super(ErrorCode.WAL_WRITE_FAILED, details);
-        this.details = details;
-    }
-
-    public SpectorWalException(String details, Throwable cause) {
-        super(ErrorCode.WAL_WRITE_FAILED, cause, details);
-        this.details = details;
-    }
-
-    public SpectorWalException(ErrorCode errorCode, String details) {
-        super(errorCode, details);
-        this.details = details;
-    }
-
-    public SpectorWalException(ErrorCode errorCode, Throwable cause, String details) {
-        super(errorCode, cause, details);
-        this.details = details;
-    }
-
-    /** Returns the details of the WAL failure. */
-    public String getDetails() {
-        return details;
-    }
-}
diff --git a/spector-storage/src/main/java/com/spectrayan/spector/storage/package-info.java b/spector-storage/src/main/java/com/spectrayan/spector/storage/package-info.java
index b690d6a..85266e1 100644
--- a/spector-storage/src/main/java/com/spectrayan/spector/storage/package-info.java
+++ b/spector-storage/src/main/java/com/spectrayan/spector/storage/package-info.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 /**
  * Spector Storage — Panama MemorySegment-based zero-copy vector and document storage.
  *
diff --git a/spector-storage/src/test/java/com/spectrayan/spector/storage/DocumentStorePersistenceTest.java b/spector-storage/src/test/java/com/spectrayan/spector/storage/DocumentStorePersistenceTest.java
deleted file mode 100644
index 6291767..0000000
--- a/spector-storage/src/test/java/com/spectrayan/spector/storage/DocumentStorePersistenceTest.java
+++ /dev/null
@@ -1,111 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.storage;
-
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.io.TempDir;
-
-import java.nio.file.Path;
-import java.util.Map;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-/**
- * Tests DocumentStore binary save/load round-trip.
- */
-class DocumentStorePersistenceTest {
-
-    @TempDir
-    Path tmpDir;
-
-    @Test
-    void saveAndLoad_preservesAllDocumentFields() {
-        Path file = tmpDir.resolve("documents.dat");
-
-        // Create and populate
-        DocumentStore original = new DocumentStore();
-        original.put(new Document("doc-1", "Title One", "Content of document one",
-                Map.of("author", "Alice", "version", "1.0")));
-        original.put(new Document("doc-2", "Title Two", "Content of document two",
-                Map.of()));
-        original.put(Document.of("doc-3", "Simple content only"));
-
-        // Save
-        original.save(file);
-
-        // Load
-        DocumentStore loaded = DocumentStore.load(file);
-
-        // Verify
-        assertThat(loaded.size()).isEqualTo(3);
-
-        Document d1 = loaded.get("doc-1");
-        assertThat(d1).isNotNull();
-        assertThat(d1.title()).isEqualTo("Title One");
-        assertThat(d1.content()).isEqualTo("Content of document one");
-        assertThat(d1.metadata()).containsEntry("author", "Alice");
-        assertThat(d1.metadata()).containsEntry("version", "1.0");
-
-        Document d2 = loaded.get("doc-2");
-        assertThat(d2).isNotNull();
-        assertThat(d2.title()).isEqualTo("Title Two");
-        assertThat(d2.metadata()).isEmpty();
-
-        Document d3 = loaded.get("doc-3");
-        assertThat(d3).isNotNull();
-        assertThat(d3.content()).isEqualTo("Simple content only");
-    }
-
-    @Test
-    void load_missingFile_returnsEmptyStore() {
-        DocumentStore loaded = DocumentStore.load(tmpDir.resolve("nonexistent.dat"));
-        assertThat(loaded.size()).isEqualTo(0);
-    }
-
-    @Test
-    void load_nullPath_returnsEmptyStore() {
-        DocumentStore loaded = DocumentStore.load(null);
-        assertThat(loaded.size()).isEqualTo(0);
-    }
-
-    @Test
-    void saveAndLoad_unicodeContent() {
-        Path file = tmpDir.resolve("docs_unicode.dat");
-
-        DocumentStore original = new DocumentStore();
-        original.put(new Document("uni-1", "日本語タイトル", "这是中文内容 🎉",
-                Map.of("language", "multi")));
-
-        original.save(file);
-        DocumentStore loaded = DocumentStore.load(file);
-
-        assertThat(loaded.size()).isEqualTo(1);
-        Document d = loaded.get("uni-1");
-        assertThat(d.title()).isEqualTo("日本語タイトル");
-        assertThat(d.content()).isEqualTo("这是中文内容 🎉");
-    }
-
-    @Test
-    void saveAndLoad_emptyStore() {
-        Path file = tmpDir.resolve("docs_empty.dat");
-
-        DocumentStore original = new DocumentStore();
-        original.save(file);
-
-        DocumentStore loaded = DocumentStore.load(file);
-        assertThat(loaded.size()).isEqualTo(0);
-    }
-}
diff --git a/spector-storage/src/test/java/com/spectrayan/spector/storage/DocumentStoreTest.java b/spector-storage/src/test/java/com/spectrayan/spector/storage/DocumentStoreTest.java
index 2d2782e..3cb7985 100644
--- a/spector-storage/src/test/java/com/spectrayan/spector/storage/DocumentStoreTest.java
+++ b/spector-storage/src/test/java/com/spectrayan/spector/storage/DocumentStoreTest.java
@@ -1,18 +1,3 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.storage;
 
 import static org.assertj.core.api.Assertions.assertThat;
diff --git a/spector-storage/src/test/java/com/spectrayan/spector/storage/InMemoryVectorStoreTest.java b/spector-storage/src/test/java/com/spectrayan/spector/storage/InMemoryVectorStoreTest.java
index 615aefb..a13a199 100644
--- a/spector-storage/src/test/java/com/spectrayan/spector/storage/InMemoryVectorStoreTest.java
+++ b/spector-storage/src/test/java/com/spectrayan/spector/storage/InMemoryVectorStoreTest.java
@@ -1,24 +1,5 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.storage;
 
-import com.spectrayan.spector.commons.error.SpectorException;
-import com.spectrayan.spector.storage.error.SpectorStoreFullException;
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import static org.assertj.core.api.Assertions.within;
@@ -108,7 +89,7 @@ void getNonexistentReturnsNull() {
     void wrongDimensionsThrows() {
         try (var store = new InMemoryVectorStore(3, 10)) {
             assertThatThrownBy(() -> store.put("x", new float[]{1f, 2f}))
-                    .isInstanceOf(SpectorValidationException.class)
+                    .isInstanceOf(IllegalArgumentException.class)
                     .hasMessageContaining("3");
         }
     }
@@ -119,8 +100,8 @@ void fullStoreThrows() {
             store.put("a", new float[]{1f, 2f});
             store.put("b", new float[]{3f, 4f});
             assertThatThrownBy(() -> store.put("c", new float[]{5f, 6f}))
-                    .isInstanceOf(SpectorStoreFullException.class)
-                    .hasMessageContaining("Vector store has reached capacity");
+                    .isInstanceOf(IllegalStateException.class)
+                    .hasMessageContaining("full");
         }
     }
 
@@ -132,7 +113,7 @@ void closedStoreThrows() {
 
         assertThat(store.isClosed()).isTrue();
         assertThatThrownBy(() -> store.get("a"))
-                .isInstanceOf(SpectorException.class);
+                .isInstanceOf(IllegalStateException.class);
     }
 
     @ParameterizedTest
diff --git a/spector-storage/src/test/java/com/spectrayan/spector/storage/MappedVectorStoreIdRecoveryTest.java b/spector-storage/src/test/java/com/spectrayan/spector/storage/MappedVectorStoreIdRecoveryTest.java
deleted file mode 100644
index eac5bb5..0000000
--- a/spector-storage/src/test/java/com/spectrayan/spector/storage/MappedVectorStoreIdRecoveryTest.java
+++ /dev/null
@@ -1,97 +0,0 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.spectrayan.spector.storage;
-
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.io.TempDir;
-
-import java.io.IOException;
-import java.nio.file.Path;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-/**
- * Tests MappedVectorStore ID mapping save/load round-trip.
- */
-class MappedVectorStoreIdRecoveryTest {
-
-    @TempDir
-    Path tmpDir;
-
-    @Test
-    void saveAndLoadIdMappings_preservesLookups() throws IOException {
-        Path vectorFile = tmpDir.resolve("vectors.mmap");
-        Path idFile = tmpDir.resolve("id-mappings.dat");
-
-        int dims = 4;
-        int capacity = 100;
-
-        // Create, put vectors, save ID mappings
-        try (var store = new MappedVectorStore(vectorFile, dims, capacity)) {
-            store.put("vec-alpha", new float[]{1.0f, 2.0f, 3.0f, 4.0f});
-            store.put("vec-beta", new float[]{5.0f, 6.0f, 7.0f, 8.0f});
-            store.put("vec-gamma", new float[]{9.0f, 10.0f, 11.0f, 12.0f});
-
-            assertThat(store.size()).isEqualTo(3);
-            assertThat(store.indexOf("vec-alpha")).isEqualTo(0);
-            assertThat(store.indexOf("vec-beta")).isEqualTo(1);
-            assertThat(store.indexOf("vec-gamma")).isEqualTo(2);
-
-            store.saveIdMappings(idFile);
-        }
-
-        // Reopen and load ID mappings — simulating a JVM restart
-        try (var store = new MappedVectorStore(vectorFile, dims, capacity)) {
-            // Before loading, idToIndex is empty
-            assertThat(store.indexOf("vec-alpha")).isEqualTo(-1);
-
-            // Load ID mappings
-            store.loadIdMappings(idFile);
-
-            // Now lookups should work
-            assertThat(store.size()).isEqualTo(3);
-            assertThat(store.indexOf("vec-alpha")).isEqualTo(0);
-            assertThat(store.indexOf("vec-beta")).isEqualTo(1);
-            assertThat(store.indexOf("vec-gamma")).isEqualTo(2);
-
-            // Verify vector data survived via mmap
-            float[] alpha = store.get("vec-alpha");
-            assertThat(alpha).isNotNull();
-            assertThat(alpha).containsExactly(1.0f, 2.0f, 3.0f, 4.0f);
-
-            float[] gamma = store.get("vec-gamma");
-            assertThat(gamma).containsExactly(9.0f, 10.0f, 11.0f, 12.0f);
-        }
-    }
-
-    @Test
-    void loadIdMappings_missingFile_noOp() throws IOException {
-        Path vectorFile = tmpDir.resolve("vectors2.mmap");
-        try (var store = new MappedVectorStore(vectorFile, 4, 10)) {
-            store.loadIdMappings(tmpDir.resolve("nonexistent.dat"));
-            assertThat(store.size()).isEqualTo(0);
-        }
-    }
-
-    @Test
-    void loadIdMappings_nullPath_noOp() throws IOException {
-        Path vectorFile = tmpDir.resolve("vectors3.mmap");
-        try (var store = new MappedVectorStore(vectorFile, 4, 10)) {
-            store.loadIdMappings(null);
-            assertThat(store.size()).isEqualTo(0);
-        }
-    }
-}
diff --git a/spector-storage/src/test/java/com/spectrayan/spector/storage/MappedVectorStoreTest.java b/spector-storage/src/test/java/com/spectrayan/spector/storage/MappedVectorStoreTest.java
index 6eb352f..d9ad9f4 100644
--- a/spector-storage/src/test/java/com/spectrayan/spector/storage/MappedVectorStoreTest.java
+++ b/spector-storage/src/test/java/com/spectrayan/spector/storage/MappedVectorStoreTest.java
@@ -1,23 +1,5 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.storage;
 
-import com.spectrayan.spector.commons.error.SpectorException;
-import com.spectrayan.spector.storage.error.SpectorStoreFullException;
-
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import static org.assertj.core.api.Assertions.within;
@@ -83,7 +65,7 @@ void dataPersistsThroughCloseAndReopen() throws IOException {
             float[] raw = store.getByIndex(0);
             // This will throw because count=0 after reopen
             // We verify the file persisted the bytes by re-putting and checking
-        } catch (com.spectrayan.spector.commons.error.SpectorValidationException expected) {
+        } catch (IndexOutOfBoundsException expected) {
             // Expected — count resets to 0 on reopen
         }
     }
@@ -107,8 +89,7 @@ void fullStoreThrows() throws IOException {
             store.put("a", new float[]{1f, 2f});
             store.put("b", new float[]{3f, 4f});
             assertThatThrownBy(() -> store.put("c", new float[]{5f, 6f}))
-                    .isInstanceOf(SpectorStoreFullException.class)
-                    .hasMessageContaining("Vector store has reached capacity");
+                    .isInstanceOf(IllegalStateException.class);
         }
     }
 
@@ -138,25 +119,7 @@ void closedStoreThrows() throws IOException {
         store.close();
         assertThat(store.isClosed()).isTrue();
         assertThatThrownBy(() -> store.get("a"))
-                .isInstanceOf(SpectorException.class);
-    }
-
-    @Test
-    void unloadIdleGracePeriod() throws IOException, InterruptedException {
-        Path file = tempDir.resolve("vectors.bin");
-        try (var store = new MappedVectorStore(file, 3, 100)) {
-            store.put("doc-1", new float[]{1f, 2f, 3f});
-
-            // 1. Should NOT evict if checked immediately (gracePeriod = 10 seconds)
-            boolean evicted = store.unloadIdle(10_000);
-            assertThat(evicted).isFalse();
-
-            // 2. Sleep for 15 milliseconds, then request eviction with a 5 ms grace period.
-            // This should trigger eviction.
-            Thread.sleep(15);
-            boolean evictedAfterIdle = store.unloadIdle(5);
-            assertThat(evictedAfterIdle).isTrue();
-        }
+                .isInstanceOf(IllegalStateException.class);
     }
 
     private static float[] randomVector(int dim, long seed) {
diff --git a/spector-storage/src/test/java/com/spectrayan/spector/storage/QuantizedVectorStoreTest.java b/spector-storage/src/test/java/com/spectrayan/spector/storage/QuantizedVectorStoreTest.java
index 626d3e9..c9f47e0 100644
--- a/spector-storage/src/test/java/com/spectrayan/spector/storage/QuantizedVectorStoreTest.java
+++ b/spector-storage/src/test/java/com/spectrayan/spector/storage/QuantizedVectorStoreTest.java
@@ -1,22 +1,5 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.storage;
 
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertNull;
@@ -24,11 +7,11 @@
 import static org.junit.jupiter.api.Assertions.assertTrue;
 import org.junit.jupiter.api.Test;
 
-import com.spectrayan.spector.core.quantization.CrumbPacker;
-import com.spectrayan.spector.core.quantization.NibblePacker;
-import com.spectrayan.spector.core.quantization.NonUniformQuantizer;
-import com.spectrayan.spector.core.quantization.QuantizationType;
-import com.spectrayan.spector.core.quantization.ScalarQuantizer;
+import com.spectrayan.spector.core.CrumbPacker;
+import com.spectrayan.spector.core.NibblePacker;
+import com.spectrayan.spector.core.NonUniformQuantizer;
+import com.spectrayan.spector.core.QuantizationType;
+import com.spectrayan.spector.core.ScalarQuantizer;
 
 /**
  * Tests for {@link QuantizedVectorStore} covering INT8 backward compatibility,
@@ -210,25 +193,25 @@ void int2_multipleVectors() {
 
     @Test
     void rejectsNullQuantizationType() {
-        assertThrows(SpectorValidationException.class,
+        assertThrows(IllegalArgumentException.class,
                 () -> new QuantizedVectorStore(DIMS, CAPACITY, null, null, null));
     }
 
     @Test
     void rejectsMissingScalarQuantizerForInt8() {
-        assertThrows(SpectorValidationException.class,
+        assertThrows(IllegalArgumentException.class,
                 () -> new QuantizedVectorStore(DIMS, CAPACITY, QuantizationType.SCALAR_INT8, null, null));
     }
 
     @Test
     void rejectsMissingNonUniformQuantizerForInt4() {
-        assertThrows(SpectorValidationException.class,
+        assertThrows(IllegalArgumentException.class,
                 () -> new QuantizedVectorStore(DIMS, CAPACITY, QuantizationType.SCALAR_INT4, null, null));
     }
 
     @Test
     void rejectsMissingNonUniformQuantizerForInt2() {
-        assertThrows(SpectorValidationException.class,
+        assertThrows(IllegalArgumentException.class,
                 () -> new QuantizedVectorStore(DIMS, CAPACITY, QuantizationType.SCALAR_INT2, null, null));
     }
 
@@ -237,7 +220,7 @@ void rejectsDimensionMismatchForInt4() {
         float[][] samples = generateSamples(50, 16);
         NonUniformQuantizer nuq = NonUniformQuantizer.calibrate(samples, 16, 16);
 
-        assertThrows(SpectorValidationException.class,
+        assertThrows(IllegalArgumentException.class,
                 () -> new QuantizedVectorStore(DIMS, CAPACITY, QuantizationType.SCALAR_INT4, null, nuq));
     }
 
@@ -247,7 +230,7 @@ void rejectsWrongLevelsForInt4() {
         // Calibrate with 4 levels but try to use with INT4 (needs 16)
         NonUniformQuantizer nuq = NonUniformQuantizer.calibrate(samples, DIMS, 4);
 
-        assertThrows(SpectorValidationException.class,
+        assertThrows(IllegalArgumentException.class,
                 () -> new QuantizedVectorStore(DIMS, CAPACITY, QuantizationType.SCALAR_INT4, null, nuq));
     }
 
@@ -257,7 +240,7 @@ void rejectsWrongLevelsForInt2() {
         // Calibrate with 16 levels but try to use with INT2 (needs 4)
         NonUniformQuantizer nuq = NonUniformQuantizer.calibrate(samples, DIMS, 16);
 
-        assertThrows(SpectorValidationException.class,
+        assertThrows(IllegalArgumentException.class,
                 () -> new QuantizedVectorStore(DIMS, CAPACITY, QuantizationType.SCALAR_INT2, null, nuq));
     }
 
diff --git a/spector-storage/src/test/java/com/spectrayan/spector/storage/VectorStoreLayoutTest.java b/spector-storage/src/test/java/com/spectrayan/spector/storage/VectorStoreLayoutTest.java
index 1a87818..ce3843d 100644
--- a/spector-storage/src/test/java/com/spectrayan/spector/storage/VectorStoreLayoutTest.java
+++ b/spector-storage/src/test/java/com/spectrayan/spector/storage/VectorStoreLayoutTest.java
@@ -1,22 +1,5 @@
-/*
- * Copyright 2026 Spectrayan
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package com.spectrayan.spector.storage;
 
-import com.spectrayan.spector.commons.error.SpectorValidationException;
-
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 
@@ -59,8 +42,8 @@ void totalByteSize() {
     @Test
     void invalidDimensionsThrows() {
         assertThatThrownBy(() -> new VectorStoreLayout(0))
-                .isInstanceOf(SpectorValidationException.class);
+                .isInstanceOf(IllegalArgumentException.class);
         assertThatThrownBy(() -> new VectorStoreLayout(-1))
-                .isInstanceOf(SpectorValidationException.class);
+                .isInstanceOf(IllegalArgumentException.class);
     }
 }
diff --git a/spector.yml.example b/spector.yml.example
deleted file mode 100644
index 51c4407..0000000
--- a/spector.yml.example
+++ /dev/null
@@ -1,38 +0,0 @@
-# ═══════════════════════════════════════════════════════════════════════
-# Spector — Configuration Example
-# ═══════════════════════════════════════════════════════════════════════
-# Copy this file to spector.yml and customize for your environment.
-# Values here override the bundled spector-defaults.yml.
-# CLI args (--dims, --ollama-model, etc.) override values in this file.
-# ═══════════════════════════════════════════════════════════════════════
-
-spector:
-  engine:
-    dimensions: 768
-    capacity: 100000
-    similarity: COSINE
-    index-type: HNSW
-    persistence-mode: DISK
-    data-directory: .spector-data
-
-  embedding:
-    model: nomic-embed-text
-    base-url: http://localhost:11434
-    timeout: 30s
-    batch-size: 32
-
-  hnsw:
-    m: 16
-    ef-construction: 200
-    ef-search: 50
-
-  memory:
-    enabled: false
-    persistence-path: .spector-memory
-
-  ingestion:
-    root-directory: .
-    file-pattern: "**/*.md"
-    skip-dirs: ".git,.idea,.mvn,target,node_modules,.github"
-    chunk-size: 800
-    chunk-overlap: 100
diff --git a/src/license/apache2-header.txt b/src/license/apache2-header.txt
deleted file mode 100644
index 5c77cd9..0000000
--- a/src/license/apache2-header.txt
+++ /dev/null
@@ -1,13 +0,0 @@
-Copyright ${year} Spectrayan
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.