Research-Stack/4-Infrastructure/infra/ene_cognitive_refactor_plan.md

ENE Cognitive Refactoring Plan

Date: May 5, 2026 (restructured May 6, 2026) Domain: ENE (Endless Node Edges) Infrastructure Purpose: Integrate Cognitive Physics equations to enhance ENE performance, security, and semantic awareness using existing code as the foundation.

---

Part I — Provable Components (Grounded in Existing Code)

Each component below maps to a specific file, function, or table in the repository. The "Action" column describes the concrete diff — what to add, change, or replace.

---

1. Cognitive Load Monitor (Eq 739)

Equation: L_total = λ_I·l_I + λ_E·l_E − λ_G·l_G + λ_R·l_R + λ_M·l_M + λ_inv·l_inv + λ_traj·l_traj + λ_aci·l_aci

Existing code to instrument:

File	Location	Metric
4-Infrastructure/infra/ene_api.py:119-128	ENESecurityManager.encrypt_data()	l_I: AES-256-GCM encrypt duration
4-Infrastructure/infra/ene_api.py:130-140	ENESecurityManager.decrypt_data()	l_I: AES-256-GCM decrypt duration
4-Infrastructure/infra/ene_api.py:142-144	ENESecurityManager.check_access()	l_aci: count of False returns per window
4-Infrastructure/infra/swarm_ene_middleware.py:101-143	SwarmENEMiddleware.check_cache()	l_R: count of return None (cache miss) per window
4-Infrastructure/infra/swarm_ene_middleware.py:258-287	SwarmENEMiddleware.get_cache_statistics()	l_M: cache_count + DB file size
4-Infrastructure/infra/ene_wiki_layer.py:379-388	revision number increment in put_page()	l_traj: revisions created per window
SQLite via os.path.getsize(db_path)	DB file size + psutil.virtual_memory()	l_M: storage footprint + RAM pressure
4-Infrastructure/infra/ene_wiki_layer.py:360-370	admit_write() rejections	l_E: rejected write attempts per window
4-Infrastructure/infra/ene_api.py:316-318	integrity check failure in retrieve_sensitive_data()	l_inv: count of integrity hash mismatches per window
N/A (negative contribution)	successful new category created or new link pattern discovered	l_G: estimated from INSERT OR REPLACE INTO ene_wiki_categories count + new ene_wiki_links target_slug discoveries per window

The extraneous component (l_E) also tracks repeated identical queries by comparing _compute_query_hash() outputs over the window. The germane component (l_G) is a negative contribution: estimated from successful schema-learning events (new categories added, new link patterns discovered).

Action:

• Add an ENELoadMonitor class (new file 4-Infrastructure/infra/ene_load_monitor.py) that:
  • Wraps calls to the above functions with timing/logging via decorators or context managers
  • Maintains a sliding window (60s default) of 8 load-component values
  • Exposes compute_total_load(operation: str, context: dict) -> float
  • The 8 λ coefficients start as equal weights (1.0 for each, -1.0 for germane) with defaults stored as a module-level dict DEFAULT_LAMBDAS
  • Calibration: after collecting (load, latency) pairs for 1 week, run scipy.stats.linregress or plain least-squares to adjust λ values. Until calibration data exists, use defaults.

Testable outcome: L_total correlates with measured p95 API latency on at least 100 samples (Pearson r > 0.7). Tracked via a CSV or SQLite log of (timestamp, L_total, p95_latency_ms) tuples written by a background collector.

Test pattern to follow: See 5-Applications/scripts/test_extremophile_constraints.py — assert-based, self-contained functions, no framework dependency.

---

2. Gap-Adaptive Cache (Eq 745, 753)

Equation: Gap = Gap_max · (1 - L_total / L_max)

Existing code to modify:

File	Location	What exists	What changes
4-Infrastructure/infra/swarm_ene_middleware.py:101-143	check_cache()	Fixed TTL expiry check (if now - created_at < ttl)	Multiply TTL by gap factor from ENELoadMonitor
4-Infrastructure/infra/swarm_ene_middleware.py:145-187	store_cache()	Stores entries with ttl column as int seconds	TTL is now int(base_ttl * gap)

