@aleph-ai/tinyaleph 1.7.2 → 1.7.3

package/backends/bioinformatics/index.js

@@ -486,6 +486,35 @@ class BioinformaticsBackend extends Backend {
   }
 }
 
+// Re-export encoding named exports
+export {
+  NUCLEOTIDE_PRIMES,
+  AMINO_ACID_PRIMES,
+  encodeDNA,
+  decodeDNA,
+  encodeRNA,
+  decodeRNA,
+  encodeProtein,
+  decodeProtein,
+} from './encoding.js';
+
+// Named exports for classes and DNA computing
+const { BindingAffinityCalculator } = binding;
+const { DNAStrand, ANDGate, ORGate, NOTGate, DNACircuit } = dnaComputing;
+
+export {
+  BioinformaticsBackend,
+  TranscriptionOperator,
+  TranslationOperator,
+  FoldingTransform,
+  BindingAffinityCalculator,
+  DNAStrand,
+  ANDGate,
+  ORGate,
+  NOTGate,
+  DNACircuit,
+};
+
 // Export everything
 export default {
   // Main backend

package/backends/index.js

@@ -4,8 +4,8 @@
 
 import { Backend } from './interface.js';
 import SemanticBackend from './semantic/index.js';
-import CryptographicBackend from './cryptographic/index.js';
-import ScientificBackend from './scientific/index.js';
+import { CryptographicBackend } from './cryptographic/index.js';
+import { ScientificBackend } from './scientific/index.js';
 
 import bioinformatics from './bioinformatics/index.js';
 

package/core/atlas/e8.js

@@ -0,0 +1,141 @@
+/**
+ * E8 Root System
+ * 
+ * 240 roots in 8D Euclidean space.
+ * Uses scaled coordinates (x2) to avoid floating point issues.
+ * - Integer roots: coordinates are ±2 or 0.
+ * - Half-integer roots: coordinates are ±1.
+ * 
+ * All roots have squared norm 8 (in scaled units), which corresponds to 2 in standard units.
+ */
+export class E8RootSystem {
+  constructor() {
+    this.roots = []; // Array<Int8Array(8)>
+    this.rootIndex = new Map(); // Map<string, number>
+    this.negationTable = [];
+
+    this._initialize();
+  }
+
+  _initialize() {
+    this.roots = this._generateAllRoots();
+    this.rootIndex = new Map(this.roots.map((r, i) => [r.join(','), i]));
+    this.negationTable = this._computeNegationTable();
+    this._verifyInvariants();
+  }
+
+  _generateAllRoots() {
+    const roots = [];
+    
+    // Type I: Integer roots (±e_i ±e_j) -> Scaled: ±2 at two positions
+    // C(8, 2) * 4 = 28 * 4 = 112
+    for (let i = 0; i < 8; i++) {
+      for (let j = i + 1; j < 8; j++) {
+        for (const si of [2, -2]) {
+          for (const sj of [2, -2]) {
+            const v = new Int8Array(8);
+            v[i] = si;
+            v[j] = sj;
+            roots.push(v);
+          }
+        }
+      }
+    }
+
+    // Type II: Half-integer roots (±1/2) -> Scaled: ±1 everywhere
+    // Must have even number of negative signs.
+    // 2^8 = 256 combinations. Half are even -> 128.
+    for (let i = 0; i < 256; i++) {
+      const v = new Int8Array(8);
+      let negCount = 0;
+      for (let bit = 0; bit < 8; bit++) {
+        if ((i >> bit) & 1) {
+          v[bit] = -1;
+          negCount++;
+        } else {
+          v[bit] = 1;
+        }
+      }
+      if (negCount % 2 === 0) {
+        roots.push(v);
+      }
+    }
+
+    return roots;
+  }
+
+  _computeNegationTable() {
+    return this.roots.map(r => {
+      const neg = r.map(x => -x);
+      const key = neg.join(',');
+      if (!this.rootIndex.has(key)) {
+        throw new Error(`Negation of root ${r} not found`);
+      }
+      return this.rootIndex.get(key);
+    });
+  }
+
+  _verifyInvariants() {
+    if (this.roots.length !== 240) {
+      throw new Error(`E8 must have 240 roots, got ${this.roots.length}`);
+    }
+    // Verify norms
+    for (const r of this.roots) {
+      const sqNorm = r.reduce((acc, x) => acc + x * x, 0);
+      if (sqNorm !== 8) {
+        throw new Error(`Root ${r} has invalid squared norm ${sqNorm} (expected 8)`);
+      }
+    }
+  }
+
+  // Public API
+
+  get numRoots() { return this.roots.length; }
+
+  getRoot(i) { return this.roots[i]; }
+
+  getNegation(i) { return this.negationTable[i]; }
+
+  innerProduct(i, j) {
+    const r1 = this.roots[i];
+    const r2 = this.roots[j];
+    let sum = 0;
+    for (let k = 0; k < 8; k++) sum += r1[k] * r2[k];
+    // Scale down: real inner product is sum / 4 (since each vec is scaled by 2)
+    return sum / 4; 
+  }
+
+  /**
+   * Get the 8 simple roots (Standard basis).
+   * Scaled by 2.
+   */
+  getSimpleRoots() {
+    const simple = [];
+    
+    // α₁ through α₆: e_i - e_{i+1} (scaled by 2)
+    for (let i = 0; i < 6; i++) {
+        const v = new Int8Array(8);
+        v[i] = 2;
+        v[i+1] = -2;
+        simple.push(v);
+    }
+    
+    // α₇ = e₆ - e₇ (scaled by 2)
+    const v6 = new Int8Array(8);
+    v6[5] = 2;
+    v6[6] = -2;
+    simple.push(v6);
+    
+    // α₈ = e₇ + e₈ (scaled by 2)
+    const a7 = new Int8Array(8);
+    a7[6] = 2;
+    a7[7] = 2;
+    simple.push(a7);
+    
+    // α₉ = ½(-1, -1, ..., -1) (scaled by 2 → all -1)
+    const a8 = new Int8Array(8).fill(-1);
+    simple.push(a8);
+    
+    return simple;
+  }
+}

package/core/atlas/graph.js

@@ -0,0 +1,162 @@
+import { Label } from './label.js';
+
+const ATLAS_VERTEX_COUNT = 96;
+
+/**
+ * Atlas of Resonance Classes
+ * 
+ * A 96-vertex graph representing the stationary configuration of the 
+ * action functional. It is the initial object for exceptional Lie groups.
+ */
+export class Atlas {
+  constructor() {
+    this.labels = [];           // Array<Label>
+    this.labelIndex = new Map(); // Map<string, number> (label.toString() -> index)
+    this.adjacency = [];        // Array<Set<number>>
+    this.tau = [];              // Array<number> (mirror pairs)
+    this.unityIndices = [];     // Array<number>
+
+    this._initialize();
+  }
+
+  _initialize() {
+    this.labels = this._generateLabels();
+    this.labelIndex = new Map(this.labels.map((l, i) => [l.toString(), i]));
+    this.adjacency = this._buildAdjacency();
+    this.tau = this._computeTau();
+    this.unityIndices = this._findUnityPositions();
+
+    this._verifyInvariants();
+  }
+
+  /**
+   * Generate all 96 canonical labels.
+   */
+  _generateLabels() {
+    const labels = [];
+    for (let e1 = 0; e1 <= 1; e1++) {
+      for (let e2 = 0; e2 <= 1; e2++) {
+        for (let e3 = 0; e3 <= 1; e3++) {
+          for (let e6 = 0; e6 <= 1; e6++) {
+            for (let e7 = 0; e7 <= 1; e7++) {
+              for (let d45 = -1; d45 <= 1; d45++) {
+                labels.push(new Label(e1, e2, e3, d45, e6, e7));
+              }
+            }
+          }
+        }
+      }
+    }
+    return labels;
+  }
+
+  /**
+   * Build adjacency list based on Hamming-1 flips.
+   */
+  _buildAdjacency() {
+    const adjacency = new Array(this.labels.length).fill(null).map(() => new Set());
+
+    this.labels.forEach((label, i) => {
+      const neighbors = this._computeNeighbors(label);
+      for (const neighbor of neighbors) {
+        const key = neighbor.toString();
+        if (this.labelIndex.has(key)) {
+          const j = this.labelIndex.get(key);
+          if (i !== j) {
+            adjacency[i].add(j);
+          }
+        }
+      }
+    });
+
+    return adjacency;
+  }
+
+  /**
+   * Compute neighbors for a single label.
+   * Flips e1, e2, e3, e6, or e4/e5 (via d45). e7 is NOT flipped (mirror).
+   */
+  _computeNeighbors(label) {
+    const { e1, e2, e3, d45, e6, e7 } = label;
+    const neighbors = [];
+
+    // Flip e1, e2, e3, e6
+    neighbors.push(new Label(1 - e1, e2, e3, d45, e6, e7));
+    neighbors.push(new Label(e1, 1 - e2, e3, d45, e6, e7));
+    neighbors.push(new Label(e1, e2, 1 - e3, d45, e6, e7));
+    neighbors.push(new Label(e1, e2, e3, d45, 1 - e6, e7));
+
+    // Flip e4 or e5 (canonical d45 transformation)
+    neighbors.push(new Label(e1, e2, e3, this._flipD45ByE4(d45), e6, e7));
+    neighbors.push(new Label(e1, e2, e3, this._flipD45ByE5(d45), e6, e7));
+
+    return neighbors;
+  }
+
+  _flipD45ByE4(d) {
+    // -1 -> 0, 0 -> 1, 1 -> 0
+    if (d === -1 || d === 1) return 0;
+    if (d === 0) return 1;
+    throw new Error(`Invalid d45: ${d}`);
+  }
+
+  _flipD45ByE5(d) {
+    // -1 -> 0, 0 -> -1, 1 -> 0
+    if (d === -1 || d === 1) return 0;
+    if (d === 0) return -1;
+    throw new Error(`Invalid d45: ${d}`);
+  }
+
+  _computeTau() {
+    return this.labels.map(label => {
+      const mirror = label.mirror();
+      return this.labelIndex.get(mirror.toString());
+    });
+  }
+
+  _findUnityPositions() {
+    return this.labels
+      .map((l, i) => l.isUnity() ? i : -1)
+      .filter(i => i !== -1);
+  }
+
+  _verifyInvariants() {
+    if (this.labels.length !== ATLAS_VERTEX_COUNT) {
+      throw new Error(`Atlas must have ${ATLAS_VERTEX_COUNT} vertices, got ${this.labels.length}`);
+    }
+    if (this.unityIndices.length !== 2) {
+      throw new Error(`Must have exactly 2 unity positions, got ${this.unityIndices.length}`);
+    }
+    // Check degrees
+    this.adjacency.forEach((neighbors, i) => {
+        const deg = neighbors.size;
+        if (deg !== 5 && deg !== 6) {
+            throw new Error(`Vertex ${i} has invalid degree ${deg}`);
+        }
+    });
+  }
+
+  // Public API
+
+  get numVertices() { return this.labels.length; }
+  
+  get numEdges() {
+    let sum = 0;
+    for (const set of this.adjacency) sum += set.size;
+    return sum / 2;
+  }
+
+  degree(v) { return this.adjacency[v].size; }
+  
+  neighbors(v) { return Array.from(this.adjacency[v]); }
+  
+  getLabel(v) { return this.labels[v]; }
+  
+  getMirror(v) { return this.tau[v]; }
+  
+  isAdjacent(v1, v2) { return this.adjacency[v1].has(v2); }
+  
+  isMirrorPair(v1, v2) { return this.tau[v1] === v2; }
+
+  getUnityPositions() { return this.unityIndices; }
+}

package/core/atlas/index.js

@@ -0,0 +1,14 @@
+import { Label } from './label.js';
+import { Atlas } from './graph.js';
+import { E8RootSystem } from './e8.js';
+
+const ATLAS = new Atlas();
+const E8 = new E8RootSystem();
+
+export {
+  Label,
+  Atlas,
+  E8RootSystem,
+  ATLAS,
+  E8
+};

package/core/atlas/label.js

@@ -0,0 +1,83 @@
+/**
+ * Atlas canonical label: (e1, e2, e3, d45, e6, e7)
+ * 
+ * - e1, e2, e3, e6, e7 ∈ {0, 1}
+ * - d45 ∈ {-1, 0, +1}
+ * 
+ * Represents the position in the Atlas of Resonance Classes.
+ */
+export class Label {
+  /**
+   * Create a new Label.
+   * @param {number} e1 - 0 or 1
+   * @param {number} e2 - 0 or 1
+   * @param {number} e3 - 0 or 1
+   * @param {number} d45 - -1, 0, or 1 (Difference e4 - e5)
+   * @param {number} e6 - 0 or 1
+   * @param {number} e7 - 0 or 1
+   */
+  constructor(e1, e2, e3, d45, e6, e7) {
+    if (![0, 1].includes(e1)) throw new Error(`Invalid e1: ${e1}`);
+    if (![0, 1].includes(e2)) throw new Error(`Invalid e2: ${e2}`);
+    if (![0, 1].includes(e3)) throw new Error(`Invalid e3: ${e3}`);
+    if (![-1, 0, 1].includes(d45)) throw new Error(`Invalid d45: ${d45}`);
+    if (![0, 1].includes(e6)) throw new Error(`Invalid e6: ${e6}`);
+    if (![0, 1].includes(e7)) throw new Error(`Invalid e7: ${e7}`);
+
+    this.e1 = e1;
+    this.e2 = e2;
+    this.e3 = e3;
+    this.d45 = d45;
+    this.e6 = e6;
+    this.e7 = e7;
+  }
+
+  /**
+   * Apply mirror transformation (flip e7).
+   * @returns {Label} New mirrored label
+   */
+  mirror() {
+    return new Label(
+      this.e1,
+      this.e2,
+      this.e3,
+      this.d45,
+      this.e6,
+      1 - this.e7
+    );
+  }
+
+  /**
+   * Check if this is a unity position.
+   * Unity requires d45=0 and e1=e2=e3=e6=0.
+   * @returns {boolean}
+   */
+  isUnity() {
+    return (
+      this.d45 === 0 &&
+      this.e1 === 0 &&
+      this.e2 === 0 &&
+      this.e3 === 0 &&
+      this.e6 === 0
+    );
+  }
+
+  /**
+   * Create a unique string key for this label (for Map/Set keys).
+   * Format: "e1,e2,e3,d45,e6,e7"
+   * @returns {string}
+   */
+  toString() {
+    return `${this.e1},${this.e2},${this.e3},${this.d45},${this.e6},${this.e7}`;
+  }
+
+  /**
+   * Parse a label string back to object.
+   * @param {string} str 
+   * @returns {Label}
+   */
+  static fromString(str) {
+    const [e1, e2, e3, d45, e6, e7] = str.split(',').map(Number);
+    return new Label(e1, e2, e3, d45, e6, e7);
+  }
+}

package/core/index.js

@@ -456,10 +456,14 @@ export * from './emotion.js';
 // Export non-local communication module (book.pdf Chapter 8)
 export * from './nonlocal.js';
 
+// Export Atlas module (atlas-embeddings)
+export * from './atlas/index.js';
+
 import * as gravity from './gravity.js';
 import * as oracle from './oracle.js';
 import * as emotion from './emotion.js';
 import * as nonlocal from './nonlocal.js';
+import { Label, Atlas, E8RootSystem, ATLAS, E8 } from './atlas/index.js';
 
 export default {
   ...gravity,
@@ -736,5 +740,13 @@ export default {
   createAlexanderModule,
   extractSignature,
   createSignatureMemory,
-  createSignatureExtractor
+  createSignatureExtractor,
+
+  // Atlas of Resonance Classes (UOR-Foundation/atlas-embeddings)
+  // 96-vertex graph, Label system, E8 root system
+  Label,
+  Atlas,
+  E8RootSystem,
+  ATLAS,
+  E8
 };

package/docs/ESM_MIGRATION_PLAN.md

@@ -0,0 +1,530 @@
+# ESM Migration Plan — `apps/sentient/lib/`
+
+> **Generated:** 2026-02-23  
+> **Scope:** All `.js` files under `apps/sentient/lib/`  
+> **Root `package.json`** has `"type": "module"` — all `.js` files must use ESM syntax.
+
+---
+
+## Table of Contents
+
+1. [Summary](#1-summary)
+2. [Already Migrated Files](#2-already-migrated-files)
+3. [Remaining CJS Files — Full Dependency Graph](#3-remaining-cjs-files--full-dependency-graph)
+4. [Cross-Package Dependencies](#4-cross-package-dependencies)
+5. [Special Cases](#5-special-cases)
+6. [Migration Batches](#6-migration-batches)
+7. [Migration Checklist per File](#7-migration-checklist-per-file)
+
+---
+
+## 1. Summary
+
+| Category | Count |
+|---|---|
+| Total `.js` files in `apps/sentient/lib/` | ~90 |
+| Already migrated to ESM | 37 |
+| Remaining CJS files | **53** |
+| Pure re-export shims | 6 |
+| Files with dynamic `require()` | 3 |
+| Files using `__dirname` / `__filename` (CJS only) | 1 |
+| Migration batches needed | 8 |
+
+---
+
+## 2. Already Migrated Files
+
+These files already use `import` / `export` syntax and need no changes:
+
+| # | File | Notes |
+|---|---|---|
+| 1 | `index.js` | Barrel — uses ESM `import` from CJS deps (will break until deps migrate) |
+| 2 | `askChaperone.js` | ESM, uses `fileURLToPath` polyfill for `__dirname` |
+| 3 | `chat.js` | ESM |
+| 4 | `lmstudio.js` | ESM |
+| 5 | `vertex-ai.js` | ESM |
+| 6 | `providers/index.js` | ESM |
+| 7 | `app/index.js` | ESM |
+| 8 | `app/args.js` | ESM |
+| 9 | `app/cli.js` | ESM |
+| 10 | `app/constants.js` | ESM |
+| 11 | `app/shared.js` | ESM |
+| 12 | `app/server.js` | ESM, uses `fileURLToPath` polyfill |
+| 13 | `app/server/index.js` | ESM |
+| 14 | `app/server/chat-handler.js` | ESM |
+| 15 | `app/server/learning-routes.js` | ESM |
+| 16 | `app/server/network-sync.js` | ESM |
+| 17 | `app/server/observer-routes.js` | ESM |
+| 18 | `app/server/provider-routes.js` | ESM |
+| 19 | `app/server/static-server.js` | ESM |
+| 20 | `app/server/stream-routes.js` | ESM |
+| 21 | `app/server/utils.js` | ESM |
+| 22 | `app/server/webrtc-routes.js` | ESM |
+| 23 | `webrtc/coordinator.js` | ESM |
+| 24 | `webrtc/index.js` | ESM |
+| 25 | `webrtc/peer.js` | ESM |
+| 26 | `webrtc/room.js` | ESM |
+| 27 | `webrtc/transport.js` | ESM |
+| 28 | `learning/chaperone.js` | ESM |
+| 29 | `learning/config.js` | ESM, uses `fileURLToPath` polyfill |
+| 30 | `learning/curiosity.js` | ESM |
+| 31 | `learning/index.js` | ESM |
+| 32 | `learning/ingester.js` | ESM |
+| 33 | `learning/learner.js` | ESM |
+| 34 | `learning/next-steps.js` | ESM |
+| 35 | `learning/query.js` | ESM |
+| 36 | `learning/reflector.js` | ESM |
+| 37 | `learning/safety-filter.js` | ESM |
+
+---
+
+## 3. Remaining CJS Files — Full Dependency Graph
+
+### Legend
+- **Imports** = what the file `require()`s
+- **Imported by** = which files `require()` this file
+- **Local** = within `apps/sentient/lib/`
+- **External** = npm packages or Node.js built-ins
+- **Cross-pkg** = from `observer/`, `core/`, `physics/`, etc.
+
+---
+
+### 3.1 Re-export Shims (6 files)
+
+These files are one-liners: `module.exports = require('...')`.
+
+| File | Re-exports From | Imported By |
+|---|---|---|
+| `smf.js` | `observer/smf` | `specialization.js`, `collective.js`, `memory-manager.js`, `symbolic-smf.js`, `symbolic-observer.js`, `sentient-core.js`, `network.js` |
+| `prsc.js` | `observer/prsc` | `sentient-core.js` |
+| `temporal.js` | `observer/temporal` | `symbolic-temporal.js`, `sentient-memory.js`, `sentient-core.js`, `symbolic-observer.js` |
+| `entanglement.js` | `observer/entanglement` | `sentient-memory.js`, `sentient-core.js` |
+| `agency.js` | `observer/agency` | `sentient-core.js` |
+| `boundary.js` | `observer/boundary` | `sentient-core.js` |
+| `safety.js` | `observer/safety` | `sentient-core.js` |
+
+### 3.2 Leaf Files (no local imports)
+
+| File | Imports (external only) | Imported By |
+|---|---|---|
+| `assays.js` | *(none)* | `index.js` (ESM) |
+| `topics.js` | *(none)* | `core.js` |
+| `processor.js` | *(none)* | `index.js` (ESM) |
+| `senses/base.js` | *(none)* | all other `senses/*.js` |
+| `quantum/math.js` | *(none)* | `quantum/analyzer.js`, `quantum/network.js`, `tools/quantum-scanner.js` |
+| `tools/file-editor/prompts.js` | *(none)* | `tools/file-editor/llmBridge.js` |
+| `tools/file-editor/patchEngine.js` | *(none)* | `tools/file-editor/index.js`, `tools/file-editor/transaction.js` |
+| `abstraction.js` | `events` | `index.js` (ESM) |
+| `agent.js` | `events` | `index.js` (ESM) |
+| `profiler.js` | `events`, `perf_hooks` | *(standalone)* |
+| `error-handler.js` | `events` | `secure-config.js` |
+| `telemetry.js` | `events`, `http` | `network.js` (dynamic) |
+| `transport/index.js` | `events` | *(standalone)* |
+| `speech.js` | `child_process`, `fs`, `path`, `https`, `http` | *(standalone)* |
+| `binary-serializer.js` | `fs`, `path`, `zlib`, `crypto` | *(standalone)* |
+| `snapshot-integrity.js` | `fs`, `path`, `crypto`, `zlib`, `util` | *(standalone)* |
+| `memory-broker.js` | `events`, `fs`, `path`, `crypto` | *(standalone)* |
+
+### 3.3 Files With Local Dependencies
+
+| File | Local Imports | Cross-Pkg Imports | External Imports | Imported By |
+|---|---|---|---|---|
+| `vocabulary.js` | *(none)* | *(none)* | `fs`, `path` | `core.js` |
+| `style.js` | *(none)* | *(none)* | `fs`, `path` | `core.js` |
+| `concepts.js` | *(none)* | *(none)* | `fs`, `path` | `core.js` |
+| `memory.js` | *(none)* | *(none)* | `fs`, `path` | `core.js` |
+| `markdown.js` | *(none)* | *(none)* | `vm` | `index.js` (ESM) |
+| `resolang.js` | *(none)* | *(none)* | `fs`, `path` | `index.js` (ESM) |
+| `enochian-vocabulary.js` | *(none)* | `core/prime` | *(none)* | `enochian.js` |
+| `learning/prompt-cache.js` | *(none)* | *(none)* | `crypto`, `fs`, `path`, `events` | *(standalone, in learning/)* |
+| `senses/chrono.js` | `senses/base` | *(none)* | *(none)* | `senses/index.js` |
+| `senses/proprio.js` | `senses/base` | *(none)* | *(none)* | `senses/index.js` |
+| `senses/network.js` | `senses/base` | *(none)* | *(none)* | `senses/index.js` |
+| `senses/user.js` | `senses/base` | *(none)* | *(none)* | `senses/index.js` |
+| `senses/sight.js` | `senses/base` | *(none)* | *(none)* | `senses/index.js` |
+| `senses/process.js` | `senses/base` | *(none)* | `os` | `senses/index.js` |
+| `senses/filesystem.js` | `senses/base` | *(none)* | `fs`, `path` | `senses/index.js` |
+| `senses/git.js` | `senses/base` | *(none)* | `child_process`, `path` | `senses/index.js` |
+| `senses/index.js` | `senses/base`, `senses/chrono`, `senses/proprio`, `senses/filesystem`, `senses/git`, `senses/process`, `senses/network`, `senses/user`, `senses/sight` | *(none)* | *(none)* | *(standalone)* |
+| `quantum/analyzer.js` | `quantum/math` | *(none)* | *(none)* | `tools/quantum-scanner.js` |
+| `quantum/network.js` | `quantum/math` | *(none)* | *(none)* | `tools/quantum-scanner.js` |
+| `tools/file-editor/llmBridge.js` | `tools/file-editor/prompts` | *(none)* | *(none)* | `tools/file-editor/index.js` |
+| `tools/file-editor/transaction.js` | `tools/file-editor/patchEngine` | *(none)* | `fs`, `path`, `crypto` | *(standalone)* |
+| `tools/file-editor/index.js` | `tools/file-editor/llmBridge`, `tools/file-editor/patchEngine` | *(none)* | `fs`, `path` | `tools.js` |
+| `tools/quantum-scanner.js` | `quantum/math`, `quantum/analyzer`, `quantum/network` | *(none)* | *(none)* | `tools.js` |
+| `core.js` | `vocabulary`, `style`, `topics`, `concepts`, `memory` | *(none)* | *(none)* | `index.js` (ESM) |
+| `enhancer.js` | `tools` | *(none)* | *(none)* | `index.js` (ESM) |
+| `tools.js` | `askChaperone` (ESM), `tools/file-editor`, `tools/quantum-scanner` | *(none)* | `fs`, `path`, `crypto`, `child_process` | `enhancer.js`, `index.js` (ESM) |
+| `specialization.js` | `smf` | *(none)* | *(none)* | `routing.js` |
+| `routing.js` | `specialization` | *(none)* | `events` | *(standalone)* |
+| `collective.js` | `smf` | *(none)* | `events` | `index.js` (ESM) |
+| `memory-manager.js` | `smf` | *(none)* | `events` | *(standalone)* |
+| `secure-config.js` | `error-handler` | *(none)* | `fs`, `path`, `crypto` | *(standalone)* |
+| `enochian.js` | `enochian-vocabulary` | *(none)* | *(none)* | `network.js`, `index.js` (ESM) |
+| `prime-calculus.js` | *(none)* | *(none)* | *(none)* | `network.js`, `index.js` (ESM) |
+| `hqe.js` | *(none)* | `core/hilbert`, `core/prime` | `crypto`, `fs`, `path`, `os` | `sentient-memory.js`, `sentient-core.js` |
+| `symbolic-smf.js` | `smf` | `core/symbols`, `core/inference`, `core/compound`, `core/resonance` | *(none)* | `symbolic-observer.js` |
+| `symbolic-temporal.js` | `temporal` | `core/rformer`, `core/symbols` | *(none)* | `symbolic-observer.js` |
+| `sentient-memory.js` | `hqe`, `entanglement`, `temporal` | `core/hilbert`, `core/rformer`, `physics/primeon_z_ladder_multi` | `fs`, `path` | `sentient-core.js` |
+| `network.js` | `smf`, `prime-calculus`, `enochian` | *(none)* | `events`, `crypto` | `index.js` (ESM) |
+| `sentient-core.js` | `smf`, `prsc`, `hqe`, `temporal`, `entanglement`, `sentient-memory`, `agency`, `boundary`, `safety` | `core/hilbert`, `core/prime`, `core/events`, `core/rformer` | *(none)* | `symbolic-observer.js` |
+| `symbolic-observer.js` | `sentient-core`, `symbolic-smf`, `symbolic-temporal`, `smf`, `temporal` | `core/symbols`, `core/inference`, `core/compound`, `core/resonance`, `core/topology` | *(none)* | `index.js` (ESM) |
+
+---
+
+## 4. Cross-Package Dependencies
+
+Files in `apps/sentient/lib/` that import from outside the directory:
+
+| Source File | External Import | Package |
+|---|---|---|
+| `smf.js` | `require('../../../observer/smf')` | `observer/` |
+| `prsc.js` | `require('../../../observer/prsc')` | `observer/` |
+| `temporal.js` | `require('../../../observer/temporal')` | `observer/` |
+| `entanglement.js` | `require('../../../observer/entanglement')` | `observer/` |
+| `agency.js` | `require('../../../observer/agency')` | `observer/` |
+| `boundary.js` | `require('../../../observer/boundary')` | `observer/` |
+| `safety.js` | `require('../../../observer/safety')` | `observer/` |
+| `hqe.js` | `require('../../../core/hilbert')`, `require('../../../core/prime')` | `core/` |
+| `enochian-vocabulary.js` | `require('../../../core/prime')` | `core/` |
+| `sentient-memory.js` | `require('../../../core/hilbert')`, `require('../../../core/rformer')`, `require('../../../physics/primeon_z_ladder_multi')` | `core/`, `physics/` |
+| `sentient-core.js` | `require('../../../core/hilbert')`, `require('../../../core/prime')`, `require('../../../core/events')`, `require('../../../core/rformer')` | `core/` |
+| `symbolic-smf.js` | `require('../../../core/symbols')`, `require('../../../core/inference')`, `require('../../../core/compound')`, `require('../../../core/resonance')` | `core/` |
+| `symbolic-temporal.js` | `require('../../../core/rformer')`, `require('../../../core/symbols')` | `core/` |
+| `symbolic-observer.js` | `require('../../../core/symbols')`, `require('../../../core/inference')`, `require('../../../core/compound')`, `require('../../../core/resonance')`, `require('../../../core/topology')` | `core/` |
+| `network.js` | `require('./telemetry')` (dynamic), `require('@sschepis/resolang')` (dynamic) | npm |
+| `prime-calculus.js` | `require('@sschepis/resolang')` (dynamic) | npm |
+
+> **Note:** The `observer/` and `core/` packages must also support ESM imports. If they still use CJS `module.exports`, the re-export shims will need `import ... from` syntax with the appropriate path + `.js` extension. The cross-package files likely use `module.exports` patterns and may need their own ESM migration, or `createRequire()` may be needed temporarily.
+
+---
+
+## 5. Special Cases
+
+### 5.1 Pure Re-export Shims (6 files)
+
+These are trivial to migrate — replace the one-liner with ESM re-export:
+
+```js
+// Before (CJS)
+module.exports = require('../../../observer/smf');
+
+// After (ESM)
+export { default } from '../../../observer/smf.js';
+// OR, if named exports are needed:
+export * from '../../../observer/smf.js';
+```
+
+**Files:** `smf.js`, `prsc.js`, `temporal.js`, `entanglement.js`, `agency.js`, `boundary.js`, `safety.js`
+
+### 5.2 Dynamic `require()` (3 files)
+
+These use `require()` inside `try/catch` for optional dependencies:
+
+| File | Dynamic Require | Migration Strategy |
+|---|---|---|
+| `network.js` (line 33) | `telemetry = require('./telemetry')` | Use dynamic `import()` in an async init or `try { const m = await import('./telemetry.js'); telemetry = m; } catch {}` |
+| `network.js` (line 41) | `resolang = require('@sschepis/resolang')` | Same dynamic `import()` pattern |
+| `prime-calculus.js` (line 25) | `resolang = require('@sschepis/resolang')` | Same dynamic `import()` pattern |
+| `enochian.js` (line 26) | `resolang = require('@sschepis/resolang')` | Same dynamic `import()` pattern |
+
+### 5.3 `__dirname` / `__filename` Usage (1 CJS file)
+
+| File | Usage | Migration |
+|---|---|---|
+| `resolang.js` (line 34) | `path.join(__dirname, ...)` | Add ESM polyfill: `const __filename = fileURLToPath(import.meta.url); const __dirname = path.dirname(__filename);` |
+
+### 5.4 Conditional `module.exports` Pattern (3 files)
+
+The `quantum/` files use `if (typeof module !== 'undefined' && module.exports)` guard:
+
+| File | Pattern |
+|---|---|
+| `quantum/math.js` | `if (typeof module !== 'undefined' && module.exports) { module.exports = {...} }` |
+| `quantum/analyzer.js` | Same pattern |
+| `quantum/network.js` | Same pattern |
+| `tools/quantum-scanner.js` | Same pattern |
+
+**Migration:** Remove the conditional, use `export { ... }` directly.
+
+### 5.5 `module.exports = { ... }` Pattern (most files)
+
+The majority of files use `module.exports = { Class1, Class2, func1 }`. Convert to:
+
+```js
+export { Class1, Class2, func1 };
+```
+
+### 5.6 `VM` module usage
+
+| File | Notes |
+|---|---|
+| `markdown.js` | Uses `const { VM } = require('vm')`. The `vm` module works in ESM — just change to `import { VM } from 'vm'`. |
+
+---
+
+## 6. Migration Batches
+
+Files must be migrated bottom-up: leaf dependencies first, then files that depend on them.
+
+### Batch 0 — Pre-requisite: Verify Cross-Package ESM Compatibility
+
+Before migrating, verify that these external packages support ESM `import`:
+- `observer/smf.js`, `observer/prsc.js`, `observer/temporal.js`, `observer/entanglement.js`, `observer/agency.js`, `observer/boundary.js`, `observer/safety.js`
+- `core/hilbert.js`, `core/prime.js`, `core/events.js`, `core/rformer.js`, `core/symbols.js`, `core/inference.js`, `core/compound.js`, `core/resonance.js`, `core/topology.js`
+- `physics/primeon_z_ladder_multi.js`
+
+If any of these still use CJS `module.exports`, they either need to be migrated first or accessed via `createRequire()` bridge.
+
+---
+
+### Batch 1 — Leaf Nodes (no local dependencies) — 23 files
+
+These files import only Node.js built-ins, npm packages, or nothing at all.
+
+| # | File | Imports | Export Pattern | Notes |
+|---|---|---|---|---|
+| 1 | `assays.js` | *(none)* | `module.exports = { ... }` | 4 classes + 1 suite |
+| 2 | `topics.js` | *(none)* | `module.exports = { TopicTracker }` | |
+| 3 | `processor.js` | *(none)* | `module.exports = { ResponseProcessor }` | |
+| 4 | `vocabulary.js` | `fs`, `path` | `module.exports = { VocabularyManager }` | |
+| 5 | `style.js` | `fs`, `path` | `module.exports = { StyleProfiler }` | |
+| 6 | `concepts.js` | `fs`, `path` | `module.exports = { ConceptGraph }` | |
+| 7 | `memory.js` | `fs`, `path` | `module.exports = { ContextMemory, ... }` | |
+| 8 | `markdown.js` | `vm` | `module.exports = { MarkdownRenderer, ... }` | |
+| 9 | `resolang.js` | `fs`, `path` | `module.exports = { ResolangLoader, ... }` | Uses `__dirname` — needs polyfill |
+| 10 | `agent.js` | `events` | `module.exports = { TaskStatus, ..., Agent, createAgent }` | Enums + classes |
+| 11 | `abstraction.js` | `events` | `module.exports = { FusionDiscoveryEngine, ... }` | |
+| 12 | `profiler.js` | `events`, `perf_hooks` | `module.exports = { ... }` | |
+| 13 | `error-handler.js` | `events` | `module.exports = { ... }` | |
+| 14 | `telemetry.js` | `events`, `http` | `module.exports = { ... }` | |
+| 15 | `transport/index.js` | `events` | `module.exports = { ... }` | |
+| 16 | `speech.js` | `child_process`, `fs`, `path`, `https`, `http` | `module.exports = { ... }` | |
+| 17 | `binary-serializer.js` | `fs`, `path`, `zlib`, `crypto` | `module.exports = { ... }` | |
+| 18 | `snapshot-integrity.js` | `fs`, `path`, `crypto`, `zlib`, `util` | `module.exports = { ... }` | |
+| 19 | `memory-broker.js` | `events`, `fs`, `path`, `crypto` | `module.exports = { ... }` | |
+| 20 | `senses/base.js` | *(none)* | `module.exports = { Sense }` | |
+| 21 | `quantum/math.js` | *(none)* | Conditional `module.exports` | Remove guard |
+| 22 | `tools/file-editor/prompts.js` | *(none)* | `module.exports = { SYSTEM_PROMPT }` | |
+| 23 | `tools/file-editor/patchEngine.js` | *(none)* | `module.exports = { ... }` | |
+
+---
+
+### Batch 2 — Depends on Batch 1 only — 14 files
+
+| # | File | Local Deps (all from Batch 1) | Notes |
+|---|---|---|---|
+| 1 | `core.js` | `vocabulary`, `style`, `topics`, `concepts`, `memory` | |
+| 2 | `secure-config.js` | `error-handler` | |
+| 3 | `senses/chrono.js` | `senses/base` | |
+| 4 | `senses/proprio.js` | `senses/base` | |
+| 5 | `senses/network.js` | `senses/base` | |
+| 6 | `senses/user.js` | `senses/base` | |
+| 7 | `senses/sight.js` | `senses/base` | |
+| 8 | `senses/process.js` | `senses/base` | |
+| 9 | `senses/filesystem.js` | `senses/base` | |
+| 10 | `senses/git.js` | `senses/base` | |
+| 11 | `quantum/analyzer.js` | `quantum/math` | Conditional exports — remove guard |
+| 12 | `quantum/network.js` | `quantum/math` | Conditional exports — remove guard |
+| 13 | `tools/file-editor/llmBridge.js` | `tools/file-editor/prompts` | |
+| 14 | `tools/file-editor/transaction.js` | `tools/file-editor/patchEngine` | |
+
+---
+
+### Batch 3 — Depends on Batch 1–2 — 7 files
+
+| # | File | Local Deps | Notes |
+|---|---|---|---|
+| 1 | `senses/index.js` | all `senses/*.js` (Batch 1–2) | Barrel file for senses subsystem |
+| 2 | `tools/file-editor/index.js` | `llmBridge` (B2), `patchEngine` (B1) | |
+| 3 | `tools/quantum-scanner.js` | `quantum/math` (B1), `quantum/analyzer` (B2), `quantum/network` (B2) | Conditional exports — remove guard |
+| 4 | `enochian-vocabulary.js` | *(none local)* | Cross-pkg: `core/prime` |
+| 5 | `prime-calculus.js` | *(none local)* | Dynamic `require('@sschepis/resolang')` — use `import()` |
+| 6 | `learning/prompt-cache.js` | *(none local)* | Only uses Node built-ins; in learning/ dir but still CJS |
+| 7 | `collective.js` | `smf` (re-export shim — convert in B4) | Move to B5 if smf needs to be done first. **Alternative:** convert `smf.js` shim in this batch too. |
+
+> **Decision point for `collective.js`**: It depends on `smf.js` which is a re-export shim. Since shims are trivial, we can convert `smf.js` and all 6 re-export shims as part of Batch 3.
+
+**Revised Batch 3** — also includes all 6 re-export shims:
+
+| # | File | Notes |
+|---|---|---|
+| 1–6 | `smf.js`, `prsc.js`, `temporal.js`, `entanglement.js`, `agency.js`, `boundary.js`, `safety.js` | Convert `module.exports = require(...)` → `export * from '...'` |
+| 7 | `senses/index.js` | Barrel |
+| 8 | `tools/file-editor/index.js` | |
+| 9 | `tools/quantum-scanner.js` | |
+| 10 | `enochian-vocabulary.js` | Cross-pkg: `core/prime` |
+| 11 | `prime-calculus.js` | Dynamic `require` → `import()` |
+| 12 | `learning/prompt-cache.js` | |
+| 13 | `collective.js` | Depends on `smf` (now converted) |
+
+---
+
+### Batch 4 — Depends on Batch 1–3 — 6 files
+
+| # | File | Local Deps | Cross-Pkg Deps | Notes |
+|---|---|---|---|---|
+| 1 | `tools.js` | `askChaperone` (ESM ✓), `tools/file-editor` (B3), `tools/quantum-scanner` (B3) | *(none)* | |
+| 2 | `enochian.js` | `enochian-vocabulary` (B3) | *(none)* | Dynamic `require('@sschepis/resolang')` |
+| 3 | `hqe.js` | *(none local)* | `core/hilbert`, `core/prime` | Uses `fs`, `path`, `os`, `crypto` |
+| 4 | `specialization.js` | `smf` (B3) | *(none)* | |
+| 5 | `memory-manager.js` | `smf` (B3) | *(none)* | |
+| 6 | `symbolic-smf.js` | `smf` (B3) | `core/symbols`, `core/inference`, `core/compound`, `core/resonance` | |
+
+---
+
+### Batch 5 — Depends on Batch 1–4 — 4 files
+
+| # | File | Local Deps | Cross-Pkg Deps |
+|---|---|---|---|
+| 1 | `enhancer.js` | `tools` (B4) | *(none)* |
+| 2 | `routing.js` | `specialization` (B4) | *(none)* |
+| 3 | `symbolic-temporal.js` | `temporal` (B3 shim) | `core/rformer`, `core/symbols` |
+| 4 | `sentient-memory.js` | `hqe` (B4), `entanglement` (B3), `temporal` (B3) | `core/hilbert`, `core/rformer`, `physics/primeon_z_ladder_multi` |
+
+---
+
+### Batch 6 — Depends on Batch 1–5 — 2 files
+
+| # | File | Local Deps | Cross-Pkg Deps |
+|---|---|---|---|
+| 1 | `network.js` | `smf` (B3), `prime-calculus` (B3), `enochian` (B4), `telemetry` (B1, dynamic) | *(none)* |
+| 2 | `sentient-core.js` | `smf` (B3), `prsc` (B3), `hqe` (B4), `temporal` (B3), `entanglement` (B3), `sentient-memory` (B5), `agency` (B3), `boundary` (B3), `safety` (B3) | `core/hilbert`, `core/prime`, `core/events`, `core/rformer` |
+
+---
+
+### Batch 7 — Final (depends on Batch 6) — 1 file
+
+| # | File | Local Deps |
+|---|---|---|
+| 1 | `symbolic-observer.js` | `sentient-core` (B6), `symbolic-smf` (B4), `symbolic-temporal` (B5), `smf` (B3), `temporal` (B3) |
+
+---
+
+### Batch Summary
+
+```mermaid
+graph TD
+    B0[Batch 0: Verify cross-pkg ESM compat]
+    B1[Batch 1: 23 leaf files]
+    B2[Batch 2: 14 files - depends on B1]
+    B3[Batch 3: 13 files - shims + barrels + deps on B1-B2]
+    B4[Batch 4: 6 files - depends on B1-B3]
+    B5[Batch 5: 4 files - depends on B1-B4]
+    B6[Batch 6: 2 files - network + sentient-core]
+    B7[Batch 7: 1 file - symbolic-observer]
+
+    B0 --> B1
+    B1 --> B2
+    B2 --> B3
+    B3 --> B4
+    B4 --> B5
+    B5 --> B6
+    B6 --> B7
+```
+
+---
+
+## 7. Migration Checklist per File
+
+For each CJS file, apply these transformations:
+
+### Standard Conversion Steps
+
+1. **Replace `require()` with `import`:**
+   ```js
+   // Before
+   const { Foo } = require('./bar');
+   const fs = require('fs');
+   
+   // After
+   import { Foo } from './bar.js';
+   import fs from 'fs';
+   ```
+
+2. **Replace `module.exports` with `export`:**
+   ```js
+   // Before
+   module.exports = { Foo, Bar, baz };
+   
+   // After
+   export { Foo, Bar, baz };
+   ```
+
+3. **Add `.js` extension** to all relative import paths.
+
+4. **Replace dynamic `require()` with `import()`:**
+   ```js
+   // Before
+   try { resolang = require('@sschepis/resolang'); } catch {}
+   
+   // After
+   try { resolang = await import('@sschepis/resolang'); } catch {}
+   // Note: if in module scope, wrap in async IIFE or init function
+   ```
+
+5. **Add `__dirname` polyfill where needed:**
+   ```js
+   import { fileURLToPath } from 'url';
+   import path from 'path';
+   const __filename = fileURLToPath(import.meta.url);
+   const __dirname = path.dirname(__filename);
+   ```
+
+6. **Remove conditional export guards:**
+   ```js
+   // Remove this pattern entirely:
+   if (typeof module !== 'undefined' && module.exports) {
+       module.exports = { ... };
+   }
+   // Replace with:
+   export { ... };
+   ```
+
+7. **Convert re-export shims:**
+   ```js
+   // Before
+   module.exports = require('../../../observer/smf');
+   
+   // After — choose based on what the observer module exports:
+   export * from '../../../observer/smf.js';
+   // OR if it has a default export:
+   export { default } from '../../../observer/smf.js';
+   // OR re-export both:
+   export * from '../../../observer/smf.js';
+   export { default } from '../../../observer/smf.js';
+   ```
+
+### Testing After Each Batch
+
+After converting each batch:
+1. Run `node --check <file>` on each converted file to verify syntax
+2. Run the test suite: `npm test`
+3. Verify no `require()` or `module.exports` remain in converted files:
+   ```bash
+   grep -rn 'require(' apps/sentient/lib/<batch-files> | grep -v node_modules
+   grep -rn 'module.exports' apps/sentient/lib/<batch-files>
+   ```
+
+---
+
+## Appendix: Files Not Imported by Anything in lib/
+
+These files may be entry points, test utilities, or dead code:
+
+| File | Notes |
+|---|---|
+| `profiler.js` | May be imported at runtime / used externally |
+| `speech.js` | Standalone speech module |
+| `binary-serializer.js` | Standalone serialization utility |
+| `snapshot-integrity.js` | Standalone integrity checker |
+| `memory-broker.js` | Standalone memory broker |
+| `transport/index.js` | Standalone transport layer |
+| `routing.js` | May be imported by app layer |
+| `memory-manager.js` | May be imported by app layer |
+| `secure-config.js` | May be imported by app layer |
+| `senses/index.js` | May be imported by app layer |
+| `learning/prompt-cache.js` | May be imported by learning subsystem at runtime |
+| `tools/file-editor/transaction.js` | May be imported externally |
+
+These should still be migrated but verify they are actually used before investing effort.

package/observer/index.js

@@ -15,83 +15,134 @@
  */
 
 // Core observer components
-import { PrimeOscillator, PRSCLayer, EntanglementDetector, coherenceKernel } from './prsc.js';
+import {
+  PrimeOscillator, PRSCLayer, EntanglementDetector,
+  computeHistogramCoherence, gaussianRandom, indexToPhase, intSin, phaseToIndex,
+  INT_SINE_M, INT_SINE_SCALE, INT_SINE_TABLE
+} from './prsc.js';
 
-import { TickGate, StabilizationController, HolographicEncoder, HQE } from './hqe.js';
+import {
+  TickGate, StabilizationController, HolographicEncoder,
+  HolographicMemory, HolographicSimilarity
+} from './hqe.js';
 
-import { SedenionMemoryField, SMF_AXES, AXIS_INDEX } from './smf.js';
+import {
+  SedenionMemoryField, SMF_AXES, AXIS_INDEX,
+  SMF_CODEBOOK, CODEBOOK_SIZE, codebookTunnel, getTunnelingCandidates, nearestCodebookAttractor
+} from './smf.js';
 
 import { Moment, TemporalLayer, TemporalPatternDetector } from './temporal.js';
 
-import { AttentionFocus, Goal, Action, Intent, AgencyLayer } from './agency.js';
+import { AttentionFocus, Goal, Action, AgencyLayer } from './agency.js';
 
-import { SensoryChannel, MotorChannel, EnvironmentalModel, SelfModel, BoundaryLayer } from './boundary.js';
+import {
+  SensoryChannel, MotorChannel, EnvironmentalModel, SelfModel,
+  BoundaryLayer, ObjectivityGate
+} from './boundary.js';
 
 import { EntangledPair, Phrase, EntanglementLayer } from './entanglement.js';
 
-import { SafetyConstraint, ViolationEvent, SafetyMonitor, DEFAULT_CONSTRAINTS } from './safety.js';
+import { SafetyConstraint, ViolationEvent, SafetyMonitor, SafetyLayer } from './safety.js';
 
 // Symbolic processing extensions
-import { SymbolicSMF, SMFSymbolMapper, smfMapper, AXIS_SYMBOL_MAPPING, TAG_TO_AXIS } from './symbolic-smf.js';
+import {
+  SymbolicSMF, SMFSymbolMapper, smfMapper, AXIS_SYMBOL_MAPPING, TAG_TO_AXIS,
+  createSymbolicSMF, fromSMF, symbolToSMF, symbolsToSMF
+} from './symbolic-smf.js';
 
-import { SymbolicMoment, SymbolicTemporalLayer, SymbolicPatternDetector, HEXAGRAM_ARCHETYPES } from './symbolic-temporal.js';
+import {
+  SymbolicMoment, SymbolicTemporalLayer, SymbolicPatternDetector,
+  HEXAGRAM_ARCHETYPES, FIRST_64_PRIMES, PHI
+} from './symbolic-temporal.js';
 
 // Evaluation assays
-import { TimeDilationAssay, MemoryContinuityAssay, AgencyConstraintAssay, NonCommutativeMeaningAssay, AssaySuite } from './assays.js';
+import {
+  TimeDilationAssay, MemoryContinuityAssay, AgencyConstraintAssay,
+  NonCommutativeMeaningAssay, AssaySuite
+} from './assays.js';
 
 export {
   // PRSC - Prime Resonance Semantic Coherence
-    PrimeOscillator,
+  PrimeOscillator,
   PRSCLayer,
   EntanglementDetector,
-  coherenceKernel,
+  computeHistogramCoherence,
+  gaussianRandom,
+  indexToPhase,
+  intSin,
+  phaseToIndex,
+  INT_SINE_M,
+  INT_SINE_SCALE,
+  INT_SINE_TABLE,
+
   // HQE - Holographic Quaternion Engine
-    TickGate,
+  TickGate,
   StabilizationController,
   HolographicEncoder,
-  HQE,
+  HolographicMemory,
+  HolographicSimilarity,
+
   // SMF - Sedenion Memory Field
-    SedenionMemoryField,
+  SedenionMemoryField,
   SMF_AXES,
   AXIS_INDEX,
+  SMF_CODEBOOK,
+  CODEBOOK_SIZE,
+  codebookTunnel,
+  getTunnelingCandidates,
+  nearestCodebookAttractor,
+
   // Temporal - Moment classification
-    Moment,
+  Moment,
   TemporalLayer,
   TemporalPatternDetector,
+
   // Agency - Goals and intentions
-    AttentionFocus,
+  AttentionFocus,
   Goal,
   Action,
-  Intent,
   AgencyLayer,
+
   // Boundary - Self-other differentiation
-    SensoryChannel,
+  SensoryChannel,
   MotorChannel,
   EnvironmentalModel,
   SelfModel,
   BoundaryLayer,
+  ObjectivityGate,
+
   // Entanglement - Semantic phrase coherence
-    EntangledPair,
+  EntangledPair,
   Phrase,
   EntanglementLayer,
+
   // Safety - Constraint monitoring
-    SafetyConstraint,
+  SafetyConstraint,
   ViolationEvent,
   SafetyMonitor,
-  DEFAULT_CONSTRAINTS,
+  SafetyLayer,
+
   // Symbolic SMF - Symbol-grounded semantic field
-    SymbolicSMF,
+  SymbolicSMF,
   SMFSymbolMapper,
   smfMapper,
   AXIS_SYMBOL_MAPPING,
   TAG_TO_AXIS,
+  createSymbolicSMF,
+  fromSMF,
+  symbolToSMF,
+  symbolsToSMF,
+
   // Symbolic Temporal - I-Ching moment classification
-    SymbolicMoment,
+  SymbolicMoment,
   SymbolicTemporalLayer,
   SymbolicPatternDetector,
   HEXAGRAM_ARCHETYPES,
+  FIRST_64_PRIMES,
+  PHI,
+
   // Assays - Validation tests
-    TimeDilationAssay,
+  TimeDilationAssay,
   MemoryContinuityAssay,
   AgencyConstraintAssay,
   NonCommutativeMeaningAssay,
@@ -99,60 +150,77 @@ export {
 };
 
 export default {
-  // PRSC - Prime Resonance Semantic Coherence
-    PrimeOscillator,
+  // PRSC
+  PrimeOscillator,
   PRSCLayer,
   EntanglementDetector,
-  coherenceKernel,
-  // HQE - Holographic Quaternion Engine
-    TickGate,
+  computeHistogramCoherence,
+
+  // HQE
+  TickGate,
   StabilizationController,
   HolographicEncoder,
-  HQE,
-  // SMF - Sedenion Memory Field
-    SedenionMemoryField,
+  HolographicMemory,
+  HolographicSimilarity,
+
+  // SMF
+  SedenionMemoryField,
   SMF_AXES,
   AXIS_INDEX,
-  // Temporal - Moment classification
-    Moment,
+
+  // Temporal
+  Moment,
   TemporalLayer,
   TemporalPatternDetector,
-  // Agency - Goals and intentions
-    AttentionFocus,
+
+  // Agency
+  AttentionFocus,
   Goal,
   Action,
-  Intent,
   AgencyLayer,
-  // Boundary - Self-other differentiation
-    SensoryChannel,
+
+  // Boundary
+  SensoryChannel,
   MotorChannel,
   EnvironmentalModel,
   SelfModel,
   BoundaryLayer,
-  // Entanglement - Semantic phrase coherence
-    EntangledPair,
+  ObjectivityGate,
+
+  // Entanglement
+  EntangledPair,
   Phrase,
   EntanglementLayer,
-  // Safety - Constraint monitoring
-    SafetyConstraint,
+
+  // Safety
+  SafetyConstraint,
   ViolationEvent,
   SafetyMonitor,
-  DEFAULT_CONSTRAINTS,
-  // Symbolic SMF - Symbol-grounded semantic field
-    SymbolicSMF,
+  SafetyLayer,
+
+  // Symbolic SMF
+  SymbolicSMF,
   SMFSymbolMapper,
   smfMapper,
   AXIS_SYMBOL_MAPPING,
   TAG_TO_AXIS,
-  // Symbolic Temporal - I-Ching moment classification
-    SymbolicMoment,
+  createSymbolicSMF,
+  fromSMF,
+  symbolToSMF,
+  symbolsToSMF,
+
+  // Symbolic Temporal
+  SymbolicMoment,
   SymbolicTemporalLayer,
   SymbolicPatternDetector,
   HEXAGRAM_ARCHETYPES,
-  // Assays - Validation tests
-    TimeDilationAssay,
+  FIRST_64_PRIMES,
+  PHI,
+
+  // Assays
+  TimeDilationAssay,
   MemoryContinuityAssay,
   AgencyConstraintAssay,
   NonCommutativeMeaningAssay,
   AssaySuite
-};
+};

package/observer/symbolic-smf.js

@@ -685,42 +685,32 @@ class SMFSymbolMapper {
 // Singleton instance
 const smfMapper = new SMFSymbolMapper();
 
+// Convenience functions
+const createSymbolicSMF = (components, options) => new SymbolicSMF(components, options);
+const fromSMF = (smf, options) => SymbolicSMF.fromSMF(smf, options);
+const symbolToSMF = (symbol) => smfMapper.symbolToSMF(symbol);
+const symbolsToSMF = (symbols) => smfMapper.symbolsToSMF(symbols);
+
 export {
-  // Classes
-    SymbolicSMF,
+  SymbolicSMF,
   SMFSymbolMapper,
-  // Singleton instance
-    smfMapper,
-  // Mappings (for external use)
-    AXIS_SYMBOL_MAPPING,
+  smfMapper,
+  AXIS_SYMBOL_MAPPING,
   TAG_TO_AXIS,
-  // Convenience functions
-    createSymbolicSMF: (components,
-  options) => new SymbolicSMF(components,
-  options),
-  fromSMF: (smf,
-  options) => SymbolicSMF.fromSMF(smf,
-  options),
-  symbolToSMF: (symbol) => smfMapper.symbolToSMF(symbol),
-  symbolsToSMF: (symbols) => smfMapper.symbolsToSMF(symbols)
+  createSymbolicSMF,
+  fromSMF,
+  symbolToSMF,
+  symbolsToSMF
 };
 
 export default {
-  // Classes
-    SymbolicSMF,
+  SymbolicSMF,
   SMFSymbolMapper,
-  // Singleton instance
-    smfMapper,
-  // Mappings (for external use)
-    AXIS_SYMBOL_MAPPING,
+  smfMapper,
+  AXIS_SYMBOL_MAPPING,
   TAG_TO_AXIS,
-  // Convenience functions
-    createSymbolicSMF: (components,
-  options) => new SymbolicSMF(components,
-  options),
-  fromSMF: (smf,
-  options) => SymbolicSMF.fromSMF(smf,
-  options),
-  symbolToSMF: (symbol) => smfMapper.symbolToSMF(symbol),
-  symbolsToSMF: (symbols) => smfMapper.symbolsToSMF(symbols)
-};
+  createSymbolicSMF,
+  fromSMF,
+  symbolToSMF,
+  symbolsToSMF
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aleph-ai/tinyaleph",
-  "version": "1.7.2",
+  "version": "1.7.3",
   "description": "Prime-resonant semantic computing framework - hypercomplex algebra, oscillator dynamics, arithmetic topology, and entropy-minimizing reasoning",
   "type": "module",
   "main": "index.js",

package/physics/lyapunov.js

@@ -89,13 +89,12 @@ function estimateLyapunovFromTimeSeries(history, windowSize = 20) {
 /**
  * Classify stability based on Lyapunov exponent
  * @param {number} lyapunovExponent - The Lyapunov exponent
- * @returns {'stable'|'unstable'|'chaotic'|'collapsed'} Stability classification
+ * @returns {'STABLE'|'MARGINAL'|'CHAOTIC'} Stability classification
  */
 function classifyStability(lyapunovExponent) {
-  if (lyapunovExponent < -0.1) return 'collapsed';  // Strong convergence
-  if (lyapunovExponent < 0) return 'stable';         // Weak convergence
-  if (lyapunovExponent < 0.5) return 'unstable';    // Weak divergence
-  return 'chaotic';                                   // Strong divergence
+  if (lyapunovExponent < 0) return 'STABLE';       // Convergent (negative exponent)
+  if (lyapunovExponent < 0.5) return 'MARGINAL';   // Near-zero / weak divergence
+  return 'CHAOTIC';                                  // Strong divergence
 }
 
 /**