WARM

lib.rs                          Public Rust exports and module declarations
  |
  bindings/
  +-- node/                     Node.js bindings, configuration, DTOs and local embedder
  +-- python/                   PyO3 entry point, vector indexes and phase-vector bindings
  |
  tests/                        Engine, security, meaning and export tests
  |
  bin/                          Shipped command-line tools and servers
  +-- research/                 Benchmark, diagnostic and experiment executables
  |
  core/
  +-- engine/
  |   +-- mod.rs                WarmCore: main orchestrator
  |   +-- mutation.rs           Validated, logged transactions and replay
  |   +-- document_api.rs       Document lifecycle and bounded batches
  |   +-- query.rs              Query routing and execution
  |   +-- router.rs             Adaptive retrieval strategy selection
  |   +-- shard.rs              ShardSet, ShardManager, Shard
  |   +-- concepts.rs           Concept synthesis (clustering + bundling)
  |   +-- knowledge.rs          Triplets, sequences, analogies
  |   +-- structural.rs         Fuzzy structural queries (algebraic + materialized)
  |   +-- multi_hop.rs          Multi-hop reasoning (rule rewrite + chained lookup)
  |
  +-- cognition/
  |   +-- mod.rs                CognitionLoop: background discovery engine
  |   +-- patterns.rs           PatternScanner: relation co-occurrence analysis
  |   +-- abstraction.rs        AbstractionEngine: prototype concept discovery
  |   +-- gaps.rs               GapDetector: epistemic gap detection
  |   +-- hypothesis.rs         HypothesisEngine: gap-filler proposals
  |   +-- analogy.rs            AnalogyDetector: structural isomorphism
  |   +-- governor.rs           MemoryGovernor: dedup, forgetting, IDF refresh
  |   +-- refiner.rs            DistributionalRefiner: self-organizing atom vectors
  |   +-- loop.rs               Background thread lifecycle
  |
  +-- agency/
  |   +-- mod.rs                Goal-directed reasoning layer
  |   +-- goals.rs              Goal definition and lifecycle
  |   +-- planner.rs            Plan generation from goals
  |   +-- questions.rs          Question generation for knowledge gaps
  |   +-- self_modify.rs        Self-modification proposals
  |
  +-- entangled.rs              EntangledHVec: sparse binary hypervector type
  +-- encoding.rs               Text -> sparse vector (multiscale words and character n-grams)
  +-- experimental/             Opt-in codebooks, block codes, Bloom memory and phase graphs
  +-- hopfield.rs               Modern Hopfield network with sparse softmax
  +-- phase_resonator.rs        Resonator network for symbolic factorization
  +-- decompose.rs              Decomposer: vector decomposition
  +-- graph.rs                  Graph engine: typed relations, multi-hop BFS, temporal
  +-- documents.rs              Chunking, stemmed BM25, metadata filters, BM25/cosine score blend
  +-- schema.rs                 Store and embedding-space compatibility
  +-- durable_file.rs           Flushed atomic file publication
  +-- storage.rs                PersistentArena: mmap segmented log and generations
  +-- config.rs                 WarmConfig, MeaningConfig, CognitionConfig, and sub-configs
  +-- security.rs               SigningManager, EncryptionManager (feature-gated)
  +-- audit.rs                  AuditLog: append-only operation log
  +-- diffusion.rs              DiffusionFactorizer: score-based vector decomposition
  +-- text.rs                   TextProcessor: readability metrics
  +-- types.rs                  Shared types (RetrievalResult, ConceptCandidate, etc.)
  +-- error.rs                  WarmError enum
  +-- intersection.rs           Sparse sorted-merge intersection
  +-- atom_memory.rs            AtomMemory: concept vector store (meaning memory)
  +-- composite_memory.rs       CompositeMemory: role-bound composite vectors
  +-- triple_store.rs           TripleStore: symbolic (S, R, O) index
  +-- role.rs                   RoleRegistry: role-shift algebra
  +-- rules.rs                  RuleStore: composition rule definitions
  +-- admission.rs              AdmissionControl: fan-out gating
  +-- indexed_memory.rs         IndexedMemory: posting + IDF substrate
  +-- posting.rs                PostingShard: per-dimension posting lists
  +-- idf.rs                    IdfWeights: IDF with proportional clipping
  +-- tombstone.rs              TombstoneMap: soft-delete tracking
  +-- index/
  |   +-- mod.rs                Index traits
  |   +-- inverted.rs           Sparse inverted index for high-sparsity queries
  +-- ivf/
  |   +-- mod.rs                IVFIndex: inverted file with product quantization
  |   +-- training.rs           IVF training pipeline
  |   +-- query.rs              IVF query execution
  |   +-- kmeans.rs             K-means clustering
  |   +-- pq.rs                 Product quantization
  |   +-- nystrom.rs            Nystrom dimensionality reduction
  |   +-- inverted_list.rs      Inverted list storage
  +-- nsg/
      +-- mod.rs                NSGIndex: navigable small-world graph
      +-- training.rs           NSG construction
      +-- search.rs             Greedy graph search
      +-- graph.rs              Graph operations (KNN, pruning, centroid)