Database tables already in place:

• swarm_query_cache — columns: query_hash, subjects, keywords, formal_status, results, count, confidence, semantic_vector, created_at, ttl, hit_count
• swarm_api_audit — columns: id, operation, query_hash, parameters, result_cached, result_count, execution_time_ms, created_at
• swarm_semantic_index — columns: id, query_hash, semantic_vector, domain, created_at

Action:

1. Add self.gap: float = 1.0 and self.load_monitor: ENELoadMonitor to SwarmENEMiddleware.__init__()
2. Add update_gap() method: calls self.load_monitor.compute_total_load() and sets self.gap = max(0.1, 1.0 - load / load_max)
3. In check_cache() at line 127: replace if now - created_at < ttl with if now - created_at < int(ttl * self.gap)
4. In store_cache(): caller computes gap_ttl = int(base_ttl * self.gap) before passing ttl. Do NOT multiply inside store_cache() itself (that method just writes the value it receives)
5. In get_cache_statistics() (line 258): add gap to the return dict

Testable outcome: Write a test that stores a cache entry with base_ttl=10 at gap=1.0, then sets gap=0.1, then sleeps 2 seconds before check_cache() — should return None (10 * 0.1 = 1s effective TTL < 2s elapsed). Conversely, store-before-sleep gap=1.0 should still hit. Test located in swarm_ene_middleware.py __main__ block or a separate test_ene_middleware.py.

---

3. Semantic Compression for Wiki Storage (Eq 742, 746)

Equation: Compressed(x) = Ψ_S [ Primes_64 × Context(L_total(x)) ] × Gap(L_total(x))

Existing code:

File	Location	What exists
4-Infrastructure/infra/ene_api.py:179-281	ENEAPIHook.store_sensitive_data()	Already does: Metafoam compression → Delta GCL encoding → AES-256-GCM encryption. Has use_metafoam and use_delta_gcl flags (lines 181-182). Records compression_stats including compression_ratio, field_phi, foam_score, rgflow_lawful, tags, gcl_encoding
4-Infrastructure/infra/ene_api.py:283-329	ENEAPIHook.retrieve_sensitive_data()	Decrypts and verifies integrity. Returns gcl_sequence and compression_stats
4-Infrastructure/infra/ene_api.py:190-225	compression pipeline	Calls MetafoamCompressionAdapter.compress_with_metafoam_metadata() then DeltaGCLEncoder.encode_to_delta_gcl()
4-Infrastructure/infra/ene_wiki_layer.py:150-182	make_archive_record()	Creates archive_id, content_hash, extracted_text (truncated at 10k chars), extraction_version from raw_content dict (title, slug, revision, text, author, summary, links, categories)
4-Infrastructure/infra/ene_wiki_layer.py:185-230	make_jsonl_event()	Builds JSONL event with concept_vector, genome (from genome_from_vector), bind dict (lawful flag, cost as bytes-len << 16, invariant string), provenance with attestation_hash

Action:

• In store_sensitive_data(), add a fidelity: float = 0.5 parameter. High fidelity (near 1.0) = preserve more detail = less compression. Low fidelity (near 0.0) = aggressive compression.
• The fidelity value is derived from link depth: count rows in ene_wiki_links where target_slug matches the page's slug (i.e., inbound links). Pages with many inbound links are reference pages and need higher fidelity. Pages with zero inbound links are likely orphan/utility pages and can be compressed aggressively.
• Pass fidelity as a hint to the compression tier selection (if MetafoamCompressionAdapter supports it) or as a gating flag: use_metafoam = fidelity > 0.3.
• For wiki pages: put_page() at line 372 calls make_archive_record() then passes the result to _upsert_package(). Add a step between: query inbound link count, compute fidelity, store it in the archive record's metadata.

Existing code that already works: The store_sensitive_data() method already handles the full pipeline. The enhancement adds a fidelity parameter that gates or scales the compression level.

