@astermind/cybernetic-chatbot-client 1.0.9 → 2.2.3

package/dist/cybernetic-chatbot-client-full.umd.js

@@ -1,6 +1,6 @@
 (function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
-    typeof define === 'function' && define.amd ? define(['exports'], factory) :
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('fs'), require('path')) :
+    typeof define === 'function' && define.amd ? define(['exports', 'fs', 'path'], factory) :
     (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.AsterMindCyberneticFull = {}));
 })(this, (function (exports) { 'use strict';
 
@@ -599,17 +599,13 @@
 
     // src/CyberneticLocalRAG.ts
     // Local RAG processing for offline fallback
-    /**
-     * Local RAG engine using TF-IDF similarity
-     *
-     * Provides offline fallback when backend is unavailable.
-     * Uses simple TF-IDF for document matching (no vector embeddings).
-     */
     class CyberneticLocalRAG {
         constructor() {
             this.documents = [];
             this.idf = new Map();
             this.indexed = false;
+            this.loadedFromExport = false;
+            this.vocabulary = new Map(); // term -> index for sparse vectors
         }
         /**
          * Check if documents are indexed
@@ -710,7 +706,66 @@
         reset() {
             this.documents = [];
             this.idf = new Map();
+            this.vocabulary = new Map();
             this.indexed = false;
+            this.loadedFromExport = false;
+            this.exportVersion = undefined;
+            this.exportedAt = undefined;
+        }
+        /**
+         * Load pre-computed vectors from an export file
+         * This skips client-side TF-IDF computation by using pre-computed values
+         *
+         * @param exportData - The offline vector export data
+         */
+        async loadFromExport(exportData) {
+            this.reset();
+            // Load pre-computed IDF from export
+            this.idf = new Map(Object.entries(exportData.tfidfIndex.idf));
+            // Build vocabulary mapping from IDF keys
+            let vocabIndex = 0;
+            for (const term of this.idf.keys()) {
+                this.vocabulary.set(term, vocabIndex++);
+            }
+            // Load documents with pre-computed TF-IDF vectors
+            for (const doc of exportData.documents) {
+                // Convert sparse vector to Map
+                const tfidfMap = new Map();
+                for (const [termIndex, weight] of doc.tfidfVector) {
+                    // Find the term from vocabulary by index
+                    for (const [term, idx] of this.vocabulary) {
+                        if (idx === termIndex) {
+                            tfidfMap.set(term, weight);
+                            break;
+                        }
+                    }
+                }
+                this.documents.push({
+                    id: doc.id,
+                    title: doc.title,
+                    content: doc.content,
+                    tokens: [], // Not needed when loading from export
+                    tfidf: tfidfMap
+                });
+            }
+            this.indexed = true;
+            this.loadedFromExport = true;
+            this.exportVersion = exportData.version;
+            this.exportedAt = exportData.meta.exportedAt;
+            console.log(`[CyberneticLocalRAG] Loaded ${this.documents.length} documents from export (v${exportData.version})`);
+        }
+        /**
+         * Get export status information
+         */
+        getExportStatus() {
+            return {
+                loaded: this.indexed,
+                loadedFromExport: this.loadedFromExport,
+                documentCount: this.documents.length,
+                chunkCount: this.documents.length, // Each document is a chunk
+                exportVersion: this.exportVersion,
+                exportedAt: this.exportedAt
+            };
         }
         // ==================== PRIVATE METHODS ====================
         /**
@@ -800,6 +855,139 @@
         }
     }
 
+    // src/CyberneticOfflineStorage.ts
+    // IndexedDB storage for offline vector exports
+    /**
+     * IndexedDB storage for offline vector exports
+     * Provides persistent caching of pre-computed TF-IDF vectors
+     */
+    class CyberneticOfflineStorage {
+        constructor() {
+            this.db = null;
+            this.dbPromise = null;
+            this.dbName = 'cybernetic-offline-vectors';
+            this.dbVersion = 1;
+        }
+        /**
+         * Initialize IndexedDB for vector storage
+         */
+        async initDB() {
+            if (this.db) {
+                return this.db;
+            }
+            if (this.dbPromise) {
+                return this.dbPromise;
+            }
+            this.dbPromise = openDB(this.dbName, this.dbVersion, {
+                upgrade(db) {
+                    if (!db.objectStoreNames.contains('vectors')) {
+                        db.createObjectStore('vectors', { keyPath: 'id' });
+                    }
+                }
+            });
+            this.db = await this.dbPromise;
+            return this.db;
+        }
+        /**
+         * Store vector export in IndexedDB
+         */
+        async store(id, exportData) {
+            const db = await this.getDB();
+            await db.put('vectors', {
+                id,
+                exportVersion: exportData.version,
+                exportedAt: exportData.meta.exportedAt,
+                type: exportData.type,
+                data: exportData
+            });
+            console.log(`[CyberneticOfflineStorage] Stored ${exportData.meta.chunkCount} chunks`);
+        }
+        /**
+         * Retrieve vector export from IndexedDB
+         */
+        async retrieve(id) {
+            const db = await this.getDB();
+            const record = await db.get('vectors', id);
+            return record?.data ?? null;
+        }
+        /**
+         * Check if cached vectors are valid (not expired)
+         */
+        async isValid(id, maxAge) {
+            const db = await this.getDB();
+            const record = await db.get('vectors', id);
+            if (!record)
+                return false;
+            const exportTime = new Date(record.exportedAt).getTime();
+            return Date.now() - exportTime < maxAge;
+        }
+        /**
+         * Get cached export metadata without loading full data
+         */
+        async getMeta(id) {
+            const db = await this.getDB();
+            const record = await db.get('vectors', id);
+            if (!record)
+                return null;
+            return {
+                version: record.exportVersion,
+                exportedAt: record.exportedAt,
+                documentCount: record.data.meta.documentCount,
+                chunkCount: record.data.meta.chunkCount,
+                type: record.type
+            };
+        }
+        /**
+         * Check if any cached vectors exist
+         */
+        async hasData() {
+            const db = await this.getDB();
+            const count = await db.count('vectors');
+            return count > 0;
+        }
+        /**
+         * Get all cached export IDs
+         */
+        async getStoredIds() {
+            const db = await this.getDB();
+            return db.getAllKeys('vectors');
+        }
+        /**
+         * Clear specific cached vectors
+         */
+        async delete(id) {
+            const db = await this.getDB();
+            await db.delete('vectors', id);
+        }
+        /**
+         * Clear all cached vectors
+         */
+        async clear() {
+            const db = await this.getDB();
+            await db.clear('vectors');
+            console.log('[CyberneticOfflineStorage] Cache cleared');
+        }
+        /**
+         * Get the database connection
+         */
+        async getDB() {
+            if (this.db) {
+                return this.db;
+            }
+            return this.initDB();
+        }
+        /**
+         * Close database connection
+         */
+        close() {
+            if (this.db) {
+                this.db.close();
+                this.db = null;
+                this.dbPromise = null;
+            }
+        }
+    }
+
     // src/license/base64url.ts
     // Base64URL encoding/decoding utilities for JWT handling
     /**
@@ -1443,6 +1631,12 @@ LJ5AZXvOhHaXdHzMuYKX5BpK4w7TqbPvJ6QPvKmLKvHh1VKcUJ6mJQgJJw==
             this.SETTINGS_CHECK_INTERVAL = 300000; // 5 minutes
             // Agentic capabilities (optional, registered separately via registerAgenticCapabilities)
             this.agenticCapabilities = null;
+            // Offline vector storage
+            this.offlineStorage = null;
+            // Omega RAG (optional, loaded dynamically)
+            this.omegaRAG = null;
+            // Track if offline warning has been shown
+            this.offlineWarningShown = false;
             // Apply defaults
             this.config = {
                 apiUrl: config.apiUrl,
@@ -1459,6 +1653,15 @@ LJ5AZXvOhHaXdHzMuYKX5BpK4w7TqbPvJ6QPvKmLKvHh1VKcUJ6mJQgJJw==
                     exponentialBackoff: config.retry?.exponentialBackoff ?? true
                 },
                 agentic: config.agentic ?? null,
+                offline: config.offline ?? null,
+                sitemap: config.sitemap ?? null,
+                sources: {
+                    enabled: config.sources?.enabled ?? true,
+                    showSummary: config.sources?.showSummary ?? true,
+                    showDownload: config.sources?.showDownload ?? true,
+                    includeFullContent: config.sources?.includeFullContent ?? false,
+                    maxSources: config.sources?.maxSources ?? 5
+                },
                 onStatusChange: config.onStatusChange || (() => { }),
                 onError: config.onError || (() => { })
             };
@@ -1488,6 +1691,12 @@ LJ5AZXvOhHaXdHzMuYKX5BpK4w7TqbPvJ6QPvKmLKvHh1VKcUJ6mJQgJJw==
                     // Silent failure on init - cache may be stale but usable
                 });
             }
+            // Initialize offline vector support if configured
+            if (this.config.offline?.enabled) {
+                this.initializeOffline(this.config.offline).catch((error) => {
+                    console.warn('[Cybernetic] Failed to initialize offline vectors:', error);
+                });
+            }
         }
         // ==================== AGENTIC CAPABILITIES ====================
         /**
@@ -1528,6 +1737,34 @@ LJ5AZXvOhHaXdHzMuYKX5BpK4w7TqbPvJ6QPvKmLKvHh1VKcUJ6mJQgJJw==
         getAgenticConfig() {
             return this.config.agentic;
         }
+        // ==================== SOURCES CONFIGURATION ====================
+        /**
+         * Get sources configuration
+         * Returns merged configuration with all defaults applied
+         */
+        getSourcesConfig() {
+            return { ...this.config.sources };
+        }
+        /**
+         * Check if a specific source feature is available
+         * Takes into account configuration, connection status, and requirements
+         *
+         * @param feature - The feature to check ('summary' or 'download')
+         * @returns Whether the feature is available
+         */
+        isSourceFeatureAvailable(feature) {
+            if (!this.config.sources.enabled) {
+                return false;
+            }
+            if (feature === 'summary') {
+                return this.config.sources.showSummary;
+            }
+            if (feature === 'download') {
+                // Download only works when online
+                return this.config.sources.showDownload && this.status === 'online';
+            }
+            return false;
+        }
         /**
          * Classify user message intent for agentic action
          * Only works if agentic capabilities are registered and enabled
@@ -1592,6 +1829,148 @@ LJ5AZXvOhHaXdHzMuYKX5BpK4w7TqbPvJ6QPvKmLKvHh1VKcUJ6mJQgJJw==
             const response = await this.ask(message, options);
             return { response };
         }
+        // ==================== OFFLINE VECTOR METHODS ====================
+        /**
+         * Initialize offline vector support
+         * Loads pre-exported vectors from URL or inline data
+         */
+        async initializeOffline(config) {
+            const storageMode = config.storageMode ?? 'hybrid';
+            const maxAge = config.cacheMaxAge ?? 604800000; // 7 days default
+            // Initialize IndexedDB storage if not memory-only
+            if (storageMode !== 'memory') {
+                this.offlineStorage = new CyberneticOfflineStorage();
+            }
+            // Check for cached vectors first
+            if (this.offlineStorage && storageMode !== 'memory') {
+                const cacheId = 'default';
+                if (await this.offlineStorage.isValid(cacheId, maxAge)) {
+                    console.log('[Cybernetic] Loading vectors from IndexedDB cache');
+                    const cached = await this.offlineStorage.retrieve(cacheId);
+                    if (cached) {
+                        await this.localRAG.loadFromExport(cached);
+                        console.log('[Cybernetic] Loaded vectors from IndexedDB cache');
+                        return;
+                    }
+                }
+            }
+            // Try to load from URL
+            if (config.vectorFileUrl) {
+                try {
+                    const response = await fetch(config.vectorFileUrl);
+                    if (!response.ok) {
+                        throw new Error(`Failed to fetch vectors: ${response.status}`);
+                    }
+                    const exportData = await response.json();
+                    // Store in IndexedDB for future use
+                    if (this.offlineStorage && storageMode !== 'memory') {
+                        await this.offlineStorage.store('default', exportData);
+                    }
+                    // Load into local RAG
+                    await this.localRAG.loadFromExport(exportData);
+                    // Initialize Omega if configured
+                    if (config.omega?.enabled) {
+                        await this.initializeOmega(config);
+                    }
+                    console.log('[Cybernetic] Loaded vectors from URL:', config.vectorFileUrl);
+                    return;
+                }
+                catch (error) {
+                    console.error('[Cybernetic] Failed to load offline vectors from URL:', error);
+                }
+            }
+            // Try inline vector data
+            if (config.vectorData) {
+                await this.localRAG.loadFromExport(config.vectorData);
+                // Initialize Omega if configured
+                if (config.omega?.enabled) {
+                    await this.initializeOmega(config);
+                }
+                console.log('[Cybernetic] Loaded inline vector data');
+                return;
+            }
+            // No vectors available - log warning (one-time)
+            if (!this.offlineWarningShown) {
+                console.warn('[Cybernetic] Offline functionality is enabled but no vectors are loaded. ' +
+                    'Offline responses will be limited. To enable full offline functionality, ' +
+                    'export vectors from the AsterMind admin panel and configure the vectorFileUrl ' +
+                    'or vectorData option.');
+                this.offlineWarningShown = true;
+            }
+        }
+        /**
+         * Initialize Omega RAG module
+         */
+        async initializeOmega(config) {
+            if (!config.omega?.enabled)
+                return;
+            try {
+                // Dynamic import to support tree-shaking
+                const { OmegaOfflineRAG } = await Promise.resolve().then(function () { return OmegaOfflineRAG$1; });
+                this.omegaRAG = new OmegaOfflineRAG({
+                    reranking: config.omega.reranking,
+                    topK: 5,
+                    verbose: false
+                });
+                // Load model from URL or inline data
+                if (config.omega.modelUrl) {
+                    await this.omegaRAG.loadModelFromUrl(config.omega.modelUrl);
+                }
+                else if (config.omega.modelData) {
+                    // Convert our type to the astermind type
+                    await this.omegaRAG.loadModel(config.omega.modelData);
+                }
+                console.log('[Cybernetic] Omega RAG initialized');
+            }
+            catch (error) {
+                console.warn('[Cybernetic] Failed to initialize Omega RAG:', error);
+                this.omegaRAG = null;
+            }
+        }
+        /**
+         * Manually reload offline vectors
+         * Clears cache and re-fetches from configured source
+         */
+        async reloadOfflineVectors() {
+            if (!this.config.offline?.enabled) {
+                console.warn('[Cybernetic] Offline mode is not enabled');
+                return;
+            }
+            // Clear existing data
+            this.localRAG.reset();
+            if (this.offlineStorage) {
+                await this.offlineStorage.clear();
+            }
+            if (this.omegaRAG) {
+                this.omegaRAG.clear();
+            }
+            // Re-initialize
+            await this.initializeOffline(this.config.offline);
+        }
+        /**
+         * Check if Omega offline RAG is enabled and ready
+         */
+        isOmegaOfflineEnabled() {
+            return this.omegaRAG?.isReady() ?? false;
+        }
+        /**
+         * Get offline model info (if Omega is loaded)
+         */
+        getOfflineModelInfo() {
+            return this.omegaRAG?.getModelInfo() ?? null;
+        }
+        /**
+         * Get local RAG export status
+         */
+        getLocalRAGStatus() {
+            return this.localRAG.getExportStatus();
+        }
+        /**
+         * Get offline storage instance for advanced operations
+         */
+        getOfflineStorage() {
+            return this.offlineStorage;
+        }
         // ==================== CORE METHODS ====================
         /**
          * Send a message to the chatbot
@@ -1870,18 +2249,79 @@ LJ5AZXvOhHaXdHzMuYKX5BpK4w7TqbPvJ6QPvKmLKvHh1VKcUJ6mJQgJJw==
         }
         /**
          * Fallback to local RAG processing
+         * Uses Omega RAG if available, falls back to simple TF-IDF
          */
         async fallbackAsk(message) {
             this.setStatus('offline');
-            // Check if we have cached documents
+            // Try Omega RAG first if available
+            if (this.omegaRAG?.isReady()) {
+                try {
+                    const omegaResult = await this.omegaRAG.ask(message);
+                    if (!omegaResult.degraded) {
+                        // Process response through license manager
+                        const processedReply = this.licenseManager.processResponse(omegaResult.answer);
+                        return {
+                            reply: processedReply,
+                            confidence: omegaResult.confidence,
+                            sources: omegaResult.sources.map(s => ({
+                                title: s.heading,
+                                snippet: s.content.substring(0, 200) + '...',
+                                relevance: s.score
+                            })),
+                            offline: true,
+                            degradedReason: 'Omega hybrid retrieval (offline)'
+                        };
+                    }
+                    // If Omega degraded, fall through to simple RAG
+                }
+                catch (error) {
+                    console.warn('[Cybernetic] Omega RAG failed, falling back to TF-IDF:', error);
+                    // Fall through to simple RAG
+                }
+            }
+            // Check if local RAG has pre-loaded vectors from export
+            const localRAGStatus = this.localRAG.getExportStatus();
+            if (localRAGStatus.loaded && localRAGStatus.documentCount > 0) {
+                try {
+                    const result = await this.localRAG.ask(message);
+                    // Determine confidence based on match quality
+                    let confidence = 'medium';
+                    if (result.topScore < 0.3) {
+                        confidence = 'low';
+                    }
+                    else if (result.topScore > 0.7) {
+                        confidence = 'medium'; // Never 'high' for offline
+                    }
+                    // Process response through license manager
+                    const processedReply = this.licenseManager.processResponse(result.answer);
+                    return {
+                        reply: processedReply,
+                        confidence,
+                        sources: result.sources.map(s => ({
+                            title: s.title,
+                            snippet: s.snippet,
+                            relevance: s.score
+                        })),
+                        offline: true,
+                        degradedReason: localRAGStatus.loadedFromExport
+                            ? 'Using pre-exported vectors (offline)'
+                            : 'Processed locally with TF-IDF'
+                    };
+                }
+                catch (error) {
+                    console.error('[Cybernetic] Local RAG error:', error);
+                    // Fall through to cache-based fallback
+                }
+            }
+            // Check if we have cached documents (original sync-based fallback)
             const cacheStatus = this.cache.getStatus();
-            if (cacheStatus.documentCount === 0) {
+            if (cacheStatus.documentCount === 0 && !localRAGStatus.loaded) {
                 return {
                     reply: 'I\'m currently offline and don\'t have any cached information. Please check your connection and try again.',
                     confidence: 'none',
                     sources: [],
                     offline: true,
-                    degradedReason: 'No cached documents available'
+                    degradedReason: 'No cached documents or offline vectors available'
                 };
             }
             try {
@@ -2236,6 +2676,8 @@ LJ5AZXvOhHaXdHzMuYKX5BpK4w7TqbPvJ6QPvKmLKvHh1VKcUJ6mJQgJJw==
      */
     class CyberneticIntentClassifier {
         constructor(config) {
+            this.categories = [];
+            this.topicKeywords = new Map(); // topic -> keywords
             this.config = config;
             this.siteMapIndex = new Map();
             this.formIndex = new Map();
@@ -2756,6 +3198,174 @@ LJ5AZXvOhHaXdHzMuYKX5BpK4w7TqbPvJ6QPvKmLKvHh1VKcUJ6mJQgJJw==
         getConfig() {
             return this.config;
         }
+        // ==================== EXPORT/SITEMAP LOADING METHODS ====================
+        /**
+         * Train classifier from exported documents
+         * Extracts topics and keywords for better intent classification
+         *
+         * @param exportData - The offline vector export data
+         */
+        async trainFromExport(exportData) {
+            // Load explicit categories if provided
+            if (exportData.categories) {
+                this.categories = exportData.categories;
+                for (const category of exportData.categories) {
+                    // Index category keywords for matching
+                    for (const keyword of category.keywords) {
+                        const existing = this.topicKeywords.get(category.name) || [];
+                        existing.push(keyword.toLowerCase());
+                        this.topicKeywords.set(category.name, existing);
+                    }
+                }
+            }
+            // Extract topics from documents
+            const docTopics = this.extractTopicsFromDocuments(exportData.documents);
+            for (const [topic, keywords] of docTopics) {
+                const existing = this.topicKeywords.get(topic) || [];
+                existing.push(...keywords);
+                this.topicKeywords.set(topic, [...new Set(existing)]); // Dedupe
+            }
+            // Load sitemap from export if available
+            if (exportData.sitemap) {
+                this.loadSitemapEntries(exportData.sitemap);
+            }
+            console.log(`[CyberneticIntentClassifier] Trained with ${this.categories.length} categories, ${this.topicKeywords.size} topics`);
+        }
+        /**
+         * Load sitemap from configuration
+         *
+         * @param config - Sitemap configuration with URL or inline data
+         */
+        async loadSitemap(config) {
+            if (!config.enabled)
+                return;
+            // Load from inline data
+            if (config.sitemapData) {
+                this.loadSitemapEntries(config.sitemapData);
+                return;
+            }
+            // Load from URL
+            if (config.sitemapUrl) {
+                try {
+                    const response = await fetch(config.sitemapUrl);
+                    if (!response.ok) {
+                        throw new Error(`Failed to fetch sitemap: ${response.status}`);
+                    }
+                    const data = await response.json();
+                    this.loadSitemapEntries(data);
+                }
+                catch (error) {
+                    console.error('[CyberneticIntentClassifier] Failed to load sitemap:', error);
+                }
+            }
+        }
+        /**
+         * Load sitemap entries into the index
+         */
+        loadSitemapEntries(entries) {
+            for (const entry of entries) {
+                // Convert GlobalSiteMapEntry to agentic SiteMapEntry format
+                const siteMapEntry = {
+                    path: entry.url,
+                    name: entry.title,
+                    description: entry.description,
+                    aliases: entry.keywords
+                };
+                // Index by title, URL, description, and keywords
+                const keys = [
+                    entry.title.toLowerCase(),
+                    entry.url.toLowerCase(),
+                    ...(entry.keywords || []).map(k => k.toLowerCase())
+                ];
+                if (entry.description) {
+                    // Also index significant words from description
+                    const descWords = entry.description
+                        .toLowerCase()
+                        .split(/\s+/)
+                        .filter(w => w.length > 4);
+                    keys.push(...descWords);
+                }
+                for (const key of keys) {
+                    this.siteMapIndex.set(key, siteMapEntry);
+                }
+            }
+            console.log(`[CyberneticIntentClassifier] Loaded ${entries.length} sitemap entries`);
+        }
+        /**
+         * Extract topics and keywords from document content
+         */
+        extractTopicsFromDocuments(docs) {
+            const topics = new Map();
+            for (const doc of docs) {
+                // Use title as topic
+                const topic = doc.title.toLowerCase();
+                const keywords = [];
+                // Extract keywords from metadata
+                if (doc.metadata?.keywords) {
+                    keywords.push(...doc.metadata.keywords.map(k => k.toLowerCase()));
+                }
+                // Extract significant words from title
+                const titleWords = doc.title
+                    .toLowerCase()
+                    .replace(/[^a-z0-9\s]/g, '')
+                    .split(/\s+/)
+                    .filter(w => w.length > 3 && !this.isStopWord(w));
+                keywords.push(...titleWords);
+                // Extract frequent significant words from content (simple TF)
+                const contentWords = doc.content
+                    .toLowerCase()
+                    .replace(/[^a-z0-9\s]/g, '')
+                    .split(/\s+/)
+                    .filter(w => w.length > 4 && !this.isStopWord(w));
+                const wordFreq = new Map();
+                for (const word of contentWords) {
+                    wordFreq.set(word, (wordFreq.get(word) || 0) + 1);
+                }
+                // Get top 5 most frequent words
+                const topWords = [...wordFreq.entries()]
+                    .sort((a, b) => b[1] - a[1])
+                    .slice(0, 5)
+                    .map(([word]) => word);
+                keywords.push(...topWords);
+                topics.set(topic, [...new Set(keywords)]); // Dedupe
+            }
+            return topics;
+        }
+        /**
+         * Check if word is a stop word
+         */
+        isStopWord(word) {
+            const stopWords = new Set([
+                'the', 'a', 'an', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for',
+                'of', 'with', 'by', 'from', 'up', 'about', 'into', 'through', 'during',
+                'is', 'are', 'was', 'were', 'be', 'been', 'being', 'have', 'has', 'had',
+                'do', 'does', 'did', 'will', 'would', 'could', 'should', 'may', 'might',
+                'this', 'that', 'these', 'those', 'it', 'its', 'they', 'them', 'their',
+                'what', 'which', 'who', 'whom', 'when', 'where', 'why', 'how',
+                'all', 'each', 'every', 'both', 'few', 'more', 'most', 'other', 'some',
+                'such', 'no', 'not', 'only', 'same', 'so', 'than', 'too', 'very',
+                'can', 'just', 'dont', 'now', 'here', 'there', 'also', 'your', 'you'
+            ]);
+            return stopWords.has(word);
+        }
+        /**
+         * Get loaded categories
+         */
+        getCategories() {
+            return this.categories;
+        }
+        /**
+         * Get topic keywords
+         */
+        getTopicKeywords() {
+            return this.topicKeywords;
+        }
+        /**
+         * Check if classifier has been trained
+         */
+        isTrained() {
+            return this.categories.length > 0 || this.topicKeywords.size > 0;
+        }
     }
 
     // src/agentic/CyberneticAgent.ts
@@ -3392,6 +4002,1394 @@ LJ5AZXvOhHaXdHzMuYKX5BpK4w7TqbPvJ6QPvKmLKvHh1VKcUJ6mJQgJJw==
         client.registerAgentic(capabilities);
     }
 
+    // © 2026 AsterMind AI Co. – All Rights Reserved.
+    // Patent Pending US 63/897,713
+    // ELMConfig.ts - Configuration interfaces, defaults, helpers for ELM-based models
+    /* =========== Defaults =========== */
+    const defaultBase = {
+        hiddenUnits: 50,
+        activation: 'relu',
+        ridgeLambda: 1e-2,
+        weightInit: 'xavier',
+        seed: 1337,
+        dropout: 0,
+        log: { verbose: true, toFile: false, modelName: 'Unnamed ELM Model', level: 'info' },
+    };
+    Object.assign(Object.assign({}, defaultBase), { useTokenizer: false });
+    Object.assign(Object.assign({}, defaultBase), { useTokenizer: true, maxLen: 30, charSet: 'abcdefghijklmnopqrstuvwxyz', tokenizerDelimiter: /\s+/ });
+
+    function buildRFF(d, D, sigma = 1.0, rng = Math.random) {
+        const W = new Float64Array(D * d);
+        const b = new Float64Array(D);
+        const s = 1 / Math.max(1e-12, sigma); // N(0, 1/sigma^2)
+        for (let i = 0; i < D * d; i++)
+            W[i] = gauss$1(rng) * s;
+        for (let i = 0; i < D; i++)
+            b[i] = rng() * 2 * Math.PI;
+        return { W, b, D, d, sigma };
+    }
+    function mapRFF(rff, x) {
+        const { W, b, D, d } = rff;
+        const z = new Float64Array(2 * D);
+        for (let k = 0; k < D; k++) {
+            let dot = b[k];
+            const off = k * d;
+            for (let j = 0; j < d; j++)
+                dot += W[off + j] * (x[j] || 0);
+            z[k] = Math.cos(dot);
+            z[D + k] = Math.sin(dot);
+        }
+        // L2 normalize block to keep ridge well-conditioned
+        let s = 0;
+        for (let i = 0; i < z.length; i++)
+            s += z[i] * z[i];
+        const inv = 1 / Math.sqrt(Math.max(s, 1e-12));
+        for (let i = 0; i < z.length; i++)
+            z[i] *= inv;
+        return z;
+    }
+    // Box-Muller
+    function gauss$1(rng) {
+        let u = 0, v = 0;
+        while (u === 0)
+            u = rng();
+        while (v === 0)
+            v = rng();
+        return Math.sqrt(-2 * Math.log(u)) * Math.cos(2 * Math.PI * v);
+    }
+
+    // online_ridge.ts — maintain (Φ^T Φ + λI)^{-1} and β for linear ridge
+    class OnlineRidge {
+        constructor(p, m, lambda = 1e-4) {
+            this.p = p;
+            this.m = m;
+            this.lambda = lambda;
+            this.Ainv = new Float64Array(p * p);
+            this.Beta = new Float64Array(p * m);
+            // Ainv = (λ I)^-1 = (1/λ) I
+            const inv = 1 / Math.max(1e-12, lambda);
+            for (let i = 0; i < p; i++)
+                this.Ainv[i * p + i] = inv;
+        }
+        // rank-1 update with a single sample (φ, y)
+        update(phi, y) {
+            const { p, m, Ainv, Beta } = this;
+            // u = Ainv * phi
+            const u = new Float64Array(p);
+            for (let i = 0; i < p; i++) {
+                let s = 0, row = i * p;
+                for (let j = 0; j < p; j++)
+                    s += Ainv[row + j] * phi[j];
+                u[i] = s;
+            }
+            // denom = 1 + phi^T u
+            let denom = 1;
+            for (let j = 0; j < p; j++)
+                denom += phi[j] * u[j];
+            denom = Math.max(denom, 1e-12);
+            const scale = 1 / denom;
+            // Ainv <- Ainv - (u u^T) * scale
+            for (let i = 0; i < p; i++) {
+                const ui = u[i] * scale;
+                for (let j = 0; j < p; j++)
+                    Ainv[i * p + j] -= ui * u[j];
+            }
+            // Beta <- Beta + Ainv * (phi * y^T)
+            // compute t = Ainv * phi  (reuse u after Ainv update)
+            for (let i = 0; i < p; i++) {
+                let s = 0, row = i * p;
+                for (let j = 0; j < p; j++)
+                    s += Ainv[row + j] * phi[j];
+                u[i] = s; // reuse u as t
+            }
+            // Beta += outer(u, y)
+            for (let i = 0; i < p; i++) {
+                const ui = u[i];
+                for (let c = 0; c < m; c++)
+                    Beta[i * m + c] += ui * y[c];
+            }
+        }
+        // yhat = φ^T Beta
+        predict(phi) {
+            const { p, m, Beta } = this;
+            const out = new Float64Array(m);
+            for (let c = 0; c < m; c++) {
+                let s = 0;
+                for (let i = 0; i < p; i++)
+                    s += phi[i] * Beta[i * m + c];
+                out[c] = s;
+            }
+            return out;
+        }
+    }
+
+    // src/math/index.ts — production-grade numerics for Ω
+    // Backward compatible with previous exports; adds robust, stable helpers.
+    // ---------- Constants
+    const EPS = 1e-12; // general epsilon for divides/sqrt
+    // ---------- Norms / normalization
+    function l2$1(a) {
+        // robust L2 (avoids NaN on weird input)
+        let s = 0;
+        for (let i = 0; i < a.length; i++)
+            s += a[i] * a[i];
+        return Math.sqrt(Math.max(0, s));
+    }
+    function normalizeL2(a, eps = EPS) {
+        const nrm = l2$1(a);
+        if (!(nrm > eps) || !Number.isFinite(nrm))
+            return new Float64Array(a.length); // zero vec
+        const o = new Float64Array(a.length);
+        const inv = 1 / nrm;
+        for (let i = 0; i < a.length; i++)
+            o[i] = a[i] * inv;
+        return o;
+    }
+    // ---------- Cosine (robust)
+    function cosine$2(a, b) {
+        var _a, _b;
+        const n = Math.min(a.length, b.length);
+        if (n === 0)
+            return 0;
+        let dotv = 0, na = 0, nb = 0;
+        for (let i = 0; i < n; i++) {
+            const ai = ((_a = a[i]) !== null && _a !== void 0 ? _a : 0), bi = ((_b = b[i]) !== null && _b !== void 0 ? _b : 0);
+            dotv += ai * bi;
+            na += ai * ai;
+            nb += bi * bi;
+        }
+        const denom = Math.sqrt(Math.max(na * nb, EPS));
+        const v = dotv / denom;
+        return Number.isFinite(v) ? v : 0;
+    }
+
+    /******************************************************************************
+    Copyright (c) Microsoft Corporation.
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose with or without fee is hereby granted.
+
+    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+    PERFORMANCE OF THIS SOFTWARE.
+    ***************************************************************************** */
+    /* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+
+    function __awaiter(thisArg, _arguments, P, generator) {
+        function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+        return new (P || (P = Promise))(function (resolve, reject) {
+            function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+            function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+            function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+            step((generator = generator.apply(thisArg, _arguments || [])).next());
+        });
+    }
+
+    typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+        var e = new Error(message);
+        return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+    };
+
+    // Omega.ts v2 — improved local reasoning + summarization
+    // uses your math.ts, rff.ts, online_ridge.ts
+    // -------- sentence + text helpers ----------
+    function splitSentences$1(text) {
+        return text
+            .replace(/\s+/g, " ")
+            .split(/(?<=[.?!])\s+/)
+            .map((s) => s.trim())
+            .filter((s) => s.length > 8 && /\w/.test(s));
+    }
+    function clean(text) {
+        return text
+            .replace(/```[\s\S]*?```/g, " ")
+            .replace(/`[^`]+`/g, " ")
+            .replace(/\[[^\]]*\]\([^)]*\)/g, "") // strip markdown links
+            .replace(/[-–>•→]/g, " ")
+            .replace(/\s+/g, " ")
+            .trim();
+    }
+    function isMetaSentence(s) {
+        // simple heuristics for table-of-contents or chapter headings
+        return (/^(\*|#)/.test(s) || // markdown markers
+            /chapter/i.test(s) || // "Chapter 11", "Chapters 11–15"
+            /part\s*\d+/i.test(s) || // "Part 3"
+            /section/i.test(s) || // "Section 2.3"
+            /^\s*[A-Z]\)\s*$/.test(s) || // single-letter outlines
+            s.length < 15 // very short stray lines
+        );
+    }
+    function rewrite(summary) {
+        return summary
+            .replace(/\s+[-–>•→]\s+/g, " ")
+            .replace(/\s+\.\s+/g, ". ")
+            .replace(/([a-z]) - ([a-z])/gi, "$1-$2")
+            .replace(/\s{2,}/g, " ")
+            .trim();
+    }
+    // ------------------------------------------------------------
+    function omegaComposeAnswer(question_1, items_1) {
+        return __awaiter(this, arguments, void 0, function* (question, items, opts = {}) {
+            // License check removed // Premium feature - requires valid license
+            if (!(items === null || items === void 0 ? void 0 : items.length))
+                return "No results found.";
+            const { dim = 64, features = 32, sigma = 1.0, rounds = 3, topSentences = 8, personality = "neutral", } = opts;
+            // ---------- 1. Clean + collect sentences ----------
+            const allText = items.map((i) => clean(i.content)).join(" ");
+            let sentences = splitSentences$1(allText)
+                .filter(s => !isMetaSentence(s))
+                .slice(0, 120);
+            if (sentences.length === 0)
+                return clean(items[0].content).slice(0, 400);
+            // ---------- 2. Build encoder + ridge ----------
+            const rff = buildRFF(dim, features, sigma);
+            const ridge = new OnlineRidge(2 * features, 1, 1e-3);
+            const encode = (s) => {
+                const vec = new Float64Array(dim);
+                const len = Math.min(s.length, dim);
+                for (let i = 0; i < len; i++)
+                    vec[i] = s.charCodeAt(i) / 255;
+                return mapRFF(rff, normalizeL2(vec));
+            };
+            const qVec = encode(question);
+            const qTokens = question.toLowerCase().split(/\W+/).filter((t) => t.length > 2);
+            // ---------- 3. Score + select top sentences ----------
+            const scored = sentences.map((s) => {
+                const v = encode(s);
+                let w = cosine$2(v, qVec);
+                // small lexical bonus for overlapping words
+                const lower = s.toLowerCase();
+                for (const t of qTokens)
+                    if (lower.includes(t))
+                        w += 0.02;
+                return { s, v, w };
+            });
+            scored.sort((a, b) => b.w - a.w);
+            let top = scored.slice(0, topSentences);
+            // ---------- 4. Recursive compression ----------
+            let summary = top.map((t) => t.s).join(" ");
+            let meanVec = new Float64Array(2 * features);
+            for (let r = 0; r < rounds; r++) {
+                const subs = splitSentences$1(summary).slice(0, topSentences);
+                const embeds = subs.map((s) => encode(s));
+                const weights = embeds.map((v) => cosine$2(v, qVec));
+                for (let i = 0; i < embeds.length; i++) {
+                    ridge.update(embeds[i], new Float64Array([weights[i]]));
+                }
+                // weighted mean vector
+                meanVec.fill(0);
+                for (let i = 0; i < embeds.length; i++) {
+                    const v = embeds[i], w = weights[i];
+                    for (let j = 0; j < v.length; j++)
+                        meanVec[j] += v[j] * w;
+                }
+                const norm = l2$1(meanVec) || 1;
+                for (let j = 0; j < meanVec.length; j++)
+                    meanVec[j] /= norm;
+                const rescored = subs.map((s) => ({
+                    s,
+                    w: cosine$2(encode(s), meanVec),
+                }));
+                rescored.sort((a, b) => b.w - a.w);
+                summary = rescored
+                    .slice(0, Math.max(3, Math.floor(topSentences / 2)))
+                    .map((r) => r.s)
+                    .join(" ");
+            }
+            // ---------- 5. Compose readable answer ----------
+            summary = rewrite(summary);
+            const firstChar = summary.charAt(0).toUpperCase() + summary.slice(1);
+            const title = items[0].heading || "Answer";
+            const prefix = personality === "teacher"
+                ? "Here’s a simple way to think about it:\n\n"
+                : personality === "scientist"
+                    ? "From the retrieved material, we can infer:\n\n"
+                    : "";
+            return `${prefix}${firstChar}\n\n(${title}, Ω-synthesized)`;
+        });
+    }
+
+    // Vectorization utilities for sparse and dense vectors
+    // Extracted from workers for reuse
+    /**
+     * Compute TF-IDF vector from tokens
+     */
+    function toTfidf(tokens, idf, vmap, headingW = 1) {
+        const counts = new Map();
+        // crude heuristic: first 8 tokens considered heading-weighted
+        for (let i = 0; i < tokens.length; i++) {
+            const t = tokens[i];
+            const id = vmap.get(t);
+            if (id === undefined)
+                continue;
+            const w = (i < 8) ? headingW : 1;
+            counts.set(id, (counts.get(id) || 0) + w);
+        }
+        const maxTf = Math.max(1, ...counts.values());
+        const v = new Map();
+        for (const [i, c] of counts) {
+            const tf = 0.5 + 0.5 * (c / maxTf);
+            v.set(i, tf * (idf[i] || 0));
+        }
+        return v;
+    }
+    /**
+     * Cosine similarity between two sparse vectors
+     */
+    function cosineSparse(a, b) {
+        let dot = 0, na = 0, nb = 0;
+        for (const [i, av] of a) {
+            na += av * av;
+            const bv = b.get(i);
+            if (bv)
+                dot += av * bv;
+        }
+        for (const [, bv] of b)
+            nb += bv * bv;
+        if (!na || !nb)
+            return 0;
+        return dot / (Math.sqrt(na) * Math.sqrt(nb));
+    }
+    /**
+     * Convert sparse vector to dense Float64Array
+     */
+    function sparseToDense(v, dim) {
+        const x = new Float64Array(dim);
+        for (const [i, val] of v)
+            x[i] = val;
+        return x;
+    }
+    /**
+     * Dot product of two dense vectors
+     */
+    function dotProd$1(a, b) {
+        let s = 0;
+        for (let i = 0; i < a.length; i++)
+            s += a[i] * b[i];
+        return s;
+    }
+    /**
+     * Base kernel function (RBF, cosine, or poly2)
+     */
+    function baseKernel$1(a, b, k, sigma) {
+        if (k === 'cosine') {
+            const dot = dotProd$1(a, b), na = Math.hypot(...a), nb = Math.hypot(...b);
+            return (na && nb) ? (dot / (na * nb)) : 0;
+        }
+        else if (k === 'poly2') {
+            const dot = dotProd$1(a, b);
+            return Math.pow((dot + 1), 2);
+        }
+        else {
+            let s = 0;
+            for (let i = 0; i < a.length; i++) {
+                const d = a[i] - b[i];
+                s += d * d;
+            }
+            return Math.exp(-s / Math.max(1e-9, 2 * sigma * sigma));
+        }
+    }
+    /**
+     * Kernel similarity between two dense vectors
+     */
+    function kernelSim(a, b, k, sigma) {
+        if (k === 'cosine') {
+            const dot = dotProd$1(a, b), na = Math.hypot(...a), nb = Math.hypot(...b);
+            return (na && nb) ? (dot / (na * nb)) : 0;
+        }
+        else if (k === 'poly2') {
+            const dot = dotProd$1(a, b);
+            return Math.pow((dot + 1), 2);
+        }
+        else {
+            let s = 0;
+            for (let i = 0; i < a.length; i++) {
+                const d = a[i] - b[i];
+                s += d * d;
+            }
+            return Math.exp(-s / Math.max(1e-9, 2 * sigma * sigma));
+        }
+    }
+    /**
+     * Project sparse vector to dense using Nyström landmarks
+     */
+    function projectToDense(v, vocabSize, landmarkMat, kernel, sigma) {
+        const x = sparseToDense(v, vocabSize);
+        const feats = new Float64Array(landmarkMat.length);
+        for (let j = 0; j < landmarkMat.length; j++) {
+            const l = landmarkMat[j];
+            feats[j] = baseKernel$1(x, l, kernel, sigma);
+        }
+        const n = Math.hypot(...feats);
+        if (n > 0)
+            for (let i = 0; i < feats.length; i++)
+                feats[i] /= n;
+        return feats;
+    }
+
+    // Tokenization and stemming utilities
+    // Extracted from workers for reuse
+    // Memo for speed
+    const STEM_CACHE = new Map();
+    function normalizeWord(raw) {
+        const k = raw;
+        const cached = STEM_CACHE.get(k);
+        if (cached)
+            return cached;
+        let w = raw.toLowerCase();
+        w = w.replace(/^[^a-z0-9]+|[^a-z0-9]+$/g, '');
+        if (w.length <= 2) {
+            STEM_CACHE.set(k, w);
+            return w;
+        }
+        // plural → singular
+        if (w.endsWith('ies') && w.length > 4) {
+            w = w.slice(0, -3) + 'y';
+        }
+        else if (/(xes|ches|shes|zes|sses)$/.test(w) && w.length > 4) {
+            w = w.replace(/(xes|ches|shes|zes|sses)$/, (m) => (m === 'sses' ? 'ss' : m.replace(/es$/, '')));
+        }
+        else if (w.endsWith('s') && !/(ss|us)$/.test(w) && w.length > 3) {
+            w = w.slice(0, -1);
+        }
+        // conservative suffix trimming
+        const rules = [
+            [/ization$|isation$/, 'ize'],
+            [/ational$/, 'ate'],
+            [/fulness$/, 'ful'],
+            [/ousness$/, 'ous'],
+            [/iveness$/, 'ive'],
+            [/ability$/, 'able'],
+            [/ness$/, ''],
+            [/ment$/, ''],
+            [/ations?$/, 'ate'],
+            [/izer$|iser$/, 'ize'],
+            [/ally$/, 'al'],
+            [/ically$/, 'ic'],
+            [/ingly$|edly$/, ''],
+            [/ing$|ed$/, ''],
+        ];
+        for (const [re, rep] of rules) {
+            if (re.test(w) && w.length - rep.length >= 4) {
+                w = w.replace(re, rep);
+                break;
+            }
+        }
+        STEM_CACHE.set(k, w);
+        return w;
+    }
+    function tokenize$1(text, doStem) {
+        const base = text.toLowerCase()
+            .replace(/[`*_>~]/g, ' ')
+            .replace(/[^a-z0-9]+/g, ' ')
+            .split(/\s+/)
+            .filter(Boolean);
+        if (!doStem)
+            return base;
+        const out = [];
+        for (const t of base) {
+            const n = normalizeWord(t);
+            if (n && n.length > 1)
+                out.push(n);
+        }
+        return out;
+    }
+    function expandQuery(q) {
+        const adds = [];
+        if (/\bmap\b/.test(q))
+            adds.push('dict key value make');
+        if (/\bchan|channel\b/.test(q))
+            adds.push('goroutine concurrency select buffer');
+        if (/\berror\b/.test(q))
+            adds.push('fmt wrap unwrap sentinel try catch');
+        if (/\bstruct\b/.test(q))
+            adds.push('field method receiver init zero value');
+        return q + ' ' + adds.join(' ');
+    }
+
+    // Hybrid retrieval system (sparse + dense + keyword bonus)
+    // Extracted from workers for reuse
+    // License removed - all features are now free!
+    /**
+     * Compute keyword bonus scores for chunks
+     */
+    function keywordBonus(chunks, query) {
+        const kws = Array.from(new Set(query.toLowerCase().split(/\W+/).filter(t => t.length > 2)));
+        const syntaxBoost = /\b(define|declare|syntax|example|function|struct|map|interface)\b/i.test(query);
+        return chunks.map(c => {
+            const text = c.rich || c.content || '';
+            const lc = text.toLowerCase();
+            let hit = 0;
+            for (const k of kws)
+                if (lc.includes(k))
+                    hit++;
+            if (syntaxBoost && /```/.test(text))
+                hit += 5; // strong bonus for code presence
+            return Math.min(1.0, hit * 0.03);
+        });
+    }
+    /**
+     * Get top K indices from scores
+     */
+    function topKIndices(arr, k) {
+        const idx = Array.from(arr, (_, i) => i);
+        idx.sort((i, j) => (arr[j] - arr[i]));
+        return idx.slice(0, k);
+    }
+    /**
+     * Clamp value between min and max
+     */
+    function clamp$1(x, a, b) {
+        return Math.max(a, Math.min(b, x));
+    }
+    /**
+     * Perform hybrid retrieval (sparse + dense + keyword bonus)
+     */
+    function hybridRetrieve(opts) {
+        // License check removed // Premium feature - requires valid license
+        const { query, chunks, vocabMap, idf, tfidfDocs, denseDocs, landmarksIdx, landmarkMat, vocabSize, kernel, sigma, alpha, beta, ridge, headingW, useStem, expandQuery: shouldExpand, topK: k, prefilter, } = opts;
+        // Expand query if needed
+        const qexp = shouldExpand ? expandQuery(query) : query;
+        const toks = tokenize$1(qexp, useStem);
+        const qvec = toTfidf(toks, idf, vocabMap, headingW);
+        const qdense = projectToDense(qvec, vocabSize, landmarkMat, kernel, sigma);
+        // Compute sparse (TF-IDF) scores
+        const tfidfScores = tfidfDocs.map(v => cosineSparse(v, qvec));
+        // Compute dense (kernel) scores
+        const denseScores = denseDocs.map((v) => kernelSim(v, qdense, kernel, sigma));
+        // Compute keyword bonus
+        const bonus = keywordBonus(chunks, query);
+        // Hybrid scoring with ridge regularization
+        const alphaClamped = clamp$1(alpha, 0, 1);
+        const lambda = ridge !== null && ridge !== void 0 ? ridge : 0.08;
+        const scores = denseScores.map((d, i) => {
+            const t = tfidfScores[i];
+            const b = beta * bonus[i];
+            // Ridge damping on ALL components (dense, tfidf, and keyword bonus)
+            const reg = 1 / (1 + lambda * (d * d + t * t + 0.5 * b * b));
+            const s = reg * (alphaClamped * d + (1 - alphaClamped) * t + b);
+            // soft clip extremes; helps prevent a single noisy dimension from dominating
+            return Math.tanh(s);
+        });
+        // Pre-filter then final topK (retrieval stage)
+        const pre = Math.max(k, prefilter !== null && prefilter !== void 0 ? prefilter : 0);
+        const idxs = topKIndices(scores, pre);
+        const finalIdxs = topKIndices(idxs.map(i => scores[i]), k).map(k => idxs[k]);
+        // Build result items
+        const items = finalIdxs.map(i => {
+            const c = chunks[i];
+            const body = (c.rich && c.rich.trim()) || (c.content && c.content.trim()) || '(see subsections)';
+            return {
+                score: scores[i],
+                heading: c.heading,
+                content: body,
+                index: i,
+            };
+        });
+        return {
+            items,
+            scores: finalIdxs.map(i => scores[i]),
+            indices: finalIdxs,
+            tfidfScores: finalIdxs.map(i => tfidfScores[i]),
+            denseScores: finalIdxs.map(i => denseScores[i]),
+        };
+    }
+
+    // OmegaRR.ts
+    // Reranker + Reducer for AsterMind docs
+    // - Extracts rich query–chunk features (sparse text + structural signals)
+    // - Trains a tiny ridge model on-the-fly with weak supervision (per query)
+    // - Produces score_rr and p_relevant
+    // - Filters with threshold + MMR coverage under a character budget
+    // - (v2) Optionally exposes engineered features (values + names) for TE/diagnostics
+    /* ====================== Tokenization ======================= */
+    const STOP$1 = new Set([
+        "a", "an", "the", "and", "or", "but", "if", "then", "else", "for", "to", "of", "in", "on", "at", "by", "with",
+        "is", "are", "was", "were", "be", "been", "being", "as", "from", "that", "this", "it", "its", "you", "your",
+        "i", "we", "they", "he", "she", "them", "his", "her", "our", "us", "do", "does", "did", "done", "not", "no",
+        "yes", "can", "could", "should", "would", "may", "might", "into", "about", "over", "under", "between"
+    ]);
+    function tokenize(s) {
+        return s
+            .toLowerCase()
+            .replace(/[`*_#>~=\[\]{}()!?.:,;'"<>|/\\+-]+/g, " ")
+            .split(/\s+/)
+            .filter(t => t && !STOP$1.has(t));
+    }
+    function unique(arr) { return Array.from(new Set(arr)); }
+    function buildCorpusStats(docs) {
+        const vocab = new Map();
+        const tfs = [];
+        const docLens = [];
+        let nextId = 0;
+        for (const d of docs) {
+            const toks = tokenize(d);
+            docLens.push(toks.length);
+            const tf = new Map();
+            for (const w of toks) {
+                let id = vocab.get(w);
+                if (id === undefined) {
+                    id = nextId++;
+                    vocab.set(w, id);
+                }
+                tf.set(id, (tf.get(id) || 0) + 1);
+            }
+            tfs.push(tf);
+        }
+        const N = docs.length;
+        const df = Array(nextId).fill(0);
+        for (const tf of tfs)
+            for (const id of tf.keys())
+                df[id] += 1;
+        const idf = df.map(df_i => Math.log((N + 1) / (df_i + 1)) + 1);
+        const avgLen = docLens.reduce((a, b) => a + b, 0) / Math.max(1, N);
+        return { stats: { vocab, idf, avgLen, df }, tf: tfs, docLens };
+    }
+    function tfidfVector(tf, idf) {
+        const out = new Map();
+        let norm2 = 0;
+        for (const [i, f] of tf) {
+            const val = (f) * (idf[i] || 0);
+            out.set(i, val);
+            norm2 += val * val;
+        }
+        const norm = Math.sqrt(norm2) || 1e-12;
+        for (const [i, v] of out)
+            out.set(i, v / norm);
+        return out;
+    }
+    function cosine$1(a, b) {
+        const [small, large] = a.size < b.size ? [a, b] : [b, a];
+        let dot = 0;
+        for (const [i, v] of small) {
+            const u = large.get(i);
+            if (u !== undefined)
+                dot += v * u;
+        }
+        return dot;
+    }
+    function bm25Score(qTf, dTf, stats, dLen, k1 = 1.5, b = 0.75) {
+        let score = 0;
+        for (const [i] of qTf) {
+            const f = dTf.get(i) || 0;
+            if (f <= 0)
+                continue;
+            const idf = Math.log(((stats.df[i] || 0) + 0.5) / ((stats.idf.length - (stats.df[i] || 0)) + 0.5) + 1);
+            const denom = f + k1 * (1 - b + b * (dLen / (stats.avgLen || 1)));
+            score += idf * ((f * (k1 + 1)) / (denom || 1e-12));
+        }
+        return score;
+    }
+    /* ========== Light Random Projection from TF-IDF (dense hint) ========== */
+    function projectSparse(vec, dim, seed = 1337) {
+        // deterministic per (feature, j) hash: simple LCG/xorshift mix
+        const out = new Float64Array(dim);
+        for (const [i, v] of vec) {
+            let s = (i * 2654435761) >>> 0;
+            for (let j = 0; j < dim; j++) {
+                s ^= s << 13;
+                s ^= s >>> 17;
+                s ^= s << 5;
+                const r = ((s >>> 0) / 4294967296) * 2 - 1; // [-1,1]
+                out[j] += v * r;
+            }
+        }
+        let n2 = 0;
+        for (let j = 0; j < dim; j++)
+            n2 += out[j] * out[j];
+        const n = Math.sqrt(n2) || 1e-12;
+        for (let j = 0; j < dim; j++)
+            out[j] /= n;
+        return out;
+    }
+    /* ===================== Structural Signals ===================== */
+    function containsGoCodeBlock(s) {
+        return /```+\s*go([\s\S]*?)```/i.test(s) || /\bfunc\s+\w+\s*\(.*\)\s*\w*\s*{/.test(s);
+    }
+    function containsCodeBlock(s) {
+        return /```+/.test(s) || /{[^}]*}/.test(s);
+    }
+    function headingQueryMatch(head, q) {
+        const ht = unique(tokenize(head));
+        const qt = new Set(tokenize(q));
+        if (ht.length === 0 || qt.size === 0)
+            return 0;
+        let hit = 0;
+        for (const t of ht)
+            if (qt.has(t))
+                hit++;
+        return hit / ht.length;
+    }
+    function jaccard$1(a, b) {
+        const A = new Set(tokenize(a));
+        const B = new Set(tokenize(b));
+        let inter = 0;
+        for (const t of A)
+            if (B.has(t))
+                inter++;
+        const uni = A.size + B.size - inter;
+        return uni === 0 ? 0 : inter / uni;
+    }
+    function golangSpecFlag(s) {
+        return /(golang\.org|go\.dev|pkg\.go\.dev)/i.test(s) ? 1 : 0;
+    }
+    function buildFeatures$1(q, chunk, qTfIdf, cTfIdf, qTfRaw, cTfRaw, stats, cLen, projQ, projC) {
+        var _a;
+        const f = [];
+        const names = [];
+        // 1) Sparse sims
+        const cos = cosine$1(qTfIdf, cTfIdf);
+        f.push(cos);
+        names.push("cosine_tfidf");
+        const bm25 = bm25Score(qTfRaw, cTfRaw, stats, cLen);
+        f.push(bm25);
+        names.push("bm25");
+        // 2) Heading & lexical overlaps
+        const hMatch = headingQueryMatch(chunk.heading || "", q);
+        f.push(hMatch);
+        names.push("heading_match_frac");
+        const jac = jaccard$1(q, chunk.content || "");
+        f.push(jac);
+        names.push("jaccard_tokens");
+        // 3) Structural flags
+        const hasGo = containsGoCodeBlock(chunk.rich || chunk.content || "");
+        const hasCode = containsCodeBlock(chunk.rich || chunk.content || "");
+        f.push(hasGo ? 1 : 0);
+        names.push("flag_go_code");
+        f.push(hasCode ? 1 : 0);
+        names.push("flag_any_code");
+        // 4) Source cues
+        f.push(golangSpecFlag(chunk.content || "") ? 1 : 0);
+        names.push("flag_go_spec_link");
+        // 5) Prior score (baseline)
+        f.push(((_a = chunk.score_base) !== null && _a !== void 0 ? _a : 0));
+        names.push("prior_score_base");
+        // 6) Length heuristics (prefer concise answers)
+        const lenChars = (chunk.content || "").length;
+        f.push(1 / Math.sqrt(1 + lenChars));
+        names.push("len_inv_sqrt");
+        // 7) Dense hint from projection
+        if (projQ && projC) {
+            let dot = 0, l1 = 0;
+            for (let i = 0; i < projQ.length; i++) {
+                dot += projQ[i] * projC[i];
+                l1 += Math.abs(projQ[i] - projC[i]);
+            }
+            f.push(dot);
+            names.push("proj_dot");
+            f.push(l1 / projQ.length);
+            names.push("proj_l1mean");
+        }
+        return { names, values: f };
+    }
+    /* ======================== Ridge Model ======================== */
+    class Ridge {
+        constructor() {
+            this.w = null;
+            this.mu = null;
+            this.sigma = null;
+        }
+        fit(X, y, lambda = 1e-2) {
+            var _a;
+            const n = X.length;
+            const d = ((_a = X[0]) === null || _a === void 0 ? void 0 : _a.length) || 0;
+            if (n === 0 || d === 0) {
+                this.w = new Float64Array(d);
+                return;
+            }
+            // standardize
+            const mu = new Float64Array(d);
+            const sig = new Float64Array(d);
+            for (let j = 0; j < d; j++) {
+                let m = 0;
+                for (let i = 0; i < n; i++)
+                    m += X[i][j];
+                m /= n;
+                mu[j] = m;
+                let v = 0;
+                for (let i = 0; i < n; i++) {
+                    const z = X[i][j] - m;
+                    v += z * z;
+                }
+                sig[j] = Math.sqrt(v / n) || 1;
+            }
+            const Z = Array.from({ length: n }, (_, i) => new Float64Array(d));
+            for (let i = 0; i < n; i++)
+                for (let j = 0; j < d; j++)
+                    Z[i][j] = (X[i][j] - mu[j]) / sig[j];
+            // A = Z^T Z + λI, Zy = Z^T y
+            const A = Array.from({ length: d }, () => new Float64Array(d));
+            const Zy = new Float64Array(d);
+            for (let i = 0; i < n; i++) {
+                const zi = Z[i];
+                const yi = y[i];
+                for (let j = 0; j < d; j++) {
+                    Zy[j] += zi[j] * yi;
+                    const zij = zi[j];
+                    for (let k = 0; k <= j; k++)
+                        A[j][k] += zij * zi[k];
+                }
+            }
+            for (let j = 0; j < d; j++) {
+                for (let k = 0; k < j; k++)
+                    A[k][j] = A[j][k];
+                A[j][j] += lambda;
+            }
+            // Cholesky solve
+            const L = Array.from({ length: d }, () => new Float64Array(d));
+            for (let i = 0; i < d; i++) {
+                for (let j = 0; j <= i; j++) {
+                    let sum = A[i][j];
+                    for (let k = 0; k < j; k++)
+                        sum -= L[i][k] * L[j][k];
+                    L[i][j] = (i === j) ? Math.sqrt(Math.max(sum, 1e-12)) : (sum / (L[j][j] || 1e-12));
+                }
+            }
+            const z = new Float64Array(d);
+            for (let i = 0; i < d; i++) {
+                let s = Zy[i];
+                for (let k = 0; k < i; k++)
+                    s -= L[i][k] * z[k];
+                z[i] = s / (L[i][i] || 1e-12);
+            }
+            const w = new Float64Array(d);
+            for (let i = d - 1; i >= 0; i--) {
+                let s = z[i];
+                for (let k = i + 1; k < d; k++)
+                    s -= L[k][i] * w[k];
+                w[i] = s / (L[i][i] || 1e-12);
+            }
+            this.w = w;
+            this.mu = mu;
+            this.sigma = sig;
+        }
+        predict(x) {
+            if (!this.w || !this.mu || !this.sigma)
+                return 0;
+            let s = 0;
+            for (let j = 0; j < this.w.length; j++) {
+                const z = (x[j] - this.mu[j]) / this.sigma[j];
+                s += this.w[j] * z;
+            }
+            return s;
+        }
+    }
+    /* ===================== Weak Supervision ===================== */
+    function generateWeakLabel(q, chunk, feats) {
+        var _a;
+        const txt = (chunk.rich || chunk.content || "");
+        let y = 0;
+        const qIsGoFunc = /\bgo\b/.test(q.toLowerCase()) && /(define|declare|function|func)/i.test(q);
+        if (qIsGoFunc && containsGoCodeBlock(txt))
+            y = Math.max(y, 1.0);
+        const headHit = headingQueryMatch(chunk.heading || "", q);
+        if (headHit >= 0.34 && containsCodeBlock(txt))
+            y = Math.max(y, 0.8);
+        const cosIdx = feats.names.indexOf("cosine_tfidf");
+        const bm25Idx = feats.names.indexOf("bm25");
+        const cos = cosIdx >= 0 ? feats.values[cosIdx] : 0;
+        const bm = bm25Idx >= 0 ? feats.values[bm25Idx] : 0;
+        if (cos > 0.25)
+            y = Math.max(y, 0.6);
+        if (bm > 1.0)
+            y = Math.max(y, 0.6);
+        const priorIdx = feats.names.indexOf("prior_score_base");
+        const prior = priorIdx >= 0 ? feats.values[priorIdx] : 0;
+        if (((_a = chunk.score_base) !== null && _a !== void 0 ? _a : 0) > 0)
+            y = Math.max(y, Math.min(0.6, 0.2 + 0.5 * prior));
+        return y;
+    }
+    function sigmoid(x) {
+        if (x >= 0) {
+            const z = Math.exp(-x);
+            return 1 / (1 + z);
+        }
+        else {
+            const z = Math.exp(x);
+            return z / (1 + z);
+        }
+    }
+    /* ========================= MMR Filter ========================= */
+    function mmrFilter(scored, lambda = 0.7, budgetChars = 1200) {
+        const sel = [];
+        const docs = scored.map(s => s.content || "");
+        const { stats, tf: tfList } = buildCorpusStats(docs);
+        const tfidf = tfList.map(tf => tfidfVector(tf, stats.idf));
+        const selectedIdx = new Set();
+        let used = 0;
+        while (selectedIdx.size < scored.length) {
+            let bestIdx = -1, bestVal = -Infinity;
+            for (let i = 0; i < scored.length; i++) {
+                if (selectedIdx.has(i))
+                    continue;
+                const cand = scored[i];
+                let red = 0;
+                for (const j of selectedIdx) {
+                    const sim = cosine$1(tfidf[i], tfidf[j]);
+                    if (sim > red)
+                        red = sim;
+                }
+                const val = lambda * cand.score_rr - (1 - lambda) * red;
+                if (val > bestVal) {
+                    bestVal = val;
+                    bestIdx = i;
+                }
+            }
+            if (bestIdx < 0)
+                break;
+            const chosen = scored[bestIdx];
+            const addLen = (chosen.content || "").length;
+            if (used + addLen > budgetChars && sel.length > 0)
+                break;
+            sel.push(chosen);
+            used += addLen;
+            selectedIdx.add(bestIdx);
+        }
+        return sel;
+    }
+    /* ========================= Public API ========================= */
+    /** Train per-query ridge model and score chunks. */
+    function rerank(query, chunks, opts = {}) {
+        var _a, _b;
+        // License check removed // Premium feature - requires valid license
+        const { lambdaRidge = 1e-2, randomProjDim = 32, exposeFeatures = true, attachFeatureNames = false, } = opts;
+        const docs = [query, ...chunks.map(c => c.content || "")];
+        const { stats, tf: tfRaw, docLens } = buildCorpusStats(docs);
+        const tfidfAll = tfRaw.map(tf => tfidfVector(tf, stats.idf));
+        const qTfRaw = tfRaw[0];
+        const qTfIdf = tfidfAll[0];
+        const projQ = randomProjDim > 0 ? projectSparse(qTfIdf, randomProjDim) : undefined;
+        const X = [];
+        const y = [];
+        const featPacks = [];
+        for (let i = 0; i < chunks.length; i++) {
+            const c = chunks[i];
+            const cTfRaw = tfRaw[i + 1];
+            const cTfIdf = tfidfAll[i + 1];
+            const projC = randomProjDim > 0 ? projectSparse(cTfIdf, randomProjDim, 1337 + i) : undefined;
+            const feats = buildFeatures$1(query, c, qTfIdf, cTfIdf, qTfRaw, cTfRaw, stats, docLens[i + 1] || 1, projQ, projC);
+            featPacks.push(feats);
+            X.push(feats.values);
+            const label = generateWeakLabel(query, c, feats);
+            y.push(label);
+        }
+        const allSame = y.every(v => Math.abs(v - y[0]) < 1e-9);
+        if (allSame) {
+            const cosIdx = featPacks[0].names.indexOf("cosine_tfidf");
+            if (cosIdx >= 0) {
+                for (let i = 0; i < y.length; i++)
+                    y[i] = Math.max(0, Math.min(1, 0.2 + 0.6 * X[i][cosIdx]));
+            }
+        }
+        const rr = new Ridge();
+        rr.fit(X, y, lambdaRidge);
+        let minS = Infinity, maxS = -Infinity;
+        const rawScores = X.map(x => rr.predict(x));
+        for (const s of rawScores) {
+            if (s < minS)
+                minS = s;
+            if (s > maxS)
+                maxS = s;
+        }
+        const range = Math.max(1e-9, maxS - minS);
+        const featureNames = attachFeatureNames ? (_b = (_a = featPacks[0]) === null || _a === void 0 ? void 0 : _a.names) !== null && _b !== void 0 ? _b : [] : undefined;
+        const scored = chunks.map((c, i) => {
+            const s01 = (rawScores[i] - minS) / range;
+            const p = sigmoid((rawScores[i] - 0.5 * (minS + maxS)) / (0.2 * range + 1e-6));
+            const base = Object.assign(Object.assign({}, c), { score_rr: s01, p_relevant: p });
+            if (exposeFeatures)
+                base._features = X[i];
+            if (featureNames)
+                base._feature_names = featureNames;
+            return base;
+        });
+        scored.sort((a, b) => b.score_rr - a.score_rr);
+        return scored;
+    }
+    /** Filter scored chunks using probability/near-top thresholds and MMR coverage. */
+    function filterMMR(scored, opts = {}) {
+        // License check removed // Premium feature - requires valid license
+        const { probThresh = 0.45, epsilonTop = 0.05, useMMR = true, mmrLambda = 0.7, budgetChars = 1200 } = opts;
+        if (scored.length === 0)
+            return [];
+        const top = scored[0].score_rr;
+        const bandKept = scored.filter(s => s.p_relevant >= probThresh && s.score_rr >= (top - epsilonTop));
+        const seed = bandKept.length > 0 ? bandKept : [scored[0]];
+        if (!useMMR) {
+            const out = [];
+            let used = 0;
+            for (const s of seed) {
+                const add = (s.content || "").length;
+                if (used + add > budgetChars && out.length > 0)
+                    break;
+                out.push(s);
+                used += add;
+            }
+            return out;
+        }
+        const boosted = scored.map(s => (Object.assign(Object.assign({}, s), { score_rr: seed.includes(s) ? s.score_rr + 0.01 : s.score_rr })));
+        return mmrFilter(boosted, mmrLambda, budgetChars);
+    }
+    /** Convenience: run rerank then filter. */
+    function rerankAndFilter(query, chunks, opts = {}) {
+        // License check removed // Premium feature - requires valid license
+        const scored = rerank(query, chunks, opts);
+        return filterMMR(scored, opts);
+    }
+    function importModel(model, opts) {
+        // License check removed // Premium feature - requires valid license
+        if (model.version !== 'astermind-pro-v1' && model.version !== 'astermind-elm-v1') {
+            throw new Error(`Unsupported model version: ${model.version}. Expected 'astermind-pro-v1' or 'astermind-elm-v1'`);
+        }
+        // 1) restore settings
+        const settings = JSON.parse(JSON.stringify(model.settings || {}));
+        // 2) vocab & idf
+        const vocabMap = new Map(model.vocab);
+        const idf = Float64Array.from(model.idf); // keep as number[] for compatibility
+        // 3) chunks
+        const chunks = model.chunks.map(c => ({
+            heading: c.heading,
+            content: c.content || '',
+            rich: c.rich,
+            level: c.level,
+            secId: c.secId
+        }));
+        // 4) tfidfDocs from pairs
+        const tfidfDocs = model.tfidfDocs.map(row => {
+            const m = new Map();
+            for (const [i, v] of row)
+                m.set(i, v);
+            return m;
+        });
+        // 5) Nyström landmarks
+        const landmarksIdx = Array.from(model.landmarksIdx);
+        const landmarkMat = model.landmarkMat.map(a => Float64Array.from(a));
+        // 6) denseDocs: use stored or recompute
+        const needRecompute = !model.denseDocs || model.denseDocs.length !== tfidfDocs.length;
+        let denseDocs;
+        if (needRecompute) {
+            throw new Error('recomputeDense=true but buildDense function not provided');
+        }
+        else {
+            denseDocs = model.denseDocs.map(a => Float64Array.from(a));
+        }
+        return {
+            settings,
+            vocabMap,
+            idf,
+            chunks,
+            tfidfDocs,
+            landmarksIdx,
+            landmarkMat,
+            denseDocs,
+        };
+    }
+
+    // src/omega/OmegaOfflineRAG.ts
+    // Omega-powered offline RAG using @astermind/astermind-community
+    /**
+     * Omega-powered offline RAG class
+     *
+     * Uses @astermind/astermind-community for hybrid retrieval and reranking.
+     * Provides enhanced offline capabilities over simple TF-IDF fallback.
+     */
+    class OmegaOfflineRAG {
+        constructor(config) {
+            this.modelState = null;
+            this.model = null;
+            this.config = {
+                reranking: {
+                    enabled: config?.reranking?.enabled ?? true,
+                    lambdaRidge: config?.reranking?.lambdaRidge ?? 0.1,
+                    useMMR: config?.reranking?.useMMR ?? true,
+                    mmrLambda: config?.reranking?.mmrLambda ?? 0.5,
+                    probThresh: config?.reranking?.probThresh ?? 0.1
+                },
+                topK: config?.topK ?? 5,
+                verbose: config?.verbose ?? false
+            };
+        }
+        /**
+         * Load a pre-exported model from SerializedModel object
+         */
+        async loadModel(model) {
+            const startTime = performance.now();
+            this.model = model;
+            this.modelState = importModel(model);
+            if (this.config.verbose) {
+                const loadTime = performance.now() - startTime;
+                console.log(`[OmegaOfflineRAG] Model loaded in ${loadTime.toFixed(0)}ms`);
+                console.log(`[OmegaOfflineRAG] ${this.modelState.chunks.length} chunks, ${this.modelState.vocabMap.size} vocab`);
+            }
+        }
+        /**
+         * Load model from a URL
+         */
+        async loadModelFromUrl(url) {
+            const response = await fetch(url);
+            if (!response.ok) {
+                throw new Error(`Failed to fetch model from ${url}: ${response.status}`);
+            }
+            const model = await response.json();
+            await this.loadModel(model);
+        }
+        /**
+         * Check if model is loaded and ready
+         */
+        isReady() {
+            return this.modelState !== null;
+        }
+        /**
+         * Get model information
+         */
+        getModelInfo() {
+            if (!this.model || !this.modelState)
+                return null;
+            return {
+                version: this.model.version,
+                savedAt: this.model.savedAt,
+                documentCount: this.modelState.chunks.length,
+                vocabularySize: this.modelState.vocabMap.size,
+                landmarkCount: this.modelState.landmarksIdx.length,
+                hasDenseVectors: this.modelState.denseDocs.length > 0,
+                settings: this.model.settings
+            };
+        }
+        /**
+         * Perform RAG query and return answer with sources
+         */
+        async ask(query) {
+            const startTime = performance.now();
+            if (!this.modelState || !this.model) {
+                return {
+                    answer: 'Omega model not loaded. Please load a model first.',
+                    confidence: 'none',
+                    sources: [],
+                    processingTime: 0,
+                    degraded: true,
+                    degradedReason: 'Model not loaded'
+                };
+            }
+            try {
+                // Extract settings with proper type assertions
+                const settings = this.model.settings;
+                const kernel = settings.kernel ?? 'rbf';
+                const sigma = settings.sigma ?? 1.0;
+                const alpha = settings.alpha ?? 0.5;
+                const beta = settings.beta ?? 0.3;
+                const ridge = settings.ridge ?? 0.001;
+                const headingW = settings.headingW ?? 0.2;
+                const useStem = settings.useStem ?? true;
+                const expandQuery = settings.expandQuery ?? false;
+                const prefilter = settings.prefilter ?? 100;
+                // Perform hybrid retrieval
+                const retrievalResult = hybridRetrieve({
+                    query,
+                    chunks: this.modelState.chunks,
+                    vocabMap: this.modelState.vocabMap,
+                    idf: this.modelState.idf,
+                    tfidfDocs: this.modelState.tfidfDocs,
+                    denseDocs: this.modelState.denseDocs,
+                    landmarksIdx: this.modelState.landmarksIdx,
+                    landmarkMat: this.modelState.landmarkMat,
+                    vocabSize: this.modelState.vocabMap.size,
+                    kernel: kernel,
+                    sigma,
+                    alpha,
+                    beta,
+                    ridge,
+                    headingW,
+                    useStem,
+                    expandQuery,
+                    topK: this.config.topK * 2, // Get more for reranking
+                    prefilter
+                });
+                let sources;
+                // Apply reranking if enabled
+                if (this.config.reranking.enabled && retrievalResult.items.length > 0) {
+                    const chunksForRerank = retrievalResult.items.map((item, idx) => ({
+                        heading: item.heading,
+                        content: item.content,
+                        rich: item.rich,
+                        score_base: retrievalResult.scores[idx]
+                    }));
+                    const reranked = rerankAndFilter(query, chunksForRerank, {
+                        lambdaRidge: this.config.reranking.lambdaRidge,
+                        useMMR: this.config.reranking.useMMR,
+                        mmrLambda: this.config.reranking.mmrLambda,
+                        probThresh: this.config.reranking.probThresh
+                    });
+                    sources = reranked.slice(0, this.config.topK).map((chunk) => ({
+                        heading: chunk.heading,
+                        content: chunk.content,
+                        rich: chunk.rich,
+                        score: chunk.score_base ?? 0,
+                        rerankScore: chunk.score_rr,
+                        probability: chunk.p_relevant
+                    }));
+                }
+                else {
+                    sources = retrievalResult.items.slice(0, this.config.topK).map((item, idx) => ({
+                        heading: item.heading,
+                        content: item.content,
+                        rich: item.rich,
+                        score: retrievalResult.scores[idx]
+                    }));
+                }
+                // Compose answer using Omega
+                const answer = await omegaComposeAnswer(query, sources.map(s => ({ heading: s.heading, content: s.content, score: s.score })));
+                const processingTime = performance.now() - startTime;
+                // Determine confidence based on scores
+                const topScore = sources[0]?.score ?? 0;
+                const confidence = this.determineConfidence(topScore, sources.length);
+                // Classify query type
+                const queryClassification = this.classifyQuery(query);
+                return {
+                    answer,
+                    confidence,
+                    sources,
+                    processingTime,
+                    degraded: false,
+                    queryClassification
+                };
+            }
+            catch (error) {
+                const processingTime = performance.now() - startTime;
+                console.error('[OmegaOfflineRAG] Error during retrieval:', error);
+                return {
+                    answer: 'An error occurred while processing your question offline.',
+                    confidence: 'none',
+                    sources: [],
+                    processingTime,
+                    degraded: true,
+                    degradedReason: error instanceof Error ? error.message : 'Unknown error'
+                };
+            }
+        }
+        /**
+         * Retrieve relevant chunks without generating an answer
+         */
+        async retrieve(query, topK) {
+            if (!this.modelState || !this.model) {
+                return [];
+            }
+            const k = topK ?? this.config.topK;
+            // Extract settings with proper type assertions
+            const settings = this.model.settings;
+            const kernel = settings.kernel ?? 'rbf';
+            const sigma = settings.sigma ?? 1.0;
+            const alpha = settings.alpha ?? 0.5;
+            const beta = settings.beta ?? 0.3;
+            const ridge = settings.ridge ?? 0.001;
+            const headingW = settings.headingW ?? 0.2;
+            const useStem = settings.useStem ?? true;
+            const expandQuery = settings.expandQuery ?? false;
+            const prefilter = settings.prefilter ?? 100;
+            const retrievalResult = hybridRetrieve({
+                query,
+                chunks: this.modelState.chunks,
+                vocabMap: this.modelState.vocabMap,
+                idf: this.modelState.idf,
+                tfidfDocs: this.modelState.tfidfDocs,
+                denseDocs: this.modelState.denseDocs,
+                landmarksIdx: this.modelState.landmarksIdx,
+                landmarkMat: this.modelState.landmarkMat,
+                vocabSize: this.modelState.vocabMap.size,
+                kernel: kernel,
+                sigma,
+                alpha,
+                beta,
+                ridge,
+                headingW,
+                useStem,
+                expandQuery,
+                topK: k,
+                prefilter
+            });
+            return retrievalResult.items.map((item, idx) => ({
+                heading: item.heading,
+                content: item.content,
+                rich: item.rich,
+                score: retrievalResult.scores[idx]
+            }));
+        }
+        /**
+         * Classify query type for better handling
+         */
+        classifyQuery(query) {
+            const lowerQuery = query.toLowerCase();
+            const words = lowerQuery.split(/\s+/);
+            // Simple keyword-based classification
+            const factualKeywords = ['what', 'who', 'when', 'where', 'which', 'is', 'are', 'was', 'were'];
+            const proceduralKeywords = ['how', 'steps', 'guide', 'tutorial', 'process', 'procedure'];
+            const conceptualKeywords = ['why', 'explain', 'describe', 'meaning', 'definition', 'concept'];
+            const navigationKeywords = ['go to', 'navigate', 'find', 'page', 'link', 'take me', 'show me'];
+            let type = 'unknown';
+            let confidence = 0.5;
+            const keywords = [];
+            // Check navigation first (phrase matching)
+            for (const phrase of navigationKeywords) {
+                if (lowerQuery.includes(phrase)) {
+                    type = 'navigational';
+                    confidence = 0.8;
+                    keywords.push(phrase);
+                    break;
+                }
+            }
+            if (type === 'unknown') {
+                // Check other types
+                const firstWord = words[0];
+                if (proceduralKeywords.includes(firstWord) || proceduralKeywords.some(k => lowerQuery.includes(k))) {
+                    type = 'procedural';
+                    confidence = 0.7;
+                    keywords.push(...proceduralKeywords.filter(k => lowerQuery.includes(k)));
+                }
+                else if (conceptualKeywords.includes(firstWord) || conceptualKeywords.some(k => lowerQuery.includes(k))) {
+                    type = 'conceptual';
+                    confidence = 0.7;
+                    keywords.push(...conceptualKeywords.filter(k => lowerQuery.includes(k)));
+                }
+                else if (factualKeywords.includes(firstWord)) {
+                    type = 'factual';
+                    confidence = 0.7;
+                    keywords.push(firstWord);
+                }
+            }
+            return { type, confidence, keywords };
+        }
+        /**
+         * Determine confidence level based on retrieval scores
+         */
+        determineConfidence(topScore, sourceCount) {
+            if (sourceCount === 0)
+                return 'none';
+            if (topScore >= 0.7)
+                return 'medium'; // Never 'high' for offline
+            if (topScore >= 0.4)
+                return 'medium';
+            if (topScore >= 0.2)
+                return 'low';
+            return 'low';
+        }
+        /**
+         * Clear loaded model
+         */
+        clear() {
+            this.modelState = null;
+            this.model = null;
+        }
+    }
+
+    var OmegaOfflineRAG$1 = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        OmegaOfflineRAG: OmegaOfflineRAG
+    });
+
     // src/full.ts
     // Full package exports (core + agentic)
     //
@@ -3411,7 +5409,9 @@ LJ5AZXvOhHaXdHzMuYKX5BpK4w7TqbPvJ6QPvKmLKvHh1VKcUJ6mJQgJJw==
     exports.CyberneticClient = CyberneticClient;
     exports.CyberneticIntentClassifier = CyberneticIntentClassifier;
     exports.CyberneticLocalRAG = CyberneticLocalRAG;
+    exports.CyberneticOfflineStorage = CyberneticOfflineStorage;
     exports.LicenseManager = LicenseManager;
+    exports.OmegaOfflineRAG = OmegaOfflineRAG;
     exports.REQUIRED_FEATURES = REQUIRED_FEATURES;
     exports.createClient = createClient;
     exports.createLicenseManager = createLicenseManager;