WarmCore (engine/mod.rs)
  |
  +-- atom_memory.rs            AtomMemory: concept vector store
  |     +-- indexed_memory.rs   IndexedMemory: posting lists + IDF + tombstones
  |           +-- posting.rs    PostingShard: inverted posting lists per dimension
  |           +-- idf.rs        IdfWeights: IDF weighting with proportional clipping
  |           +-- tombstone.rs  TombstoneMap: soft-delete tracking
  |
  +-- composite_memory.rs       CompositeMemory: role-bound triple vectors
  |     +-- indexed_memory.rs   (shared substrate with AtomMemory)
  |
  +-- triple_store.rs           TripleStore: symbolic (S, R, O) index
  |                             Four-way FxHash index: by_subject, by_relation,
  |                             by_object, by_composite
  |
  +-- role.rs                   RoleRegistry: role -> cyclic-shift mapping
  |                             compose(), unbind(), compose_triple()
  |
  +-- rules.rs                  RuleStore: CompositionRule definitions
  |                             Maps relation chains to derived relations
  |
  +-- admission.rs              AdmissionControl: fan-out gating
  |                             Algebraic vs. MaterializedLookup decision
  |
  +-- decompose.rs              Decomposer: vector decomposition
  |
  +-- engine/
      +-- structural.rs         fuzzy_structural_query(): algebraic + materialized paths
      +-- multi_hop.rs          multi_hop_query(): rule rewrite + chained lookup

fuzzy_structural_query(known_bindings, target_role)
  -> RoleRegistry.compose(known)          // build partial query vector
  -> CompositeMemory.overlap_scan(query)  // IDF-weighted posting intersection
  -> AdmissionControl.check(fan_out)      // gate on candidate count
     |
     +-- Algebraic path (fan_out <= limit):
     |   -> composite.bind(query)         // XOR-unbind known roles
     |   -> permute(dim - target_shift)   // inverse cyclic shift
     |   -> hopfield_cleanup(residual)    // attractor network recovery
     |      -> overlap_scan + sparse_softmax + iterate
     |   -> return (entity_id, confidence)
     |
     +-- Materialized path (fan_out > limit):
         -> TripleStore.by_composite_id() // symbolic index lookup
         -> extract target_role field
         -> return (entity_id, score)

multi_hop_query(start, [rel1, rel2, ...], ctx, rule_store)
  -> if single relation:
       single_hop -> fuzzy_structural_query
  -> if two relations + matching CompositionRule:
       rule_rewrite -> fuzzy_structural_query(derived_relation)
  -> else:
       chained_lookup -> TripleStore walk, hop by hop

public mutation
  -> validate dimensions, identifiers, limits, and complete operation list
  -> acquire transaction write gate and shard write lock
  -> serialize HMS-TXN-2 + typed mutations as one record
  -> optional authenticated encryption
  -> CRC-framed append and mmap flush
  -> apply vectors, postings, documents, triples, relations, and rule changes
  -> increment data revision