Testable outcome: Pages with 0 inbound links achieve >40% smaller stored representation compared to full-text storage. Pages with >5 inbound links decompress to byte-exact match (SHA-256 identical) with the original text. Both measured via the compression_stats dict already returned by store_sensitive_data() and the integrity hash check in retrieve_sensitive_data() (line 316-318).

---

4. Prime-Based Concept Vectors (Eq 748, 749)

Equation: Vector(x) = M_P · p(x) · Gap where p(x) is the 64-element structural prime activation vector.

Existing code to replace:

File	Location	What exists	Problem
4-Infrastructure/infra/ene_wiki_layer.py:113-131	concept_vector_for_wiki()	14D vector from keyword counting (counts of "topology", "hash", "receipt", "proof", "lean", etc.)	Heuristic, hardcoded keywords, no learning
4-Infrastructure/infra/swarm_ene_middleware.py:77-93	_derive_semantic_vector()	14D from MD5 hashes of subjects	Nonsemantic — a hash is not a semantic representation

The 14-axis mapping (hardcoded in concept_vector_for_wiki):

axes[2]  = topology/manifold/links count         (~ mathematical structure)
axes[5]  = hash/receipt/verify count              (~ integrity/cryptography)
axes[6]  = sqlite/schema/index count              (~ data architecture)
axes[7]  = unique word count / 500                (~ lexical diversity)
axes[11] = proof/lean/theorem count               (~ formal verification)
axes[12] = categories + archive + history count   (~ organizational metadata)
axes[13] = author/provenance/attest count         (~ attribution/trust)

(Axes 0, 1, 3, 4, 8, 9, 10 are always 0.0 — unused.)

Action:

1. Define 64 structural primes that map to computable features of a wiki page:

   • Content features: text length, unique word count, average sentence length, markup density
   • Link features: outbound link count, inbound (backlink) count, link-to-text ratio, category count
   • Revision features: revision count, edit velocity (revisions/day), time since last edit, author count
   • Semantic features: specific token presence (LaTeX math blocks, code blocks, tables), heading structure depth

2. Learn a 64×14 matrix M_P by:

   • Creating a labeled dataset of similar/dissimilar page pairs (e.g., pages that link to each other are "similar")
   • Using the existing link structure (ene_wiki_links table) as ground truth
   • Training via linear regression: for each linked pair (page A → page B), minimize ||M_P · p(A) - M_P · p(B)||² where p(page) is the 64-prime activation vector

3. Replace the body of concept_vector_for_wiki() with:

   primes = compute_64_primes(title, text, links, categories)  # returns list[float] length 64
   return (M_P @ np.array(primes)).tolist()[:14]  # project to 14D
   

Preserve backward compatibility: The output format remains list[float] of length 14. All consumers (make_jsonl_event, the packages table, swarm_semantic_index) are unchanged.

Testable outcome: On a holdout set of 100 wiki page pairs (50 linked, 50 random), the cosine similarity of their concept vectors discriminates between linked and unlinked pairs with AUC > 0.80 (baseline with current keyword heuristic: TBD by running on existing wiki data).

---

5. Invariant Preservation for Security (Eq 750, 755)

Equation: L_inv_active = Σ w_i · 𝟙[broken(i, x)] · severity(i) · 𝟙[active(p_i, Gap)]

Existing invariants to gate:

File	Location	Invariant	Severity	How to check
4-Infrastructure/infra/ene_wiki_layer.py:85-97	write_receipt()	Receipt chain integrity: each revision has valid SHA-256 receipt	CRITICAL	Compare stored receipt with recomputed write_receipt(slug, revision, text, author, created_at)
4-Infrastructure/infra/ene_api.py:142-144	check_access()	Access control: clearance ≥ classification	CRITICAL	Already enforced; add audit log of any DENY
4-Infrastructure/infra/ene_api.py:146-148	compute_integrity_hash()	Data integrity: stored hash matches computed hash	CRITICAL	Already checked in retrieve_sensitive_data() line 316-318
4-Infrastructure/infra/ene_api.py:96-116	derive_key_from_semantic()	Key derivation: key derived from semantic vector has expected entropy	HIGH	Check that key has >128 bits of entropy (not all zeros/ones)
4-Infrastructure/infra/ene_wiki_layer.py:360-370	admit_write()	Content safety: no active scripts, text within size limits	HIGH	Already enforced; this is already an invariant gate

Action:

1. Create ENESecurityInvariants class (new in infra/) that wraps the above checks
2. Each check returns InvariantCheck(name, severity, passed, details)
3. Critical invariants: always run, rejection = raise ConstraintViolation (from extremophile_priors.py:29-32)
4. High-severity: run when gap > 0.2
5. Integrate into ENEAPIHook.store_sensitive_data() and retrieve_sensitive_data() as pre/post conditions

Testable outcome: All existing tests pass (especially the access control test in ene_api.py:348-349 which tests PUBLIC clearance rejection). Add invariant-specific tests following the pattern in test_extremophile_constraints.py.

---

6. HNSW Vector Search (Eq 780-782)

Existing O(N) code to replace:

File	Location	What exists	Problem
4-Infrastructure/infra/swarm_ene_middleware.py:224-240	semantic_search()	Iterates over ALL rows in swarm_semantic_index, computes _cosine_similarity() for each	O(N) brute force — linear scan of entire index
4-Infrastructure/infra/swarm_ene_middleware.py:242-249	_cosine_similarity()	Pure Python dot product + norm	Correct but slow for large N

Existing data structure to index:

• swarm_semantic_index table — each row has query_hash, semantic_vector (JSON list of 14 floats), domain, created_at

Action:

1. Implement HNSWIndex class with:

   • add_vector(vector_id: str, vector: list[float]) — inserts into HNSW layers
   • search(query: list[float], k: int = 10) -> list[tuple[str, float]] — approximate nearest neighbors
   • Parameters: M=16 (max connections), ef_construction=200, ef_search=k
   • Distance metric: cosine distance 1 - cos(v1, v2) (reuse existing _cosine_similarity)

2. Add self._hnsw_index: HNSWIndex to SwarmENEMiddleware.__init__()

3. In store_cache(): after the INSERT INTO swarm_semantic_index block (lines 168-179), call self._hnsw_index.add_vector(f"semantic_{query_hash}", semantic_vector)

4. Rewrite semantic_search() to use self._hnsw_index.search(query_vector, k=len(rows)) instead of linear scan

5. Fallback to brute force when HNSW index is empty (cold start)

Testable outcome: For 10,000 cached queries, semantic_search(query_vector, threshold=0.7) runs in <1ms (down from ~15ms brute force). Recall vs brute force at k=10: >95%.

---

7. Database Architecture — Concrete Cleanup

Current issues to fix (no net-new equations, just engineering):

File	Issue	Fix
4-Infrastructure/infra/ene_api.py:179-281	store_sensitive_data() mixes Metafoam compression, GCL encoding, AES encryption, SQLite I/O, and schema migration (ALTER TABLE for missing columns) in one 100-line method	Extract: _compress_payload(), _encrypt_payload(), _persist_sensitive()
4-Infrastructure/infra/ene_wiki_layer.py:372-453	put_page() handles admission, revision computation, link extraction, archive creation, and 3 separate SQLite writes in one method	Extract data-access layer (_insert_revision(), _update_page(), _upsert_package()) — the _upsert_package method already exists at line 328
4-Infrastructure/infra/swarm_ene_middleware.py:41-67	_init_middleware_tables() creates tables but has no version tracking	Add schema_version row to each table creation block
4-Infrastructure/infra/ene_api.py:240-246	Runtime ALTER TABLE for schema evolution	Move to a _migrate_schema() method called from __init__(), not from store_sensitive_data()

Note on SQLite concurrency: 4-Infrastructure/infra/swarm_ene_middleware.py already uses plain sqlite3.connect() (synchronous, one connection per call). This is correct for SQLite — do NOT add connection pooling or aiosqlite. SQLite serializes writes at the OS level; multiple concurrent connections add lock contention, not throughput.

---

8. AMVR Shell Partition (Eq 759-769)

Equations mapped to PIST primitives:

Equation	PIST primitive (existing code)	Application to ENE
Eq 759: k = floor(sqrt(n))	pist_encode(n) at 3-Mathematical-Models/pist_biological_polymorphic_shifter_v3_complete.py:159-166 returns (shell, offset)	Shell k is the complexity tier of a wiki page: n = page size in bytes. Small pages (k=0-2) = low complexity; large pages (k>10) = high complexity
Sorting within shell	pist_decode(k, t) at line 168-170 returns n = k² + t	Reversible: shell+offset ↔ page size. Not directly used for ranking, but ensures injectivity of (k, t) pairs
Eq 761: J = m + p + s	pist_mass(k, t) at line 172-174 = t · (2k+1-t)	Page "engagement mass": zero at shell edges (trivial/saturated pages), max at middle (substantive but not bloated). Use as a scoring boost for pages with mid-shell offset
Eq 769: RG flow preserves shells	pist_mirror(k, t) at line 180-182 = (k, 2k+1-t)	Eviction symmetry: mass(k, t) = mass(mirror(k, t)). Pages from each shell should be evicted in proportion to their shell width 2k+1

Action:

1. Add shell_partition(page_size_bytes: int) -> tuple[int, int] that wraps pist_encode(page_size_bytes) — returns (shell, offset)
2. In ENEWikiLayer.put_page() at line 372: after computing revision, call shell, offset = shell_partition(len(text.encode('utf-8'))) and store as part of the archive record
3. In SwarmENEMiddleware eviction logic: when evicting cache entries, group by shell partition and evict proportionally (rather than FIFO-only, which the current DELETE ... ORDER BY created_at ASC LIMIT ? pattern does)

Existing code to import from: sys.path.insert(0, ...) pattern already used in ene_api.py:35 to import from scripts/ — same approach for PIST imports.

---

9. Extremophile Constraint Layer (Eq 829-840)

Existing code — NO new implementation needed:

File	What exists
5-Applications/scripts/extremophile_priors.py (1089 lines)	Full implementation of all 12 extremophile priors with PriorResult(admissible, violated_constraint, details)
5-Applications/scripts/extremophile_priors.py:550-699	DeepExtremophilePrior.unified_check(solution_params) — runs all 12 tiers
5-Applications/scripts/extremophile_priors.py:704-764	NavierStokesConstraints.check_solution() — applies priors to PDE solutions
5-Applications/scripts/extremophile_priors.py:767-1067	MissionCriticalReliability — depth scoring and AngrySphinx adversarial defense
5-Applications/scripts/test_extremophile_constraints.py (175 lines)	5 test functions validating constraint behavior
5-Applications/scripts/extremophile_priors.py:29-32	ConstraintViolation exception — already usable

Action:

Wire the existing DeepExtremophilePrior into the ENE operation pipeline:

1. In ENEAPIHook.__init__() (line 153): add self.extremophile = DeepExtremophilePrior()
2. In store_sensitive_data() before encryption (line 231): call self.extremophile.unified_check(params) where params include:
   • temperature: hardware thermal reading (from psutil.sensors_temperatures() or env var)
   • power: estimated energy cost of the compression operation
   • time: expected operation duration
   • bits: payload size in bits
3. Reject operations that fail any constraint with ConstraintViolation
4. In put_page() (line 372): gate wiki writes through extremophile growth constraints (TuringPatternPrior — reject if wiki growth rate exceeds nutrient-like resource bounds)

Test:

python 5-Applications/scripts/test_extremophile_constraints.py

All 5 existing tests must pass. Add an ENE-specific test that verifies store_sensitive_data() rejects a payload requiring infinite energy.

---

10. Multi-Language Wiki Compression (Eq 757, 758)

Existing code:

File	Location	What exists
4-Infrastructure/infra/ene_wiki_layer.py	—	No language detection or language-aware compression. concept_vector_for_wiki() works on lowered text regardless of language
4-Infrastructure/infra/ene_api.py:179-281	store_sensitive_data()	Compression pipeline is language-agnostic

Action:

1. Add _detect_language(text: str) -> str to ene_wiki_layer.py:
   • Use a simple collections.Counter of character n-grams and a frequency table for en/ru/zh/de/ja
   • Or import an existing library if available
2. In store_sensitive_data(): add language parameter. For morphologically complex languages (ru, de): use higher compression threshold. For CJK languages (zh, ja): use lower threshold (token boundary ambiguity limits safe compression)
3. In make_archive_record() at line 150: add language field

Testable outcome: Decompression error for Russian text is within 10% of English text error at the same compression ratio.

---

Part II — Research Hypotheses

These sections from the original plan are retained as hypotheses for future investigation, NOT as implementation phases.

What makes something "mushy" and why

The original plan's sections 14-19 (Shockwave/Phonon/Photon, GCCL, Mass Number, Archive Metaphors) share a pattern:

• They name-drop physics equations but provide no concrete mapping to system metrics
• The "implementations" are self-referential: they compare the system to itself with no external ground truth
• Several reduce to trivial operations wrapped in novel terminology:
  • "Rotational phase encoding" ≈ 4-bit integer with angular interpretation
  • "Temporal to genetic transduction" ≈ hashlib.sha256(data).digest()
  • "NaNMass detection" ≈ numpy.isinf(value) or numpy.isnan(value)
  • "Predictive coding" ≈ prediction += learning_rate * error (an EMA)
  • "Spike sync coarse-graining" ≈ timestamp // bin_width

These are not inherently wrong ideas, but they are not currently falsifiable. Each hypothesis below states what evidence would move it from the "mushy" column to the "provable" column.

Hypothesis A: Cache Propagation via Lattice Metaphors

Hypothesis B: Behavioral Routing via Fingerprint Matching

Hypothesis C: Admissibility Gates for Operation Budgeting

Hypothesis D: Genotype-Phenotype Split for Wiki Pages

Hypothesis E: Time-Aware Semantic Encoding

(Detailed hypothesis statements retained from v1 of this document.)

---

Part III — Implementation Plan

Phases are sequential but partially parallelizable within phase. Each phase modifies specific files.

Phase 1: Instrumentation (Week 1-2)

Files touched:

• NEW 4-Infrastructure/infra/ene_load_monitor.py — ENELoadMonitor class
• MODIFY 4-Infrastructure/infra/ene_api.py — add timing hooks to ENESecurityManager methods
• MODIFY 4-Infrastructure/infra/swarm_ene_middleware.py — add gap field to SwarmENEMiddleware

Deliverable:

monitor = ENELoadMonitor()
load = monitor.compute_total_load("test_operation", {"size": 1024})
assert load >= 0.0, "load should be non-negative"
# load may exceed 100.0; load_max is a configurable threshold for gap calculation, not a hard bound

Phase 2: Adaptive Cache (Week 3-4)

Files touched:

• MODIFY 4-Infrastructure/infra/swarm_ene_middleware.py — gap-adaptive TTL in check_cache() and store_cache()

Deliverable: Cache hit rate under variable load improves >10% vs fixed TTL baseline.

Phase 3: Semantic Compression (Week 5-6)

Files touched:

• MODIFY 4-Infrastructure/infra/ene_api.py — fidelity-gated compression in store_sensitive_data()
• MODIFY 4-Infrastructure/infra/ene_wiki_layer.py — pass link density as fidelity hint

Deliverable: >20% storage reduction for orphan pages, <5% decompression error for heavily-linked pages.

Phase 4: Prime Concept Vectors (Week 7-8)

Files touched:

• NEW 4-Infrastructure/infra/ene_prime_vectors.py — PrimeConceptVector class with 64×14 matrix
• MODIFY 4-Infrastructure/infra/ene_wiki_layer.py — replace concept_vector_for_wiki() body

Deliverable: Semantic search with learned vectors beats keyword heuristic on labeled page-pair test set.

Phase 5: Security Invariants (Week 9-10)

Files touched:

• NEW 4-Infrastructure/infra/ene_security_invariants.py — ENESecurityInvariants class
• MODIFY 4-Infrastructure/infra/ene_api.py — integrate invariant checks

Deliverable: Zero critical invariant violations. All existing ene_api.py tests pass.

Phase 6: Vector Search & Shell Organization (Week 11-12)

Files touched:

• NEW 4-Infrastructure/infra/ene_hnsw_index.py — HNSWIndex class
• MODIFY 4-Infrastructure/infra/swarm_ene_middleware.py — replace semantic_search() linear scan
• NEW 4-Infrastructure/infra/ene_shell_partition.py — wraps PIST functions for wiki page bucketing
• MODIFY 4-Infrastructure/infra/ene_wiki_layer.py — tag pages with shell partition in archive records

Deliverable: semantic_search() on 10k+ vectors runs in <1ms. Cache eviction preserves shell proportions.

Phase 7: Extremophile Constraints & Multi-Language (Week 13-14)

Files touched:

• MODIFY 4-Infrastructure/infra/ene_api.py — wire DeepExtremophilePrior into operation gates
• MODIFY 4-Infrastructure/infra/ene_wiki_layer.py — add language detection + language-aware compression

Deliverable: Operations violating extremophile priors are rejected with traceable reason codes. Cross-language compression within 10% variance.

---

Part IV — Guardrails

Things to NOT implement as originally described

1. asyncio.LRUCache — Does not exist in Python. The original plan used it in 5+ places. Replace with collections.OrderedDict with manual eviction, or functools.lru_cache for function-level caching.

2. Do NOT add SQLite connection pooling. The existing code uses plain sqlite3.connect() per operation, which is correct. SQLite serializes writes at the OS level. Multiple concurrent aiosqlite connections would add lock contention, not throughput.

3. physics_equations.db does not exist — The original plan references it as a source for equations 739-850, but no such file exists in the repository. The equations referenced in this plan are self-contained.

4. Do NOT create 17 independent thread/process pools. The original plan assigns ThreadPoolExecutor(8) and ProcessPoolExecutor(4) to each of 15+ classes, creating hundreds of idle threads. Use a single shared executor with semaphore-gated submission.

5. Do NOT wrap sub-microsecond operations in asyncio.to_thread(). Operations like a * b, a - b, or hashlib.sha256(data).hexdigest() complete in <1μs — thread dispatch overhead (~50μs) dominates the operation cost. Reserve thread dispatch for I/O or operations taking >1ms.

6. The QueryLanguage.CYpher typo (lowercase 'p' vs enum value CYPHER) would make graph queries silently fail. If implementing graph query support, fix this at implementation time.

---

File Map

4-Infrastructure/infra/
├── ene_api.py                          [MODIFY Phases 1,3,5,7]  AES-GCM + compression
├── ene_wiki_layer.py                   [MODIFY Phases 3,4,6,7]  Wiki revisions + concept vectors
├── swarm_ene_middleware.py             [MODIFY Phases 1,2,6]    Cache + semantic search
├── ene_load_monitor.py                 [NEW Phase 1]            Cognitive load computation
├── ene_prime_vectors.py                [NEW Phase 4]            64×14 matrix learning
├── ene_hnsw_index.py                   [NEW Phase 6]            HNSW ANN search
├── ene_shell_partition.py              [NEW Phase 6]            PIST-based shell bucketing
├── ene_security_invariants.py          [NEW Phase 5]            Invariant checking + gating

5-Applications/scripts/
├── extremophile_priors.py              [USE AS-IS Phases 5,7]   12-tier constraint checking
├── test_extremophile_constraints.py    [REFERENCE for test patterns]

3-Mathematical-Models/
├── pist_biological_polymorphic_shifter_v3_complete.py  [IMPORT FROM Phase 6]  PIST encoding primitives