@astermind/cybernetic-chatbot-client 1.0.6

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

@@ -0,0 +1,3290 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+    typeof define === 'function' && define.amd ? define(['exports'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.AsterMindCybernetic = {}));
+})(this, (function (exports) { 'use strict';
+
+    // src/ApiClient.ts
+    // HTTP client for AsterMind backend API
+    /**
+     * HTTP/SSE client for AsterMind backend
+     */
+    class ApiClient {
+        constructor(baseUrl, apiKey) {
+            this.baseUrl = baseUrl.replace(/\/$/, ''); // Remove trailing slash
+            this.apiKey = apiKey;
+        }
+        /**
+         * Send chat message and get complete response
+         */
+        async chat(message, options) {
+            const response = await fetch(`${this.baseUrl}/api/external/chat`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'X-API-Key': this.apiKey
+                },
+                body: JSON.stringify({
+                    message,
+                    sessionId: options?.sessionId,
+                    context: options?.context
+                })
+            });
+            if (!response.ok) {
+                const error = await response.json().catch(() => ({}));
+                throw new Error(error.message || `HTTP ${response.status}: ${response.statusText}`);
+            }
+            return response.json();
+        }
+        /**
+         * Send chat message with streaming response via SSE
+         */
+        async chatStream(message, options) {
+            const response = await fetch(`${this.baseUrl}/api/external/chat/stream`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'X-API-Key': this.apiKey
+                },
+                body: JSON.stringify({
+                    message,
+                    sessionId: options?.sessionId,
+                    context: options?.context
+                })
+            });
+            if (!response.ok) {
+                const error = await response.json().catch(() => ({}));
+                throw new Error(error.message || `HTTP ${response.status}`);
+            }
+            const reader = response.body?.getReader();
+            if (!reader) {
+                throw new Error('Streaming not supported');
+            }
+            const decoder = new TextDecoder();
+            let buffer = '';
+            let fullText = '';
+            let sources = [];
+            let sessionId;
+            try {
+                while (true) {
+                    const { done, value } = await reader.read();
+                    if (done)
+                        break;
+                    buffer += decoder.decode(value, { stream: true });
+                    const lines = buffer.split('\n');
+                    buffer = lines.pop() || '';
+                    for (const line of lines) {
+                        if (line.startsWith('event: ')) {
+                            // Event type handled in data line
+                        }
+                        else if (line.startsWith('data: ')) {
+                            try {
+                                const data = JSON.parse(line.slice(6));
+                                if (data.text !== undefined) {
+                                    // Token event
+                                    fullText += data.text;
+                                    options.onToken?.(data.text);
+                                }
+                                else if (data.sources !== undefined) {
+                                    // Sources event
+                                    sources = data.sources;
+                                    options.onSources?.(sources);
+                                }
+                                else if (data.sessionId !== undefined) {
+                                    // Done event
+                                    sessionId = data.sessionId;
+                                }
+                            }
+                            catch {
+                                // Skip malformed JSON
+                            }
+                        }
+                    }
+                }
+                options.onComplete?.({ fullText, sessionId, sources });
+            }
+            catch (error) {
+                options.onError?.(error);
+            }
+        }
+        /**
+         * Get general documents for caching
+         */
+        async getGeneralDocs(since) {
+            const params = new URLSearchParams();
+            if (since) {
+                params.set('since', since);
+            }
+            const url = `${this.baseUrl}/api/external/docs${params.toString() ? '?' + params : ''}`;
+            const response = await fetch(url, {
+                headers: {
+                    'X-API-Key': this.apiKey
+                }
+            });
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}`);
+            }
+            const data = await response.json();
+            return data.documents;
+        }
+        /**
+         * Get API status, quota, and system settings
+         */
+        async getStatus() {
+            const response = await fetch(`${this.baseUrl}/api/external/status`, {
+                headers: {
+                    'X-API-Key': this.apiKey
+                }
+            });
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}`);
+            }
+            return response.json();
+        }
+        /**
+         * Health check (no auth required)
+         */
+        async health() {
+            const response = await fetch(`${this.baseUrl}/api/external/health`);
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}`);
+            }
+            return response.json();
+        }
+    }
+
+    const instanceOfAny = (object, constructors) => constructors.some((c) => object instanceof c);
+
+    let idbProxyableTypes;
+    let cursorAdvanceMethods;
+    // This is a function to prevent it throwing up in node environments.
+    function getIdbProxyableTypes() {
+        return (idbProxyableTypes ||
+            (idbProxyableTypes = [
+                IDBDatabase,
+                IDBObjectStore,
+                IDBIndex,
+                IDBCursor,
+                IDBTransaction,
+            ]));
+    }
+    // This is a function to prevent it throwing up in node environments.
+    function getCursorAdvanceMethods() {
+        return (cursorAdvanceMethods ||
+            (cursorAdvanceMethods = [
+                IDBCursor.prototype.advance,
+                IDBCursor.prototype.continue,
+                IDBCursor.prototype.continuePrimaryKey,
+            ]));
+    }
+    const cursorRequestMap = new WeakMap();
+    const transactionDoneMap = new WeakMap();
+    const transactionStoreNamesMap = new WeakMap();
+    const transformCache = new WeakMap();
+    const reverseTransformCache = new WeakMap();
+    function promisifyRequest(request) {
+        const promise = new Promise((resolve, reject) => {
+            const unlisten = () => {
+                request.removeEventListener('success', success);
+                request.removeEventListener('error', error);
+            };
+            const success = () => {
+                resolve(wrap(request.result));
+                unlisten();
+            };
+            const error = () => {
+                reject(request.error);
+                unlisten();
+            };
+            request.addEventListener('success', success);
+            request.addEventListener('error', error);
+        });
+        promise
+            .then((value) => {
+            // Since cursoring reuses the IDBRequest (*sigh*), we cache it for later retrieval
+            // (see wrapFunction).
+            if (value instanceof IDBCursor) {
+                cursorRequestMap.set(value, request);
+            }
+            // Catching to avoid "Uncaught Promise exceptions"
+        })
+            .catch(() => { });
+        // This mapping exists in reverseTransformCache but doesn't doesn't exist in transformCache. This
+        // is because we create many promises from a single IDBRequest.
+        reverseTransformCache.set(promise, request);
+        return promise;
+    }
+    function cacheDonePromiseForTransaction(tx) {
+        // Early bail if we've already created a done promise for this transaction.
+        if (transactionDoneMap.has(tx))
+            return;
+        const done = new Promise((resolve, reject) => {
+            const unlisten = () => {
+                tx.removeEventListener('complete', complete);
+                tx.removeEventListener('error', error);
+                tx.removeEventListener('abort', error);
+            };
+            const complete = () => {
+                resolve();
+                unlisten();
+            };
+            const error = () => {
+                reject(tx.error || new DOMException('AbortError', 'AbortError'));
+                unlisten();
+            };
+            tx.addEventListener('complete', complete);
+            tx.addEventListener('error', error);
+            tx.addEventListener('abort', error);
+        });
+        // Cache it for later retrieval.
+        transactionDoneMap.set(tx, done);
+    }
+    let idbProxyTraps = {
+        get(target, prop, receiver) {
+            if (target instanceof IDBTransaction) {
+                // Special handling for transaction.done.
+                if (prop === 'done')
+                    return transactionDoneMap.get(target);
+                // Polyfill for objectStoreNames because of Edge.
+                if (prop === 'objectStoreNames') {
+                    return target.objectStoreNames || transactionStoreNamesMap.get(target);
+                }
+                // Make tx.store return the only store in the transaction, or undefined if there are many.
+                if (prop === 'store') {
+                    return receiver.objectStoreNames[1]
+                        ? undefined
+                        : receiver.objectStore(receiver.objectStoreNames[0]);
+                }
+            }
+            // Else transform whatever we get back.
+            return wrap(target[prop]);
+        },
+        set(target, prop, value) {
+            target[prop] = value;
+            return true;
+        },
+        has(target, prop) {
+            if (target instanceof IDBTransaction &&
+                (prop === 'done' || prop === 'store')) {
+                return true;
+            }
+            return prop in target;
+        },
+    };
+    function replaceTraps(callback) {
+        idbProxyTraps = callback(idbProxyTraps);
+    }
+    function wrapFunction(func) {
+        // Due to expected object equality (which is enforced by the caching in `wrap`), we
+        // only create one new func per func.
+        // Edge doesn't support objectStoreNames (booo), so we polyfill it here.
+        if (func === IDBDatabase.prototype.transaction &&
+            !('objectStoreNames' in IDBTransaction.prototype)) {
+            return function (storeNames, ...args) {
+                const tx = func.call(unwrap(this), storeNames, ...args);
+                transactionStoreNamesMap.set(tx, storeNames.sort ? storeNames.sort() : [storeNames]);
+                return wrap(tx);
+            };
+        }
+        // Cursor methods are special, as the behaviour is a little more different to standard IDB. In
+        // IDB, you advance the cursor and wait for a new 'success' on the IDBRequest that gave you the
+        // cursor. It's kinda like a promise that can resolve with many values. That doesn't make sense
+        // with real promises, so each advance methods returns a new promise for the cursor object, or
+        // undefined if the end of the cursor has been reached.
+        if (getCursorAdvanceMethods().includes(func)) {
+            return function (...args) {
+                // Calling the original function with the proxy as 'this' causes ILLEGAL INVOCATION, so we use
+                // the original object.
+                func.apply(unwrap(this), args);
+                return wrap(cursorRequestMap.get(this));
+            };
+        }
+        return function (...args) {
+            // Calling the original function with the proxy as 'this' causes ILLEGAL INVOCATION, so we use
+            // the original object.
+            return wrap(func.apply(unwrap(this), args));
+        };
+    }
+    function transformCachableValue(value) {
+        if (typeof value === 'function')
+            return wrapFunction(value);
+        // This doesn't return, it just creates a 'done' promise for the transaction,
+        // which is later returned for transaction.done (see idbObjectHandler).
+        if (value instanceof IDBTransaction)
+            cacheDonePromiseForTransaction(value);
+        if (instanceOfAny(value, getIdbProxyableTypes()))
+            return new Proxy(value, idbProxyTraps);
+        // Return the same value back if we're not going to transform it.
+        return value;
+    }
+    function wrap(value) {
+        // We sometimes generate multiple promises from a single IDBRequest (eg when cursoring), because
+        // IDB is weird and a single IDBRequest can yield many responses, so these can't be cached.
+        if (value instanceof IDBRequest)
+            return promisifyRequest(value);
+        // If we've already transformed this value before, reuse the transformed value.
+        // This is faster, but it also provides object equality.
+        if (transformCache.has(value))
+            return transformCache.get(value);
+        const newValue = transformCachableValue(value);
+        // Not all types are transformed.
+        // These may be primitive types, so they can't be WeakMap keys.
+        if (newValue !== value) {
+            transformCache.set(value, newValue);
+            reverseTransformCache.set(newValue, value);
+        }
+        return newValue;
+    }
+    const unwrap = (value) => reverseTransformCache.get(value);
+
+    /**
+     * Open a database.
+     *
+     * @param name Name of the database.
+     * @param version Schema version.
+     * @param callbacks Additional callbacks.
+     */
+    function openDB(name, version, { blocked, upgrade, blocking, terminated } = {}) {
+        const request = indexedDB.open(name, version);
+        const openPromise = wrap(request);
+        if (upgrade) {
+            request.addEventListener('upgradeneeded', (event) => {
+                upgrade(wrap(request.result), event.oldVersion, event.newVersion, wrap(request.transaction), event);
+            });
+        }
+        if (blocked) {
+            request.addEventListener('blocked', (event) => blocked(
+            // Casting due to https://github.com/microsoft/TypeScript-DOM-lib-generator/pull/1405
+            event.oldVersion, event.newVersion, event));
+        }
+        openPromise
+            .then((db) => {
+            if (terminated)
+                db.addEventListener('close', () => terminated());
+            if (blocking) {
+                db.addEventListener('versionchange', (event) => blocking(event.oldVersion, event.newVersion, event));
+            }
+        })
+            .catch(() => { });
+        return openPromise;
+    }
+
+    const readMethods = ['get', 'getKey', 'getAll', 'getAllKeys', 'count'];
+    const writeMethods = ['put', 'add', 'delete', 'clear'];
+    const cachedMethods = new Map();
+    function getMethod(target, prop) {
+        if (!(target instanceof IDBDatabase &&
+            !(prop in target) &&
+            typeof prop === 'string')) {
+            return;
+        }
+        if (cachedMethods.get(prop))
+            return cachedMethods.get(prop);
+        const targetFuncName = prop.replace(/FromIndex$/, '');
+        const useIndex = prop !== targetFuncName;
+        const isWrite = writeMethods.includes(targetFuncName);
+        if (
+        // Bail if the target doesn't exist on the target. Eg, getAll isn't in Edge.
+        !(targetFuncName in (useIndex ? IDBIndex : IDBObjectStore).prototype) ||
+            !(isWrite || readMethods.includes(targetFuncName))) {
+            return;
+        }
+        const method = async function (storeName, ...args) {
+            // isWrite ? 'readwrite' : undefined gzipps better, but fails in Edge :(
+            const tx = this.transaction(storeName, isWrite ? 'readwrite' : 'readonly');
+            let target = tx.store;
+            if (useIndex)
+                target = target.index(args.shift());
+            // Must reject if op rejects.
+            // If it's a write operation, must reject if tx.done rejects.
+            // Must reject with op rejection first.
+            // Must resolve with op value.
+            // Must handle both promises (no unhandled rejections)
+            return (await Promise.all([
+                target[targetFuncName](...args),
+                isWrite && tx.done,
+            ]))[0];
+        };
+        cachedMethods.set(prop, method);
+        return method;
+    }
+    replaceTraps((oldTraps) => ({
+        ...oldTraps,
+        get: (target, prop, receiver) => getMethod(target, prop) || oldTraps.get(target, prop, receiver),
+        has: (target, prop) => !!getMethod(target, prop) || oldTraps.has(target, prop),
+    }));
+
+    // src/CyberneticCache.ts
+    // IndexedDB cache for offline document storage
+    /**
+     * Document cache for offline RAG fallback
+     */
+    class CyberneticCache {
+        constructor(config) {
+            this.db = null;
+            this.dbPromise = null;
+            this.documentCount = 0;
+            this.lastSyncAt = null;
+            this.config = config;
+            if (config.storage === 'indexeddb' && typeof indexedDB !== 'undefined') {
+                this.dbPromise = this.initDB();
+            }
+            else if (config.storage === 'localstorage') {
+                // Load cached metadata from localStorage
+                this.loadLocalStorageMetadata();
+            }
+        }
+        /**
+         * Load metadata from localStorage
+         */
+        loadLocalStorageMetadata() {
+            try {
+                const meta = localStorage.getItem('cybernetic-cache-meta');
+                if (meta) {
+                    const parsed = JSON.parse(meta);
+                    this.documentCount = parsed.documentCount || 0;
+                    this.lastSyncAt = parsed.lastSyncAt || null;
+                }
+            }
+            catch {
+                // Ignore parse errors
+            }
+        }
+        /**
+         * Initialize IndexedDB
+         */
+        async initDB() {
+            this.db = await openDB('cybernetic-cache', 1, {
+                upgrade(db) {
+                    // Documents store
+                    if (!db.objectStoreNames.contains('documents')) {
+                        const docStore = db.createObjectStore('documents', { keyPath: 'id' });
+                        docStore.createIndex('by-updated', 'updatedAt');
+                    }
+                    // Metadata store
+                    if (!db.objectStoreNames.contains('metadata')) {
+                        db.createObjectStore('metadata', { keyPath: 'key' });
+                    }
+                }
+            });
+            // Load cached metadata
+            await this.loadMetadata();
+            return this.db;
+        }
+        /**
+         * Get database instance
+         */
+        async getDB() {
+            if (this.db)
+                return this.db;
+            if (this.dbPromise)
+                return this.dbPromise;
+            throw new Error('Database not available');
+        }
+        /**
+         * Load cached metadata (count, last sync)
+         */
+        async loadMetadata() {
+            if (!this.db)
+                return;
+            const countMeta = await this.db.get('metadata', 'documentCount');
+            this.documentCount = countMeta?.value || 0;
+            const syncMeta = await this.db.get('metadata', 'lastSyncAt');
+            this.lastSyncAt = syncMeta?.value || null;
+        }
+        /**
+         * Store documents in cache
+         */
+        async store(documents) {
+            if (this.config.storage === 'localstorage') {
+                return this.storeLocalStorage(documents);
+            }
+            const db = await this.getDB();
+            const tx = db.transaction(['documents', 'metadata'], 'readwrite');
+            // Store documents
+            for (const doc of documents) {
+                await tx.objectStore('documents').put(doc);
+            }
+            // Update metadata
+            this.documentCount = await tx.objectStore('documents').count();
+            this.lastSyncAt = new Date().toISOString();
+            await tx.objectStore('metadata').put({
+                key: 'documentCount',
+                value: this.documentCount
+            });
+            await tx.objectStore('metadata').put({
+                key: 'lastSyncAt',
+                value: this.lastSyncAt
+            });
+            await tx.done;
+        }
+        /**
+         * Retrieve all cached documents
+         */
+        async retrieve() {
+            if (this.config.storage === 'localstorage') {
+                return this.retrieveLocalStorage();
+            }
+            const db = await this.getDB();
+            return db.getAll('documents');
+        }
+        /**
+         * Get last sync timestamp
+         */
+        async getLastSync() {
+            return this.lastSyncAt;
+        }
+        /**
+         * Get cache status
+         */
+        getStatus() {
+            const now = Date.now();
+            const lastSync = this.lastSyncAt ? new Date(this.lastSyncAt).getTime() : 0;
+            const isStale = now - lastSync > this.config.maxAge;
+            return {
+                documentCount: this.documentCount,
+                lastSyncAt: this.lastSyncAt,
+                cacheSize: this.documentCount * 5000, // Rough estimate: ~5KB per doc
+                isStale
+            };
+        }
+        /**
+         * Clear all cached data
+         */
+        async clear() {
+            if (this.config.storage === 'localstorage') {
+                localStorage.removeItem('cybernetic-cache-docs');
+                localStorage.removeItem('cybernetic-cache-meta');
+                this.documentCount = 0;
+                this.lastSyncAt = null;
+                return;
+            }
+            const db = await this.getDB();
+            const tx = db.transaction(['documents', 'metadata'], 'readwrite');
+            await tx.objectStore('documents').clear();
+            await tx.objectStore('metadata').clear();
+            await tx.done;
+            this.documentCount = 0;
+            this.lastSyncAt = null;
+        }
+        // ==================== LocalStorage fallback ====================
+        storeLocalStorage(documents) {
+            try {
+                localStorage.setItem('cybernetic-cache-docs', JSON.stringify(documents));
+                this.documentCount = documents.length;
+                this.lastSyncAt = new Date().toISOString();
+                localStorage.setItem('cybernetic-cache-meta', JSON.stringify({
+                    documentCount: this.documentCount,
+                    lastSyncAt: this.lastSyncAt
+                }));
+            }
+            catch {
+                // LocalStorage full - clear and retry with limit
+                localStorage.removeItem('cybernetic-cache-docs');
+                const limited = documents.slice(0, 50); // Keep only 50 docs
+                localStorage.setItem('cybernetic-cache-docs', JSON.stringify(limited));
+                this.documentCount = limited.length;
+            }
+        }
+        retrieveLocalStorage() {
+            try {
+                const data = localStorage.getItem('cybernetic-cache-docs');
+                return data ? JSON.parse(data) : [];
+            }
+            catch {
+                return [];
+            }
+        }
+    }
+
+    // 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;
+        }
+        /**
+         * Check if documents are indexed
+         */
+        isIndexed() {
+            return this.indexed && this.documents.length > 0;
+        }
+        /**
+         * Index documents for local search
+         */
+        async index(documents) {
+            this.documents = [];
+            this.idf = new Map();
+            // Tokenize and build document frequency
+            const docFreq = new Map();
+            for (const doc of documents) {
+                const tokens = this.tokenize(doc.content);
+                const uniqueTokens = new Set(tokens);
+                // Count document frequency
+                for (const token of uniqueTokens) {
+                    docFreq.set(token, (docFreq.get(token) || 0) + 1);
+                }
+                // Store indexed document
+                this.documents.push({
+                    id: doc.id,
+                    title: doc.title,
+                    content: doc.content,
+                    tokens,
+                    tfidf: new Map() // Computed after IDF is known
+                });
+            }
+            // Compute IDF
+            const N = documents.length;
+            for (const [term, df] of docFreq) {
+                this.idf.set(term, Math.log((N + 1) / (df + 1)) + 1);
+            }
+            // Compute TF-IDF for each document
+            for (const doc of this.documents) {
+                const termFreq = this.computeTermFrequency(doc.tokens);
+                for (const [term, tf] of termFreq) {
+                    const idf = this.idf.get(term) || 1;
+                    doc.tfidf.set(term, tf * idf);
+                }
+            }
+            this.indexed = true;
+        }
+        /**
+         * Process query and generate response
+         */
+        async ask(query) {
+            if (!this.indexed || this.documents.length === 0) {
+                return {
+                    answer: 'I don\'t have any information available offline.',
+                    sources: [],
+                    topScore: 0
+                };
+            }
+            // Tokenize query and compute TF-IDF
+            const queryTokens = this.tokenize(query);
+            const queryTf = this.computeTermFrequency(queryTokens);
+            const queryTfidf = new Map();
+            for (const [term, tf] of queryTf) {
+                const idf = this.idf.get(term) || 1;
+                queryTfidf.set(term, tf * idf);
+            }
+            // Compute similarity scores
+            const scores = this.documents.map(doc => ({
+                doc,
+                score: this.cosineSimilarity(queryTfidf, doc.tfidf)
+            }));
+            // Sort by score descending
+            scores.sort((a, b) => b.score - a.score);
+            // Take top 3 results
+            const topResults = scores.slice(0, 3).filter(r => r.score > 0.1);
+            if (topResults.length === 0) {
+                return {
+                    answer: 'I couldn\'t find relevant information for your question in my offline data.',
+                    sources: [],
+                    topScore: scores[0]?.score || 0
+                };
+            }
+            // Generate simple answer from top result
+            const topDoc = topResults[0].doc;
+            const snippet = this.extractRelevantSnippet(topDoc.content, queryTokens);
+            return {
+                answer: snippet,
+                sources: topResults.map(r => ({
+                    title: r.doc.title,
+                    snippet: r.doc.content.substring(0, 200) + '...',
+                    score: r.score
+                })),
+                topScore: topResults[0].score
+            };
+        }
+        /**
+         * Reset the index
+         */
+        reset() {
+            this.documents = [];
+            this.idf = new Map();
+            this.indexed = false;
+        }
+        // ==================== PRIVATE METHODS ====================
+        /**
+         * Tokenize text into words
+         */
+        tokenize(text) {
+            return text
+                .toLowerCase()
+                .replace(/[^\w\s]/g, ' ')
+                .split(/\s+/)
+                .filter(token => token.length > 2 && !this.isStopWord(token));
+        }
+        /**
+         * Compute term frequency
+         */
+        computeTermFrequency(tokens) {
+            const freq = new Map();
+            for (const token of tokens) {
+                freq.set(token, (freq.get(token) || 0) + 1);
+            }
+            // Normalize by document length
+            const maxFreq = Math.max(...freq.values());
+            if (maxFreq > 0) {
+                for (const [term, f] of freq) {
+                    freq.set(term, f / maxFreq);
+                }
+            }
+            return freq;
+        }
+        /**
+         * Compute cosine similarity between two TF-IDF vectors
+         */
+        cosineSimilarity(vec1, vec2) {
+            let dotProduct = 0;
+            let norm1 = 0;
+            let norm2 = 0;
+            for (const [term, val1] of vec1) {
+                const val2 = vec2.get(term) || 0;
+                dotProduct += val1 * val2;
+                norm1 += val1 * val1;
+            }
+            for (const val of vec2.values()) {
+                norm2 += val * val;
+            }
+            if (norm1 === 0 || norm2 === 0)
+                return 0;
+            return dotProduct / (Math.sqrt(norm1) * Math.sqrt(norm2));
+        }
+        /**
+         * Extract most relevant snippet from content
+         */
+        extractRelevantSnippet(content, queryTokens) {
+            const sentences = content.split(/[.!?]+/).filter(s => s.trim().length > 0);
+            // Score sentences by query token overlap
+            const scored = sentences.map(sentence => {
+                const sentenceTokens = new Set(this.tokenize(sentence));
+                let score = 0;
+                for (const qt of queryTokens) {
+                    if (sentenceTokens.has(qt))
+                        score++;
+                }
+                return { sentence: sentence.trim(), score };
+            });
+            scored.sort((a, b) => b.score - a.score);
+            // Take top 2-3 sentences
+            const topSentences = scored.slice(0, 3).filter(s => s.score > 0);
+            if (topSentences.length === 0) {
+                return content.substring(0, 300) + '...';
+            }
+            return topSentences.map(s => s.sentence).join('. ') + '.';
+        }
+        /**
+         * 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'
+            ]);
+            return stopWords.has(word);
+        }
+    }
+
+    // src/license/base64url.ts
+    // Base64URL encoding/decoding utilities for JWT handling
+    /**
+     * Decode a base64url string to Uint8Array
+     * RFC 4648 §5 - Base64 URL-safe encoding
+     */
+    function base64urlDecode(input) {
+        // Convert base64url to standard base64
+        let base64 = input
+            .replace(/-/g, '+')
+            .replace(/_/g, '/');
+        // Add padding if needed
+        const padding = base64.length % 4;
+        if (padding) {
+            base64 += '='.repeat(4 - padding);
+        }
+        // Decode base64
+        const binaryString = atob(base64);
+        const bytes = new Uint8Array(binaryString.length);
+        for (let i = 0; i < binaryString.length; i++) {
+            bytes[i] = binaryString.charCodeAt(i);
+        }
+        return bytes;
+    }
+    /**
+     * Decode base64url to UTF-8 string
+     */
+    function base64urlDecodeString(input) {
+        const bytes = base64urlDecode(input);
+        return new TextDecoder().decode(bytes);
+    }
+    /**
+     * Parse a JWT token into its parts (header, payload, signature)
+     * Does NOT verify the signature
+     */
+    function parseJWT(token) {
+        try {
+            const parts = token.split('.');
+            if (parts.length !== 3) {
+                return null;
+            }
+            const [headerB64, payloadB64, signatureB64] = parts;
+            return {
+                header: JSON.parse(base64urlDecodeString(headerB64)),
+                payload: JSON.parse(base64urlDecodeString(payloadB64)),
+                signature: base64urlDecode(signatureB64),
+                signedContent: `${headerB64}.${payloadB64}`
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+
+    // src/license/verifier.ts
+    // JWT verification for license tokens
+    /**
+     * AsterMind public key for license verification (ES256 - ECDSA P-256)
+     * This key is embedded for verification of official AsterMind licenses
+     */
+    const ASTERMIND_PUBLIC_KEY = `-----BEGIN PUBLIC KEY-----
+MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEhLW7MXHQ0Fuk1OKt9D5CbRw7fUMN
+LJ5AZXvOhHaXdHzMuYKX5BpK4w7TqbPvJ6QPvKmLKvHh1VKcUJ6mJQgJJw==
+-----END PUBLIC KEY-----`;
+    /**
+     * Import a PEM-encoded public key for WebCrypto
+     */
+    async function importPublicKey(pemKey) {
+        // Remove PEM headers and whitespace
+        const pemContents = pemKey
+            .replace(/-----BEGIN PUBLIC KEY-----/, '')
+            .replace(/-----END PUBLIC KEY-----/, '')
+            .replace(/\s/g, '');
+        // Decode base64 to ArrayBuffer
+        const binaryString = atob(pemContents);
+        const bytes = new Uint8Array(binaryString.length);
+        for (let i = 0; i < binaryString.length; i++) {
+            bytes[i] = binaryString.charCodeAt(i);
+        }
+        // Import as ECDSA P-256 key
+        return crypto.subtle.importKey('spki', bytes.buffer, {
+            name: 'ECDSA',
+            namedCurve: 'P-256'
+        }, false, ['verify']);
+    }
+    /**
+     * Convert JWT signature from compact format to DER format for WebCrypto
+     * JWT uses raw R||S format (64 bytes for P-256)
+     * WebCrypto expects raw format for ECDSA, not DER
+     */
+    function convertJWTSignature(signature) {
+        // For P-256, the signature should be 64 bytes (32 for R, 32 for S)
+        // JWT compact serialization already uses this format
+        return signature;
+    }
+    /**
+     * Verify a JWT signature using WebCrypto
+     */
+    async function verifySignature(signedContent, signature, publicKey) {
+        try {
+            const key = await importPublicKey(publicKey);
+            const encoder = new TextEncoder();
+            const data = encoder.encode(signedContent);
+            const sig = convertJWTSignature(signature);
+            // Create a new ArrayBuffer from the signature bytes to satisfy TypeScript
+            const sigBuffer = new Uint8Array(sig).buffer;
+            return await crypto.subtle.verify({
+                name: 'ECDSA',
+                hash: 'SHA-256'
+            }, key, sigBuffer, data);
+        }
+        catch (error) {
+            console.warn('[License] Signature verification failed:', error);
+            return false;
+        }
+    }
+    /**
+     * Validate license payload structure
+     */
+    function validatePayload(payload) {
+        // Required fields
+        if (typeof payload.iss !== 'string')
+            return null;
+        if (typeof payload.sub !== 'string')
+            return null;
+        if (typeof payload.aud !== 'string')
+            return null;
+        if (typeof payload.iat !== 'number')
+            return null;
+        if (typeof payload.exp !== 'number')
+            return null;
+        if (typeof payload.plan !== 'string')
+            return null;
+        if (typeof payload.seats !== 'number')
+            return null;
+        if (!Array.isArray(payload.features))
+            return null;
+        if (typeof payload.licenseVersion !== 'number')
+            return null;
+        return {
+            iss: payload.iss,
+            sub: payload.sub,
+            aud: payload.aud,
+            iat: payload.iat,
+            exp: payload.exp,
+            plan: payload.plan,
+            org: typeof payload.org === 'string' ? payload.org : undefined,
+            seats: payload.seats,
+            features: payload.features,
+            graceUntil: typeof payload.graceUntil === 'number' ? payload.graceUntil : undefined,
+            licenseVersion: payload.licenseVersion
+        };
+    }
+    /**
+     * Calculate days remaining until expiration
+     */
+    function calculateDaysRemaining(expTimestamp) {
+        const now = Math.floor(Date.now() / 1000);
+        const secondsRemaining = expTimestamp - now;
+        return Math.floor(secondsRemaining / 86400); // 86400 = seconds in a day
+    }
+    /**
+     * Verify a license token
+     *
+     * @param token - JWT license token
+     * @param publicKey - Optional custom public key (defaults to AsterMind key)
+     * @returns License state after verification
+     */
+    async function verifyLicenseToken(token, publicKey) {
+        // No token provided
+        if (!token || token.trim() === '') {
+            return {
+                status: 'missing',
+                payload: null,
+                error: 'No license key provided',
+                inGracePeriod: false,
+                daysRemaining: null
+            };
+        }
+        // Parse JWT
+        const parsed = parseJWT(token);
+        if (!parsed) {
+            return {
+                status: 'invalid',
+                payload: null,
+                error: 'Invalid license key format',
+                inGracePeriod: false,
+                daysRemaining: null
+            };
+        }
+        // Validate payload structure
+        const payload = validatePayload(parsed.payload);
+        if (!payload) {
+            return {
+                status: 'invalid',
+                payload: null,
+                error: 'Invalid license payload structure',
+                inGracePeriod: false,
+                daysRemaining: null
+            };
+        }
+        // Verify issuer
+        if (payload.iss !== 'astermind') {
+            return {
+                status: 'invalid',
+                payload: null,
+                error: 'Invalid license issuer',
+                inGracePeriod: false,
+                daysRemaining: null
+            };
+        }
+        // Verify audience (should be cybernetic-chatbot or wildcard)
+        if (payload.aud !== 'cybernetic-chatbot' && payload.aud !== '*') {
+            return {
+                status: 'invalid',
+                payload: null,
+                error: 'License not valid for this product',
+                inGracePeriod: false,
+                daysRemaining: null
+            };
+        }
+        // Verify signature (if WebCrypto is available)
+        if (typeof crypto !== 'undefined' && crypto.subtle) {
+            const keyToUse = publicKey || ASTERMIND_PUBLIC_KEY;
+            const signatureValid = await verifySignature(parsed.signedContent, parsed.signature, keyToUse);
+            if (!signatureValid) {
+                return {
+                    status: 'invalid',
+                    payload: null,
+                    error: 'License signature verification failed',
+                    inGracePeriod: false,
+                    daysRemaining: null
+                };
+            }
+        }
+        // Check expiration
+        const now = Math.floor(Date.now() / 1000);
+        const daysRemaining = calculateDaysRemaining(payload.exp);
+        if (payload.exp < now) {
+            // Check for grace period
+            if (payload.graceUntil && payload.graceUntil > now) {
+                return {
+                    status: 'valid',
+                    payload,
+                    inGracePeriod: true,
+                    daysRemaining
+                };
+            }
+            return {
+                status: 'expired',
+                payload,
+                error: 'License has expired',
+                inGracePeriod: false,
+                daysRemaining
+            };
+        }
+        // Check for evaluation license
+        if (payload.plan === 'eval') {
+            return {
+                status: 'eval',
+                payload,
+                inGracePeriod: false,
+                daysRemaining
+            };
+        }
+        // License is valid
+        return {
+            status: 'valid',
+            payload,
+            inGracePeriod: false,
+            daysRemaining
+        };
+    }
+    /**
+     * Quick check if a token looks like a valid JWT (does not verify)
+     */
+    function isValidJWTFormat(token) {
+        return parseJWT(token) !== null;
+    }
+    /**
+     * Extract expiration date from a token without verification
+     * Useful for quick checks
+     */
+    function getTokenExpiration(token) {
+        const parsed = parseJWT(token);
+        if (!parsed || typeof parsed.payload.exp !== 'number') {
+            return null;
+        }
+        return new Date(parsed.payload.exp * 1000);
+    }
+
+    // src/license/licenseManager.ts
+    // License management with environment-aware enforcement
+    /**
+     * Required features for different capabilities
+     */
+    const REQUIRED_FEATURES = {
+        /** Feature required for basic client functionality */
+        CLIENT: 'cybernetic-chatbot-client',
+        /** Feature required for agentic capabilities (DOM automation, intent classification) */
+        AGENTIC: 'agentic'
+    };
+    /**
+     * License enforcement message shown in production when license is invalid
+     */
+    const LICENSE_WARNING_MESSAGE = '\n\n---\n⚠️ License Notice: Your AsterMind license key needs to be updated. ' +
+        'Please contact support@astermind.ai or visit https://astermind.ai/license to renew your license.';
+    /**
+     * Detect current environment based on URL and other signals
+     */
+    function detectEnvironment() {
+        // Node.js environment
+        if (typeof window === 'undefined') {
+            return process?.env?.NODE_ENV === 'production' ? 'production' : 'development';
+        }
+        const hostname = window.location?.hostname || '';
+        // Development indicators
+        const devPatterns = [
+            'localhost',
+            '127.0.0.1',
+            '0.0.0.0',
+            '.local',
+            '.dev',
+            '.test',
+            ':3000', // Common dev ports
+            ':5173', // Vite
+            ':8080', // Common dev port
+            ':4200', // Angular
+        ];
+        // Check for development patterns
+        for (const pattern of devPatterns) {
+            if (hostname.includes(pattern) || window.location?.port === pattern.replace(':', '')) {
+                return 'development';
+            }
+        }
+        // Check for file:// protocol (local development)
+        if (window.location?.protocol === 'file:') {
+            return 'development';
+        }
+        // Check for staging/preview patterns
+        const stagingPatterns = [
+            'staging.',
+            'preview.',
+            '-preview.',
+            '.vercel.app',
+            '.netlify.app',
+            '.pages.dev',
+        ];
+        for (const pattern of stagingPatterns) {
+            if (hostname.includes(pattern)) {
+                // Treat staging as production for license enforcement
+                return 'production';
+            }
+        }
+        // Default to production for safety
+        return 'production';
+    }
+    /**
+     * Determine enforcement mode based on environment
+     */
+    function getEnforcementMode(environment) {
+        return environment === 'development' ? 'soft' : 'hard';
+    }
+    /**
+     * License Manager
+     *
+     * Manages license verification and enforcement for CyberneticClient.
+     * - In development: Logs warnings to console (soft enforcement)
+     * - In production: Appends warning to chatbot responses (hard enforcement)
+     */
+    class LicenseManager {
+        constructor(config = {}) {
+            this.state = null;
+            this.verificationPromise = null;
+            this.hasLoggedWarning = false;
+            this.loggedMissingFeatures = new Set();
+            this.config = config;
+            this.environment = config.environment || detectEnvironment();
+            this.enforcementMode = getEnforcementMode(this.environment);
+        }
+        /**
+         * Verify the license (async, caches result)
+         */
+        async verify() {
+            // Return cached state if available
+            if (this.state) {
+                return this.state;
+            }
+            // Prevent concurrent verification calls
+            if (this.verificationPromise) {
+                return this.verificationPromise;
+            }
+            this.verificationPromise = verifyLicenseToken(this.config.licenseKey, this.config.publicKey);
+            try {
+                this.state = await this.verificationPromise;
+                // Notify status change
+                this.config.onStatusChange?.(this.state);
+                // Log based on enforcement mode
+                this.logLicenseStatus();
+                return this.state;
+            }
+            finally {
+                this.verificationPromise = null;
+            }
+        }
+        /**
+         * Get current license state (null if not yet verified)
+         */
+        getState() {
+            return this.state;
+        }
+        /**
+         * Check if license is valid or acceptable
+         * Valid statuses: 'valid', 'eval'
+         */
+        isValid() {
+            if (!this.state)
+                return false;
+            return this.state.status === 'valid' || this.state.status === 'eval';
+        }
+        /**
+         * Check if license requires action (expired, missing, invalid)
+         */
+        requiresAction() {
+            if (!this.state)
+                return true;
+            return this.state.status === 'expired' ||
+                this.state.status === 'missing' ||
+                this.state.status === 'invalid';
+        }
+        /**
+         * Get current environment
+         */
+        getEnvironment() {
+            return this.environment;
+        }
+        /**
+         * Get current enforcement mode
+         */
+        getEnforcementMode() {
+            return this.enforcementMode;
+        }
+        /**
+         * Process a response based on license status
+         * In production with invalid license: appends warning to response
+         * In development: logs warning (once) and returns response unchanged
+         *
+         * @param response - The chatbot response text
+         * @returns Modified response (or original if license valid)
+         */
+        processResponse(response) {
+            // License not verified yet - allow through
+            if (!this.state) {
+                return response;
+            }
+            // Valid license - no modification
+            if (this.isValid() && !this.state.inGracePeriod) {
+                return response;
+            }
+            // Handle based on enforcement mode
+            if (this.enforcementMode === 'soft') {
+                // Development: just log warning (once)
+                if (!this.hasLoggedWarning) {
+                    this.logDevelopmentWarning();
+                    this.hasLoggedWarning = true;
+                }
+                return response;
+            }
+            // Production: append warning to response
+            return response + LICENSE_WARNING_MESSAGE;
+        }
+        /**
+         * Get a human-readable license status message
+         */
+        getStatusMessage() {
+            if (!this.state) {
+                return 'License not verified';
+            }
+            switch (this.state.status) {
+                case 'valid':
+                    if (this.state.inGracePeriod) {
+                        return `License expired but in grace period (${Math.abs(this.state.daysRemaining || 0)} days overdue)`;
+                    }
+                    return `License valid (${this.state.daysRemaining} days remaining)`;
+                case 'eval':
+                    return `Evaluation license (${this.state.daysRemaining} days remaining)`;
+                case 'expired':
+                    return `License expired ${Math.abs(this.state.daysRemaining || 0)} days ago`;
+                case 'missing':
+                    return 'No license key provided';
+                case 'invalid':
+                    return `Invalid license: ${this.state.error}`;
+                default:
+                    return 'Unknown license status';
+            }
+        }
+        /**
+         * Force re-verification (clears cached state)
+         */
+        async reVerify() {
+            this.state = null;
+            this.hasLoggedWarning = false;
+            this.loggedMissingFeatures.clear();
+            return this.verify();
+        }
+        /**
+         * Check if a specific feature is licensed
+         *
+         * @param feature - Feature name to check
+         * @returns true if feature is present in license
+         */
+        hasFeature(feature) {
+            if (!this.state?.payload)
+                return false;
+            return this.state.payload.features.includes(feature);
+        }
+        /**
+         * Get all licensed features
+         */
+        getFeatures() {
+            return this.state?.payload?.features || [];
+        }
+        /**
+         * Check if client feature is licensed
+         * Logs warning if not present (only once)
+         *
+         * @returns true if cybernetic-chatbot-client feature is present
+         */
+        checkClientFeature() {
+            return this.checkFeatureWithLog(REQUIRED_FEATURES.CLIENT, 'CyberneticClient');
+        }
+        /**
+         * Check if agentic feature is licensed
+         * Logs warning if not present (only once)
+         * Call this when attempting to use agentic capabilities
+         *
+         * @returns true if agentic feature is present
+         */
+        checkAgenticFeature() {
+            return this.checkFeatureWithLog(REQUIRED_FEATURES.AGENTIC, 'Agentic capabilities');
+        }
+        /**
+         * Check a feature and log if missing (only logs once per feature)
+         */
+        checkFeatureWithLog(feature, displayName) {
+            // If license is missing/invalid, allow through (handled by other checks)
+            if (!this.state?.payload) {
+                return true;
+            }
+            const hasFeature = this.state.payload.features.includes(feature);
+            if (!hasFeature && !this.loggedMissingFeatures.has(feature)) {
+                this.loggedMissingFeatures.add(feature);
+                this.logMissingFeature(feature, displayName);
+            }
+            return hasFeature;
+        }
+        /**
+         * Log missing feature warning with available features
+         */
+        logMissingFeature(missingFeature, displayName) {
+            const availableFeatures = this.getFeatures();
+            const plan = this.state?.payload?.plan || 'unknown';
+            console.warn(`[Cybernetic License] ${displayName} requires the '${missingFeature}' feature, ` +
+                `which is not included in your license.`);
+            console.info(`[Cybernetic License] Current license plan: ${plan}`);
+            console.info(`[Cybernetic License] Licensed features: ${availableFeatures.length > 0
+            ? availableFeatures.join(', ')
+            : '(none)'}`);
+            console.info(`[Cybernetic License] To add this feature, upgrade your license at https://astermind.ai/license`);
+        }
+        /**
+         * Log license status based on enforcement mode
+         */
+        logLicenseStatus() {
+            if (!this.state)
+                return;
+            const prefix = '[Cybernetic License]';
+            switch (this.state.status) {
+                case 'valid':
+                    if (this.state.inGracePeriod) {
+                        console.warn(`${prefix} License expired but in grace period. ` +
+                            `Please renew at https://astermind.ai/license`);
+                    }
+                    else if (this.state.daysRemaining !== null && this.state.daysRemaining <= 30) {
+                        console.info(`${prefix} License expires in ${this.state.daysRemaining} days`);
+                    }
+                    break;
+                case 'eval':
+                    console.info(`${prefix} Evaluation license - ${this.state.daysRemaining} days remaining`);
+                    break;
+                case 'expired':
+                    console.error(`${prefix} License expired. ` +
+                        `Enforcement mode: ${this.enforcementMode}. ` +
+                        `Renew at https://astermind.ai/license`);
+                    break;
+                case 'missing':
+                    console.warn(`${prefix} No license key provided. ` +
+                        `Enforcement mode: ${this.enforcementMode}. ` +
+                        `Get a license at https://astermind.ai/license`);
+                    break;
+                case 'invalid':
+                    console.error(`${prefix} Invalid license: ${this.state.error}. ` +
+                        `Enforcement mode: ${this.enforcementMode}`);
+                    break;
+            }
+        }
+        /**
+         * Log development-only warning
+         */
+        logDevelopmentWarning() {
+            console.warn('[Cybernetic License] Running in development mode with ' +
+                `${this.state?.status || 'unknown'} license. ` +
+                'In production, a warning will be appended to chatbot responses. ' +
+                'Get a license at https://astermind.ai/license');
+        }
+    }
+    /**
+     * Create a pre-configured license manager and verify immediately
+     */
+    async function createLicenseManager(config) {
+        const manager = new LicenseManager(config);
+        await manager.verify();
+        return manager;
+    }
+
+    // src/CyberneticClient.ts
+    // Main client with API calls and offline fallback
+    /**
+     * Cybernetic Chatbot Client
+     *
+     * Provides API access to AsterMind backend with offline fallback.
+     * Always returns a response, never throws exceptions.
+     */
+    class CyberneticClient {
+        constructor(config) {
+            this.status = 'connecting';
+            this.lastError = null;
+            // Maintenance mode tracking (ADR-200)
+            this.systemSettings = null;
+            this.settingsLastChecked = 0;
+            this.SETTINGS_CHECK_INTERVAL = 300000; // 5 minutes
+            // Agentic capabilities (optional, registered separately via registerAgenticCapabilities)
+            this.agenticCapabilities = null;
+            // Apply defaults
+            this.config = {
+                apiUrl: config.apiUrl,
+                apiKey: config.apiKey,
+                fallback: {
+                    enabled: config.fallback?.enabled ?? true,
+                    cacheMaxAge: config.fallback?.cacheMaxAge ?? 86400000, // 24 hours
+                    cacheOnConnect: config.fallback?.cacheOnConnect ?? true,
+                    cacheStorage: config.fallback?.cacheStorage ?? 'indexeddb'
+                },
+                retry: {
+                    maxRetries: config.retry?.maxRetries ?? 2,
+                    initialDelay: config.retry?.initialDelay ?? 1000,
+                    exponentialBackoff: config.retry?.exponentialBackoff ?? true
+                },
+                agentic: config.agentic ?? null,
+                onStatusChange: config.onStatusChange || (() => { }),
+                onError: config.onError || (() => { })
+            };
+            // Initialize components
+            this.apiClient = new ApiClient(this.config.apiUrl, this.config.apiKey);
+            this.cache = new CyberneticCache({
+                storage: this.config.fallback.cacheStorage,
+                maxAge: this.config.fallback.cacheMaxAge
+            });
+            this.localRAG = new CyberneticLocalRAG();
+            // Initialize license manager
+            this.licenseManager = new LicenseManager({
+                licenseKey: config.licenseKey
+            });
+            // Verify license asynchronously (non-blocking)
+            this.licenseManager.verify().then(() => {
+                // Check client feature after verification
+                this.licenseManager.checkClientFeature();
+            }).catch(() => {
+                // License verification errors are handled internally
+            });
+            // Monitor connection status
+            this.monitorConnection();
+            // Pre-cache documents on init if enabled
+            if (this.config.fallback.enabled && this.config.fallback.cacheOnConnect) {
+                this.syncCache().catch(() => {
+                    // Silent failure on init - cache may be stale but usable
+                });
+            }
+        }
+        // ==================== AGENTIC CAPABILITIES ====================
+        /**
+         * Register agentic capabilities
+         * Called by registerAgenticCapabilities() helper from agentic module
+         *
+         * @example
+         * ```typescript
+         * import { CyberneticClient, registerAgenticCapabilities } from '@astermind/cybernetic-chatbot-client';
+         * const client = new CyberneticClient(config);
+         * registerAgenticCapabilities(client);
+         * ```
+         */
+        registerAgentic(capabilities) {
+            this.agenticCapabilities = capabilities;
+            console.log('[Cybernetic] Agentic capabilities registered');
+        }
+        /**
+         * Check if agentic capabilities are available and enabled
+         */
+        isAgenticEnabled() {
+            if (this.agenticCapabilities === null || this.config.agentic?.enabled !== true) {
+                return false;
+            }
+            // Check for agentic feature in license (logs warning if missing)
+            this.licenseManager.checkAgenticFeature();
+            return true;
+        }
+        /**
+         * Get registered agentic capabilities (for advanced use)
+         */
+        getAgenticCapabilities() {
+            return this.agenticCapabilities;
+        }
+        /**
+         * Get agentic configuration
+         */
+        getAgenticConfig() {
+            return this.config.agentic;
+        }
+        /**
+         * Classify user message intent for agentic action
+         * Only works if agentic capabilities are registered and enabled
+         *
+         * @param message - User's message to classify
+         * @returns Intent classification or null if agentic not available
+         */
+        classifyIntent(message) {
+            if (!this.isAgenticEnabled() || !this.agenticCapabilities) {
+                return null;
+            }
+            // Create agent instance if needed for classification
+            const agentConfig = this.config.agentic;
+            const AgentClass = this.agenticCapabilities.agent;
+            const agent = new AgentClass(agentConfig);
+            return agent.interpretIntent(message);
+        }
+        /**
+         * Execute an agent action
+         * Only works if agentic capabilities are registered and enabled
+         *
+         * @param action - Action to execute
+         * @returns Action result or error
+         */
+        async executeAction(action) {
+            if (!this.isAgenticEnabled() || !this.agenticCapabilities) {
+                return {
+                    success: false,
+                    message: 'Agentic capabilities not enabled'
+                };
+            }
+            const agentConfig = this.config.agentic;
+            const AgentClass = this.agenticCapabilities.agent;
+            const agent = new AgentClass(agentConfig);
+            return agent.executeAction(action);
+        }
+        /**
+         * Smart ask - checks for action intent first, then falls back to RAG
+         * Combines agentic classification with standard RAG query
+         *
+         * @param message - User's message
+         * @param options - Optional request configuration
+         * @returns Object containing response, action, and/or action result
+         */
+        async smartAsk(message, options) {
+            // Check for actionable intent if agentic is enabled
+            const classification = this.classifyIntent(message);
+            if (classification && classification.action && !classification.shouldEscalate) {
+                // High confidence action detected
+                if (this.config.agentic?.requireConfirmation !== false) {
+                    // Return action for UI confirmation without executing
+                    return { action: classification.action };
+                }
+                // Auto-execute if confirmation not required
+                const result = await this.executeAction(classification.action);
+                return {
+                    action: classification.action,
+                    actionResult: result
+                };
+            }
+            // Low confidence or no action - proceed to RAG
+            const response = await this.ask(message, options);
+            return { response };
+        }
+        // ==================== CORE METHODS ====================
+        /**
+         * Send a message to the chatbot
+         * Always returns a response, never throws
+         *
+         * @param message - User's message
+         * @param options - Optional request configuration
+         */
+        async ask(message, options) {
+            // Validate input
+            if (!message || typeof message !== 'string') {
+                return this.createErrorResponse('Message is required', 'none');
+            }
+            // Check maintenance mode before API call (ADR-200)
+            const settings = await this.checkSystemStatus();
+            if (settings.maintenanceMode || settings.forceOfflineClients) {
+                console.log('[Cybernetic] Maintenance mode active, using cached data');
+                // Return maintenance response if no cached data
+                if (!this.isCacheValid()) {
+                    return {
+                        reply: settings.maintenanceMessage ||
+                            'The service is currently under maintenance. Please try again later.',
+                        confidence: 'none',
+                        sources: [],
+                        offline: true,
+                        degradedReason: 'Maintenance mode active, no valid cache available'
+                    };
+                }
+                // Use local fallback during maintenance
+                return await this.fallbackAsk(message);
+            }
+            // Try API first
+            try {
+                const response = await this.apiWithRetry(message, options);
+                this.setStatus('online');
+                // Process response through license manager (may add warning in production)
+                const processedReply = this.licenseManager.processResponse(response.reply);
+                return {
+                    reply: processedReply,
+                    confidence: 'high',
+                    sources: response.sources || [],
+                    offline: false,
+                    sessionId: response.sessionId
+                };
+            }
+            catch (error) {
+                const omegaError = this.normalizeError(error);
+                this.lastError = omegaError;
+                this.config.onError(omegaError);
+                // Rate limit - don't fallback, return error response
+                if (omegaError.code === 'RATE_LIMIT') {
+                    return {
+                        reply: 'I\'m receiving too many requests right now. Please try again in a moment.',
+                        confidence: 'none',
+                        sources: [],
+                        offline: false,
+                        retryAfter: omegaError.retryAfter
+                    };
+                }
+                // Try fallback if enabled and not explicitly skipped
+                if (this.config.fallback.enabled && !options?.skipFallback) {
+                    return await this.fallbackAsk(message);
+                }
+                // No fallback - return error response
+                return this.createErrorResponse('Unable to connect to the chatbot service. Please try again later.', 'none', omegaError.retryAfter);
+            }
+        }
+        /**
+         * Send a message with streaming response
+         *
+         * @param message - User's message
+         * @param callbacks - Streaming event callbacks
+         * @param options - Optional request configuration
+         */
+        async askStream(message, callbacks, options) {
+            if (!message || typeof message !== 'string') {
+                callbacks.onError?.({
+                    code: 'LOCAL_RAG_ERROR',
+                    message: 'Message is required'
+                });
+                return;
+            }
+            // Check maintenance mode before API call (ADR-200)
+            const settings = await this.checkSystemStatus();
+            if (settings.maintenanceMode || settings.forceOfflineClients) {
+                console.log('[Cybernetic] Maintenance mode active, falling back to offline');
+                const response = await this.fallbackAsk(message);
+                callbacks.onComplete?.(response);
+                return;
+            }
+            try {
+                await this.apiClient.chatStream(message, {
+                    sessionId: options?.sessionId,
+                    context: options?.context,
+                    onToken: callbacks.onToken,
+                    onSources: callbacks.onSources,
+                    onComplete: (data) => {
+                        this.setStatus('online');
+                        // Process response through license manager (may add warning in production)
+                        const processedReply = this.licenseManager.processResponse(data.fullText);
+                        callbacks.onComplete?.({
+                            reply: processedReply,
+                            confidence: 'high',
+                            sources: data.sources || [],
+                            offline: false,
+                            sessionId: data.sessionId
+                        });
+                    },
+                    onError: (error) => {
+                        const omegaError = this.normalizeError(error);
+                        this.config.onError(omegaError);
+                        callbacks.onError?.(omegaError);
+                    }
+                });
+            }
+            catch (error) {
+                const omegaError = this.normalizeError(error);
+                this.lastError = omegaError;
+                this.config.onError(omegaError);
+                // Fall back to non-streaming if enabled
+                if (this.config.fallback.enabled && !options?.skipFallback) {
+                    const response = await this.fallbackAsk(message);
+                    callbacks.onComplete?.(response);
+                }
+                else {
+                    callbacks.onError?.(omegaError);
+                }
+            }
+        }
+        /**
+         * Sync documents to local cache for offline use
+         */
+        async syncCache() {
+            try {
+                const lastSync = await this.cache.getLastSync();
+                const docs = await this.apiClient.getGeneralDocs(lastSync);
+                if (docs.length > 0) {
+                    await this.cache.store(docs);
+                    await this.localRAG.index(docs);
+                    console.log(`[Cybernetic] Cache synced: ${docs.length} documents`);
+                }
+                this.setStatus('online');
+            }
+            catch (error) {
+                console.warn('[Cybernetic] Cache sync failed:', error);
+                // Don't change status - we may still have cached data
+            }
+        }
+        /**
+         * Get current connection status including system settings
+         */
+        getStatus() {
+            return {
+                connection: this.status,
+                cache: this.cache.getStatus(),
+                lastError: this.lastError,
+                systemSettings: this.systemSettings,
+                license: this.licenseManager.getState()
+            };
+        }
+        /**
+         * Get license manager for advanced license operations
+         */
+        getLicenseManager() {
+            return this.licenseManager;
+        }
+        /**
+         * Clear local cache
+         */
+        async clearCache() {
+            await this.cache.clear();
+            this.localRAG.reset();
+        }
+        /**
+         * Manually check if backend is reachable
+         */
+        async checkConnection() {
+            try {
+                await this.apiClient.getStatus();
+                this.setStatus('online');
+                return true;
+            }
+            catch {
+                this.setStatus('offline');
+                return false;
+            }
+        }
+        // ==================== MAINTENANCE MODE METHODS (ADR-200) ====================
+        /**
+         * Check system status including maintenance mode
+         * Called periodically and before API calls
+         */
+        async checkSystemStatus() {
+            // Use cached settings if recently checked
+            if (this.systemSettings &&
+                Date.now() - this.settingsLastChecked < this.SETTINGS_CHECK_INTERVAL) {
+                return this.systemSettings;
+            }
+            try {
+                const status = await this.apiClient.getStatus();
+                // Extract system settings from status response
+                this.systemSettings = {
+                    cacheRetentionHours: status.systemSettings?.cacheRetentionHours ?? 168,
+                    maintenanceMode: status.systemSettings?.maintenanceMode ?? false,
+                    maintenanceMessage: status.systemSettings?.maintenanceMessage,
+                    forceOfflineClients: status.systemSettings?.forceOfflineClients ?? false
+                };
+                this.settingsLastChecked = Date.now();
+                return this.systemSettings;
+            }
+            catch {
+                // On error, return cached settings or safe defaults
+                return this.systemSettings || {
+                    cacheRetentionHours: 168,
+                    maintenanceMode: false,
+                    forceOfflineClients: false
+                };
+            }
+        }
+        /**
+         * Check if maintenance mode is active
+         */
+        isMaintenanceMode() {
+            return this.systemSettings?.maintenanceMode ?? false;
+        }
+        /**
+         * Get maintenance message if in maintenance mode
+         */
+        getMaintenanceMessage() {
+            return this.systemSettings?.maintenanceMessage;
+        }
+        /**
+         * Validate cache using server-configured retention hours
+         */
+        isCacheValid() {
+            const cacheStatus = this.cache.getStatus();
+            if (!cacheStatus.lastSyncAt)
+                return false;
+            // Use server-configured retention or default 168 hours (7 days)
+            const retentionHours = this.systemSettings?.cacheRetentionHours || 168;
+            const retentionMs = retentionHours * 60 * 60 * 1000;
+            const lastSyncTime = new Date(cacheStatus.lastSyncAt).getTime();
+            return Date.now() - lastSyncTime < retentionMs;
+        }
+        // ==================== PRIVATE METHODS ====================
+        /**
+         * API call with retry logic
+         */
+        async apiWithRetry(message, options) {
+            const { maxRetries, initialDelay, exponentialBackoff } = this.config.retry;
+            let lastError = null;
+            for (let attempt = 0; attempt <= maxRetries; attempt++) {
+                try {
+                    return await this.apiClient.chat(message, {
+                        sessionId: options?.sessionId,
+                        context: options?.context
+                    });
+                }
+                catch (error) {
+                    lastError = error;
+                    // Don't retry on auth or rate limit errors
+                    const omegaError = this.normalizeError(error);
+                    if (omegaError.code === 'AUTH_ERROR' || omegaError.code === 'RATE_LIMIT') {
+                        throw error;
+                    }
+                    // Wait before retry
+                    if (attempt < maxRetries) {
+                        const delay = exponentialBackoff
+                            ? initialDelay * Math.pow(2, attempt)
+                            : initialDelay;
+                        await this.sleep(delay);
+                    }
+                }
+            }
+            throw lastError;
+        }
+        /**
+         * Fallback to local RAG processing
+         */
+        async fallbackAsk(message) {
+            this.setStatus('offline');
+            // Check if we have cached documents
+            const cacheStatus = this.cache.getStatus();
+            if (cacheStatus.documentCount === 0) {
+                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'
+                };
+            }
+            try {
+                // Get documents from cache
+                const docs = await this.cache.retrieve();
+                // Ensure local RAG is indexed
+                if (!this.localRAG.isIndexed()) {
+                    await this.localRAG.index(docs);
+                }
+                // Process with local RAG
+                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 (may add warning in production)
+                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: cacheStatus.isStale
+                        ? 'Using stale cached data'
+                        : 'Processed locally without server'
+                };
+            }
+            catch (error) {
+                console.error('[Cybernetic] Local RAG error:', error);
+                return {
+                    reply: 'I\'m having trouble processing your request offline. Please try again when you\'re back online.',
+                    confidence: 'none',
+                    sources: [],
+                    offline: true,
+                    degradedReason: 'Local RAG processing failed'
+                };
+            }
+        }
+        /**
+         * Monitor browser online/offline events
+         */
+        monitorConnection() {
+            if (typeof window !== 'undefined') {
+                window.addEventListener('online', () => {
+                    this.syncCache().catch(() => { });
+                });
+                window.addEventListener('offline', () => {
+                    this.setStatus('offline');
+                });
+                // Set initial status
+                if (!navigator.onLine) {
+                    this.setStatus('offline');
+                }
+            }
+        }
+        /**
+         * Update connection status and notify listeners
+         */
+        setStatus(status) {
+            if (this.status !== status) {
+                this.status = status;
+                this.config.onStatusChange(status);
+            }
+        }
+        /**
+         * Normalize various error types to CyberneticError
+         */
+        normalizeError(error) {
+            if (error instanceof Error) {
+                // Check for specific error types
+                if (error.message.includes('401') || error.message.includes('Unauthorized')) {
+                    return {
+                        code: 'AUTH_ERROR',
+                        message: 'Invalid or expired API key',
+                        originalError: error
+                    };
+                }
+                if (error.message.includes('429') || error.message.includes('Rate limit')) {
+                    const match = error.message.match(/retry after (\d+)/i);
+                    return {
+                        code: 'RATE_LIMIT',
+                        message: 'Rate limit exceeded',
+                        retryAfter: match ? parseInt(match[1], 10) : 60,
+                        originalError: error
+                    };
+                }
+                if (error.message.includes('5') || error.message.includes('Server')) {
+                    return {
+                        code: 'SERVER_ERROR',
+                        message: 'Server error occurred',
+                        originalError: error
+                    };
+                }
+                return {
+                    code: 'NETWORK_ERROR',
+                    message: error.message || 'Network error',
+                    originalError: error
+                };
+            }
+            return {
+                code: 'NETWORK_ERROR',
+                message: 'Unknown error occurred'
+            };
+        }
+        /**
+         * Create standardized error response
+         */
+        createErrorResponse(message, confidence, retryAfter) {
+            return {
+                reply: message,
+                confidence,
+                sources: [],
+                offline: false,
+                retryAfter
+            };
+        }
+        /**
+         * Async sleep utility
+         */
+        sleep(ms) {
+            return new Promise(resolve => setTimeout(resolve, ms));
+        }
+    }
+
+    // src/config.ts
+    // Configuration loading and validation
+    /**
+     * Validate configuration
+     */
+    function validateConfig(config) {
+        if (!config || typeof config !== 'object') {
+            throw new Error('Config must be an object');
+        }
+        const c = config;
+        if (!c.apiUrl || typeof c.apiUrl !== 'string') {
+            throw new Error('apiUrl is required and must be a string');
+        }
+        if (!c.apiKey || typeof c.apiKey !== 'string') {
+            throw new Error('apiKey is required and must be a string');
+        }
+        if (!c.apiKey.startsWith('am_')) {
+            throw new Error('apiKey must start with "am_"');
+        }
+        return true;
+    }
+    /**
+     * Load config from window.astermindConfig or script tag data attributes
+     */
+    function loadConfig() {
+        if (typeof window === 'undefined') {
+            return null;
+        }
+        // Check for global config object
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        if (window.astermindConfig) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const config = window.astermindConfig;
+            validateConfig(config);
+            return config;
+        }
+        // Check for script tag with data attributes
+        const script = document.querySelector('script[data-astermind-key]');
+        if (script) {
+            return {
+                apiUrl: script.getAttribute('data-astermind-url') || 'https://api.astermind.ai',
+                apiKey: script.getAttribute('data-astermind-key') || ''
+            };
+        }
+        return null;
+    }
+
+    // src/agentic/CyberneticIntentClassifier.ts
+    // Hybrid intent classification for agentic capabilities
+    /**
+     * Action intent patterns with weights
+     */
+    const ACTION_PATTERNS = {
+        navigate: [
+            { pattern: /^(go to|navigate to|take me to|open|show me|bring up)\s+(.+)/i, type: 'navigate', weight: 0.9 },
+            { pattern: /^(i want to see|i need to go to|let me see)\s+(.+)/i, type: 'navigate', weight: 0.85 },
+            { pattern: /^(where is|how do i get to)\s+(.+)/i, type: 'navigate', weight: 0.6 }, // Lower - might be question
+        ],
+        fillForm: [
+            { pattern: /^(search for|find|look up|search)\s+(.+)/i, type: 'fillForm', weight: 0.88 },
+            { pattern: /^(filter by|set .+ to|change .+ to)\s+(.+)/i, type: 'fillForm', weight: 0.85 },
+            { pattern: /^(enter|type|put)\s+(.+)\s+(in|into)\s+(.+)/i, type: 'fillForm', weight: 0.9 },
+        ],
+        clickElement: [
+            { pattern: /^(click|press|hit|tap)\s+(the\s+)?(.+)\s+(button|link)/i, type: 'clickElement', weight: 0.9 },
+            { pattern: /^(submit|send|confirm|save|cancel|delete)/i, type: 'clickElement', weight: 0.85 },
+        ],
+        triggerModal: [
+            { pattern: /^(open|show|display)\s+(the\s+)?(.+)\s+(modal|dialog|popup|window)/i, type: 'triggerModal', weight: 0.9 },
+            { pattern: /^(open|show)\s+(help|settings|preferences|options)/i, type: 'triggerModal', weight: 0.85 },
+        ],
+        scroll: [
+            { pattern: /^(scroll to|jump to|go to)\s+(the\s+)?(.+)\s+(section|area|part)/i, type: 'scroll', weight: 0.85 },
+            { pattern: /^(show me|take me to)\s+(the\s+)?(bottom|top|end|beginning)/i, type: 'scroll', weight: 0.8 },
+        ],
+        highlight: [
+            { pattern: /^(highlight|show me|point to|where is)\s+(the\s+)?(.+)/i, type: 'highlight', weight: 0.7 },
+        ],
+        custom: [
+            { pattern: /^(export|download|refresh|reload|sync)/i, type: 'custom', weight: 0.85 },
+        ]
+    };
+    /**
+     * Intent classifier for agentic actions
+     *
+     * Classifies user messages to determine if they should trigger
+     * a local DOM action or be sent to the backend RAG.
+     */
+    class CyberneticIntentClassifier {
+        constructor(config) {
+            this.config = config;
+            this.siteMapIndex = new Map();
+            this.formIndex = new Map();
+            this.modalIndex = new Map();
+            // Build indexes for fast lookup
+            this.buildIndexes();
+        }
+        /**
+         * Build search indexes from configuration
+         */
+        buildIndexes() {
+            // Site map index
+            if (this.config.siteMap) {
+                for (const entry of this.config.siteMap) {
+                    // Index by name and aliases
+                    const keys = [
+                        entry.name.toLowerCase(),
+                        entry.path.toLowerCase(),
+                        ...(entry.aliases || []).map(a => a.toLowerCase())
+                    ];
+                    for (const key of keys) {
+                        this.siteMapIndex.set(key, entry);
+                    }
+                }
+            }
+            // Form fields index
+            if (this.config.forms) {
+                for (const [key, field] of Object.entries(this.config.forms)) {
+                    const keys = [
+                        key.toLowerCase(),
+                        field.name.toLowerCase(),
+                        ...(field.aliases || []).map(a => a.toLowerCase())
+                    ];
+                    for (const k of keys) {
+                        this.formIndex.set(k, field);
+                    }
+                }
+            }
+            // Modal triggers index
+            if (this.config.modals) {
+                for (const [key, modal] of Object.entries(this.config.modals)) {
+                    const keys = [
+                        key.toLowerCase(),
+                        modal.id.toLowerCase(),
+                        ...(modal.aliases || []).map(a => a.toLowerCase())
+                    ];
+                    for (const k of keys) {
+                        this.modalIndex.set(k, modal);
+                    }
+                }
+            }
+        }
+        /**
+         * Classify user message intent
+         *
+         * @param message - User's message to classify
+         * @returns Classification result with action and confidence
+         */
+        classify(message) {
+            if (!this.config.enabled) {
+                return {
+                    action: null,
+                    shouldEscalate: true,
+                    rawConfidence: 0
+                };
+            }
+            const normalizedMessage = message.trim().toLowerCase();
+            // Try each action type
+            for (const [actionType, patterns] of Object.entries(ACTION_PATTERNS)) {
+                for (const { pattern, weight } of patterns) {
+                    const match = message.match(pattern);
+                    if (match) {
+                        const result = this.buildAction(actionType, match, weight);
+                        if (result) {
+                            return result;
+                        }
+                    }
+                }
+            }
+            // No pattern match - try fuzzy site map match
+            const siteMapResult = this.fuzzyMatchSiteMap(normalizedMessage);
+            if (siteMapResult) {
+                return siteMapResult;
+            }
+            // Check for custom action keywords
+            const customResult = this.matchCustomAction(normalizedMessage);
+            if (customResult) {
+                return customResult;
+            }
+            // No match - escalate to backend
+            return {
+                action: null,
+                shouldEscalate: true,
+                rawConfidence: 0,
+                matchedPatterns: []
+            };
+        }
+        /**
+         * Build action from pattern match
+         */
+        buildAction(actionType, match, baseWeight) {
+            const threshold = this.config.confidenceThreshold ?? 0.8;
+            switch (actionType) {
+                case 'navigate': {
+                    const target = this.extractTarget(match);
+                    const siteMatch = this.findSiteMapMatch(target);
+                    if (siteMatch) {
+                        const confidence = baseWeight * siteMatch.similarity;
+                        return {
+                            action: {
+                                id: `action-${Date.now()}`,
+                                type: 'navigate',
+                                target: siteMatch.entry.path,
+                                confidence,
+                                explanation: `Navigate to ${siteMatch.entry.name}`
+                            },
+                            shouldEscalate: confidence < threshold,
+                            rawConfidence: confidence,
+                            matchedPatterns: ['navigate', siteMatch.entry.name]
+                        };
+                    }
+                    break;
+                }
+                case 'fillForm': {
+                    const target = this.extractTarget(match);
+                    const { field, value } = this.parseFormIntent(match);
+                    if (field) {
+                        const confidence = baseWeight * 0.95;
+                        return {
+                            action: {
+                                id: `action-${Date.now()}`,
+                                type: 'fillForm',
+                                target: field.selector,
+                                params: { value },
+                                confidence,
+                                explanation: `Fill "${field.name}" with "${value}"`
+                            },
+                            shouldEscalate: confidence < threshold,
+                            rawConfidence: confidence,
+                            matchedPatterns: ['fillForm', field.name]
+                        };
+                    }
+                    // Default to search field
+                    if (this.config.forms?.search) {
+                        const confidence = baseWeight * 0.9;
+                        return {
+                            action: {
+                                id: `action-${Date.now()}`,
+                                type: 'fillForm',
+                                target: this.config.forms.search.selector,
+                                params: { value: target },
+                                confidence,
+                                explanation: `Search for "${target}"`
+                            },
+                            shouldEscalate: confidence < threshold,
+                            rawConfidence: confidence,
+                            matchedPatterns: ['fillForm', 'search']
+                        };
+                    }
+                    break;
+                }
+                case 'clickElement': {
+                    const buttonName = this.extractTarget(match);
+                    const selector = this.findButtonSelector(buttonName);
+                    if (selector) {
+                        const confidence = baseWeight * 0.95;
+                        return {
+                            action: {
+                                id: `action-${Date.now()}`,
+                                type: 'clickElement',
+                                target: selector,
+                                confidence,
+                                explanation: `Click "${buttonName}" button`
+                            },
+                            shouldEscalate: confidence < threshold,
+                            rawConfidence: confidence,
+                            matchedPatterns: ['clickElement', buttonName]
+                        };
+                    }
+                    break;
+                }
+                case 'triggerModal': {
+                    const modalName = this.extractTarget(match);
+                    const modal = this.findModalConfig(modalName);
+                    if (modal) {
+                        const confidence = baseWeight * 0.95;
+                        return {
+                            action: {
+                                id: `action-${Date.now()}`,
+                                type: 'triggerModal',
+                                target: modal.trigger,
+                                confidence,
+                                explanation: `Open ${modal.id} modal`
+                            },
+                            shouldEscalate: confidence < threshold,
+                            rawConfidence: confidence,
+                            matchedPatterns: ['triggerModal', modal.id]
+                        };
+                    }
+                    break;
+                }
+                case 'scroll': {
+                    const target = this.extractTarget(match);
+                    const selector = this.findScrollTarget(target);
+                    if (selector) {
+                        const confidence = baseWeight * 0.9;
+                        return {
+                            action: {
+                                id: `action-${Date.now()}`,
+                                type: 'scroll',
+                                target: selector,
+                                confidence,
+                                explanation: `Scroll to ${target}`
+                            },
+                            shouldEscalate: confidence < threshold,
+                            rawConfidence: confidence,
+                            matchedPatterns: ['scroll', target]
+                        };
+                    }
+                    break;
+                }
+                case 'highlight': {
+                    // Highlighting is typically lower confidence
+                    const target = this.extractTarget(match);
+                    const selector = this.findElementByDescription(target);
+                    if (selector) {
+                        const confidence = baseWeight * 0.85;
+                        return {
+                            action: {
+                                id: `action-${Date.now()}`,
+                                type: 'highlight',
+                                target: selector,
+                                confidence,
+                                explanation: `Highlight ${target}`
+                            },
+                            shouldEscalate: confidence < threshold,
+                            rawConfidence: confidence,
+                            matchedPatterns: ['highlight', target]
+                        };
+                    }
+                    break;
+                }
+                case 'custom': {
+                    const actionName = match[1]?.toLowerCase();
+                    if (this.config.customActions?.[actionName]) {
+                        const confidence = baseWeight * 0.95;
+                        return {
+                            action: {
+                                id: `action-${Date.now()}`,
+                                type: 'custom',
+                                target: actionName,
+                                confidence,
+                                explanation: `Execute ${actionName} action`
+                            },
+                            shouldEscalate: confidence < threshold,
+                            rawConfidence: confidence,
+                            matchedPatterns: ['custom', actionName]
+                        };
+                    }
+                    break;
+                }
+            }
+            return null;
+        }
+        /**
+         * Extract target from regex match
+         */
+        extractTarget(match) {
+            // Get the last non-empty capture group
+            for (let i = match.length - 1; i >= 1; i--) {
+                if (match[i]) {
+                    return match[i].trim();
+                }
+            }
+            return '';
+        }
+        /**
+         * Find site map match for target string
+         */
+        findSiteMapMatch(target) {
+            const normalizedTarget = target.toLowerCase().replace(/[^a-z0-9\s]/g, '');
+            // Exact match
+            const exact = this.siteMapIndex.get(normalizedTarget);
+            if (exact) {
+                return { entry: exact, similarity: 1.0 };
+            }
+            // Fuzzy match
+            let bestMatch = null;
+            let bestScore = 0;
+            for (const [key, entry] of this.siteMapIndex) {
+                const score = this.calculateSimilarity(normalizedTarget, key);
+                if (score > bestScore && score > 0.6) {
+                    bestScore = score;
+                    bestMatch = entry;
+                }
+            }
+            if (bestMatch) {
+                return { entry: bestMatch, similarity: bestScore };
+            }
+            return null;
+        }
+        /**
+         * Fuzzy match against site map for unstructured queries
+         */
+        fuzzyMatchSiteMap(message) {
+            const threshold = this.config.confidenceThreshold ?? 0.8;
+            // Look for page/site name mentions
+            for (const [key, entry] of this.siteMapIndex) {
+                if (message.includes(key)) {
+                    const confidence = 0.75; // Lower confidence for implicit matches
+                    return {
+                        action: {
+                            id: `action-${Date.now()}`,
+                            type: 'navigate',
+                            target: entry.path,
+                            confidence,
+                            explanation: `Navigate to ${entry.name}`
+                        },
+                        shouldEscalate: confidence < threshold,
+                        rawConfidence: confidence,
+                        matchedPatterns: ['fuzzy-sitemap', key]
+                    };
+                }
+            }
+            return null;
+        }
+        /**
+         * Match custom action keywords
+         */
+        matchCustomAction(message) {
+            if (!this.config.customActions)
+                return null;
+            const threshold = this.config.confidenceThreshold ?? 0.8;
+            for (const actionName of Object.keys(this.config.customActions)) {
+                if (message.includes(actionName.toLowerCase())) {
+                    const confidence = 0.85;
+                    return {
+                        action: {
+                            id: `action-${Date.now()}`,
+                            type: 'custom',
+                            target: actionName,
+                            confidence,
+                            explanation: `Execute ${actionName}`
+                        },
+                        shouldEscalate: confidence < threshold,
+                        rawConfidence: confidence,
+                        matchedPatterns: ['custom', actionName]
+                    };
+                }
+            }
+            return null;
+        }
+        /**
+         * Parse form fill intent
+         */
+        parseFormIntent(match) {
+            const fullText = match[0];
+            // Try to extract field name and value
+            for (const [, field] of this.formIndex) {
+                if (fullText.toLowerCase().includes(field.name.toLowerCase())) {
+                    // Extract value - everything after the field name
+                    const valueMatch = fullText.match(new RegExp(`${field.name}[^a-z]*(.+)`, 'i'));
+                    return {
+                        field,
+                        value: valueMatch?.[1]?.trim() || ''
+                    };
+                }
+            }
+            return { field: null, value: this.extractTarget(match) };
+        }
+        /**
+         * Find button selector by name
+         */
+        findButtonSelector(name) {
+            const normalizedName = name.toLowerCase();
+            // Check if we're in a browser environment
+            if (typeof document === 'undefined') {
+                // Return a generic selector for server-side contexts
+                return `button:contains("${name}")`;
+            }
+            // Common button selectors
+            const selectors = [
+                `[data-action="${normalizedName}"]`,
+                `[aria-label*="${normalizedName}" i]`,
+                `.btn-${normalizedName}`,
+                `#${normalizedName}-button`,
+                `button.${normalizedName}`
+            ];
+            // Check if any selector matches
+            for (const selector of selectors) {
+                try {
+                    if (document.querySelector(selector)) {
+                        return selector;
+                    }
+                }
+                catch {
+                    // Invalid selector, continue
+                }
+            }
+            // Fallback - try to find any button with matching text
+            const buttons = document.querySelectorAll('button, [role="button"], a.btn');
+            for (const btn of buttons) {
+                if (btn.textContent?.toLowerCase().includes(normalizedName)) {
+                    return this.generateUniqueSelector(btn);
+                }
+            }
+            return null;
+        }
+        /**
+         * Find modal config by name
+         */
+        findModalConfig(name) {
+            return this.modalIndex.get(name.toLowerCase()) || null;
+        }
+        /**
+         * Find scroll target selector
+         */
+        findScrollTarget(target) {
+            const normalizedTarget = target.toLowerCase();
+            // Special cases
+            if (normalizedTarget === 'top' || normalizedTarget === 'beginning') {
+                return 'body';
+            }
+            if (normalizedTarget === 'bottom' || normalizedTarget === 'end') {
+                return 'body:last-child';
+            }
+            // Check if we're in a browser environment
+            if (typeof document === 'undefined') {
+                return `#${normalizedTarget.replace(/\s+/g, '-')}`;
+            }
+            // Try to find section by id or class
+            const selectors = [
+                `#${normalizedTarget.replace(/\s+/g, '-')}`,
+                `[data-section="${normalizedTarget}"]`,
+                `.${normalizedTarget.replace(/\s+/g, '-')}-section`,
+                `section[aria-label*="${normalizedTarget}" i]`
+            ];
+            for (const selector of selectors) {
+                try {
+                    if (document.querySelector(selector)) {
+                        return selector;
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+            return null;
+        }
+        /**
+         * Find element by description
+         */
+        findElementByDescription(description) {
+            const normalizedDesc = description.toLowerCase();
+            // Check if we're in a browser environment
+            if (typeof document === 'undefined') {
+                return `[aria-label*="${normalizedDesc}" i]`;
+            }
+            // Try common patterns
+            const selectors = [
+                `[aria-label*="${normalizedDesc}" i]`,
+                `[data-testid*="${normalizedDesc}" i]`,
+                `[title*="${normalizedDesc}" i]`
+            ];
+            for (const selector of selectors) {
+                try {
+                    if (document.querySelector(selector)) {
+                        return selector;
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+            return null;
+        }
+        /**
+         * Generate unique selector for an element
+         */
+        generateUniqueSelector(element) {
+            // Try ID first
+            if (element.id) {
+                return `#${element.id}`;
+            }
+            // Try data attributes
+            if (element.getAttribute('data-testid')) {
+                return `[data-testid="${element.getAttribute('data-testid')}"]`;
+            }
+            // Build path selector
+            const path = [];
+            let current = element;
+            while (current && current !== document.body) {
+                let selector = current.tagName.toLowerCase();
+                if (current.className && typeof current.className === 'string') {
+                    const classes = current.className.split(' ').filter(c => c && !c.includes(' '));
+                    if (classes.length > 0) {
+                        selector += `.${classes.slice(0, 2).join('.')}`;
+                    }
+                }
+                path.unshift(selector);
+                current = current.parentElement;
+            }
+            return path.join(' > ');
+        }
+        /**
+         * Calculate string similarity (Jaccard index)
+         */
+        calculateSimilarity(a, b) {
+            const setA = new Set(a.split(/\s+/));
+            const setB = new Set(b.split(/\s+/));
+            const intersection = new Set([...setA].filter(x => setB.has(x)));
+            const union = new Set([...setA, ...setB]);
+            return intersection.size / union.size;
+        }
+        /**
+         * Get configuration
+         */
+        getConfig() {
+            return this.config;
+        }
+    }
+
+    // src/agentic/CyberneticAgent.ts
+    // DOM interaction agent for agentic actions
+    /**
+     * DOM interaction agent
+     *
+     * Executes actions on the host page based on classified intent.
+     * Supports navigation, form filling, clicking, scrolling, and more.
+     */
+    class CyberneticAgent {
+        constructor(config) {
+            this.highlightOverlay = null;
+            this.actionCount = 0;
+            this.lastActionReset = Date.now();
+            this.config = config;
+            this.classifier = new CyberneticIntentClassifier(config);
+            // Inject highlight styles (only in browser)
+            if (typeof document !== 'undefined') {
+                this.injectStyles();
+            }
+        }
+        /**
+         * Interpret user message and determine action
+         *
+         * @param message - User's message to interpret
+         * @returns Intent classification with suggested action
+         */
+        interpretIntent(message) {
+            return this.classifier.classify(message);
+        }
+        /**
+         * Execute an agent action
+         *
+         * @param action - The action to execute
+         * @returns Result of action execution
+         */
+        async executeAction(action) {
+            // Reset action count every minute
+            const now = Date.now();
+            if (now - this.lastActionReset > 60000) {
+                this.actionCount = 0;
+                this.lastActionReset = now;
+            }
+            // Check rate limit
+            const maxActions = this.config.maxActionsPerTurn ?? 5;
+            if (this.actionCount >= maxActions) {
+                return {
+                    success: false,
+                    message: `Rate limit exceeded. Maximum ${maxActions} actions per minute.`
+                };
+            }
+            // Validate action is allowed
+            if (!this.isActionAllowed(action)) {
+                return {
+                    success: false,
+                    message: `Action type "${action.type}" is not allowed`
+                };
+            }
+            this.actionCount++;
+            switch (action.type) {
+                case 'navigate':
+                    return this.navigate(action.target, action.params);
+                case 'fillForm':
+                    return this.fillForm(action.target, action.params?.value);
+                case 'clickElement':
+                    return this.clickElement(action.target);
+                case 'triggerModal':
+                    return this.triggerModal(action.target);
+                case 'scroll':
+                    return this.scrollToElement(action.target);
+                case 'highlight':
+                    return this.highlightElement(action.target);
+                case 'custom':
+                    return this.executeCustomAction(action.target, action.params);
+                default:
+                    return {
+                        success: false,
+                        message: `Unknown action type: ${action.type}`
+                    };
+            }
+        }
+        /**
+         * Check if an action type is allowed by configuration
+         */
+        isActionAllowed(action) {
+            const allowedActions = this.config.allowedActions;
+            if (!allowedActions)
+                return true; // All allowed by default
+            const actionTypeMap = {
+                'navigate': 'navigate',
+                'fillForm': 'fill',
+                'clickElement': 'click',
+                'scroll': 'scroll',
+                'highlight': 'click', // Highlight is a form of interaction
+                'triggerModal': 'click',
+                'custom': 'click'
+            };
+            const mappedType = actionTypeMap[action.type];
+            return allowedActions.includes(mappedType);
+        }
+        /**
+         * Check if selector is allowed (not blocked)
+         */
+        isSelectorAllowed(selector) {
+            // Check blocked selectors
+            if (this.config.blockedSelectors) {
+                for (const blocked of this.config.blockedSelectors) {
+                    if (selector.includes(blocked)) {
+                        return false;
+                    }
+                }
+            }
+            // Check allowed selectors (if specified, only those are allowed)
+            if (this.config.allowedSelectors && this.config.allowedSelectors.length > 0) {
+                return this.config.allowedSelectors.some(allowed => selector.includes(allowed));
+            }
+            return true;
+        }
+        // ==================== ACTION IMPLEMENTATIONS ====================
+        /**
+         * Navigate to a URL
+         */
+        async navigate(path, params) {
+            try {
+                // Validate URL
+                if (!this.validateNavigationUrl(path)) {
+                    return {
+                        success: false,
+                        message: 'Invalid or blocked URL'
+                    };
+                }
+                // Build URL with params
+                let url = path;
+                if (params) {
+                    const searchParams = new URLSearchParams();
+                    for (const [key, value] of Object.entries(params)) {
+                        if (value !== undefined && value !== null) {
+                            searchParams.set(key, String(value));
+                        }
+                    }
+                    const queryString = searchParams.toString();
+                    if (queryString) {
+                        url += (url.includes('?') ? '&' : '?') + queryString;
+                    }
+                }
+                // Check if we're in a browser environment
+                if (typeof window === 'undefined') {
+                    return {
+                        success: true,
+                        message: `Navigation to ${path} would be executed (server-side)`
+                    };
+                }
+                // Check if internal or external navigation
+                if (this.isInternalUrl(url)) {
+                    // Try client-side navigation first (SPA support)
+                    if (this.tryClientSideNavigation(url)) {
+                        return {
+                            success: true,
+                            message: `Navigated to ${path}`
+                        };
+                    }
+                    // Fallback to full page navigation
+                    window.location.href = url;
+                    return {
+                        success: true,
+                        message: `Navigating to ${path}...`
+                    };
+                }
+                // External URL - open in new tab
+                window.open(url, '_blank', 'noopener,noreferrer');
+                return {
+                    success: true,
+                    message: `Opened ${url} in new tab`
+                };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    message: 'Navigation failed',
+                    error: String(error)
+                };
+            }
+        }
+        /**
+         * Fill a form field
+         */
+        async fillForm(selector, value) {
+            // Check selector is allowed
+            if (!this.isSelectorAllowed(selector)) {
+                return {
+                    success: false,
+                    message: `Selector "${selector}" is not allowed`
+                };
+            }
+            // Sanitize selector
+            const sanitizedSelector = this.sanitizeSelector(selector);
+            // Check if we're in a browser environment
+            if (typeof document === 'undefined') {
+                return {
+                    success: true,
+                    message: `Form fill would set "${sanitizedSelector}" to "${value}" (server-side)`
+                };
+            }
+            try {
+                const element = document.querySelector(sanitizedSelector);
+                if (!element) {
+                    return {
+                        success: false,
+                        message: `Element not found: ${sanitizedSelector}`
+                    };
+                }
+                if (!(element instanceof HTMLInputElement ||
+                    element instanceof HTMLTextAreaElement ||
+                    element instanceof HTMLSelectElement)) {
+                    return {
+                        success: false,
+                        message: 'Element is not a form field'
+                    };
+                }
+                // Focus the element
+                element.focus();
+                // Set value
+                if (element instanceof HTMLSelectElement) {
+                    // For select, find matching option
+                    const option = Array.from(element.options).find(opt => opt.value.toLowerCase() === value.toLowerCase() ||
+                        opt.text.toLowerCase() === value.toLowerCase());
+                    if (option) {
+                        element.value = option.value;
+                    }
+                    else {
+                        return {
+                            success: false,
+                            message: `Option "${value}" not found`
+                        };
+                    }
+                }
+                else {
+                    element.value = value;
+                }
+                // Dispatch events to trigger frameworks
+                element.dispatchEvent(new Event('input', { bubbles: true }));
+                element.dispatchEvent(new Event('change', { bubbles: true }));
+                // For React - try to set value natively
+                const nativeInputValueSetter = Object.getOwnPropertyDescriptor(window.HTMLInputElement.prototype, 'value')?.set;
+                if (nativeInputValueSetter && element instanceof HTMLInputElement) {
+                    nativeInputValueSetter.call(element, value);
+                    element.dispatchEvent(new Event('input', { bubbles: true }));
+                }
+                return {
+                    success: true,
+                    message: `Filled field with "${value}"`
+                };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    message: 'Failed to fill form field',
+                    error: String(error)
+                };
+            }
+        }
+        /**
+         * Click an element
+         */
+        async clickElement(selector) {
+            // Check selector is allowed
+            if (!this.isSelectorAllowed(selector)) {
+                return {
+                    success: false,
+                    message: `Selector "${selector}" is not allowed`
+                };
+            }
+            // Sanitize selector
+            const sanitizedSelector = this.sanitizeSelector(selector);
+            // Check if we're in a browser environment
+            if (typeof document === 'undefined') {
+                return {
+                    success: true,
+                    message: `Click on "${sanitizedSelector}" would be executed (server-side)`
+                };
+            }
+            try {
+                const element = document.querySelector(sanitizedSelector);
+                if (!element) {
+                    return {
+                        success: false,
+                        message: `Element not found: ${sanitizedSelector}`
+                    };
+                }
+                if (!(element instanceof HTMLElement)) {
+                    return {
+                        success: false,
+                        message: 'Element is not clickable'
+                    };
+                }
+                // Scroll into view
+                element.scrollIntoView({ behavior: 'smooth', block: 'center' });
+                // Brief delay for scroll
+                await this.sleep(300);
+                // Click
+                element.click();
+                return {
+                    success: true,
+                    message: 'Element clicked'
+                };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    message: 'Failed to click element',
+                    error: String(error)
+                };
+            }
+        }
+        /**
+         * Trigger a modal by clicking its trigger element
+         */
+        async triggerModal(triggerSelector) {
+            return this.clickElement(triggerSelector);
+        }
+        /**
+         * Scroll to an element
+         */
+        async scrollToElement(selector) {
+            // Check if we're in a browser environment
+            if (typeof window === 'undefined') {
+                return {
+                    success: true,
+                    message: `Scroll to "${selector}" would be executed (server-side)`
+                };
+            }
+            try {
+                // Special case for top/bottom
+                if (selector === 'body') {
+                    window.scrollTo({ top: 0, behavior: 'smooth' });
+                    return { success: true, message: 'Scrolled to top' };
+                }
+                if (selector === 'body:last-child') {
+                    window.scrollTo({ top: document.body.scrollHeight, behavior: 'smooth' });
+                    return { success: true, message: 'Scrolled to bottom' };
+                }
+                const element = document.querySelector(selector);
+                if (!element) {
+                    return {
+                        success: false,
+                        message: `Element not found: ${selector}`
+                    };
+                }
+                element.scrollIntoView({ behavior: 'smooth', block: 'start' });
+                return {
+                    success: true,
+                    message: 'Scrolled to element'
+                };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    message: 'Failed to scroll',
+                    error: String(error)
+                };
+            }
+        }
+        /**
+         * Highlight an element with animation
+         */
+        async highlightElement(selector) {
+            // Check selector is allowed
+            if (!this.isSelectorAllowed(selector)) {
+                return {
+                    success: false,
+                    message: `Selector "${selector}" is not allowed`
+                };
+            }
+            // Check if we're in a browser environment
+            if (typeof document === 'undefined') {
+                return {
+                    success: true,
+                    message: `Highlight on "${selector}" would be shown (server-side)`
+                };
+            }
+            try {
+                const element = document.querySelector(selector);
+                if (!element) {
+                    return {
+                        success: false,
+                        message: `Element not found: ${selector}`
+                    };
+                }
+                // Remove existing highlight
+                this.removeHighlight();
+                // Scroll element into view
+                element.scrollIntoView({ behavior: 'smooth', block: 'center' });
+                // Brief delay for scroll
+                await this.sleep(300);
+                // Create highlight overlay
+                const rect = element.getBoundingClientRect();
+                const overlay = document.createElement('div');
+                overlay.className = 'astermind-highlight-overlay';
+                overlay.style.cssText = `
+                position: fixed;
+                top: ${rect.top - 4}px;
+                left: ${rect.left - 4}px;
+                width: ${rect.width + 8}px;
+                height: ${rect.height + 8}px;
+                border: 3px solid #4F46E5;
+                border-radius: 4px;
+                pointer-events: none;
+                z-index: 999999;
+                animation: astermind-highlight-pulse 1s ease-in-out 3;
+            `;
+                document.body.appendChild(overlay);
+                this.highlightOverlay = overlay;
+                // Remove after animation
+                setTimeout(() => this.removeHighlight(), 3000);
+                return {
+                    success: true,
+                    message: 'Element highlighted'
+                };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    message: 'Failed to highlight element',
+                    error: String(error)
+                };
+            }
+        }
+        /**
+         * Execute a custom action callback
+         */
+        async executeCustomAction(actionName, params) {
+            // Validate custom action is in whitelist
+            if (!this.isAllowedCustomAction(actionName)) {
+                return {
+                    success: false,
+                    message: `Custom action "${actionName}" not found`
+                };
+            }
+            const callback = this.config.customActions[actionName];
+            try {
+                return await callback(params);
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    message: `Custom action "${actionName}" failed`,
+                    error: String(error)
+                };
+            }
+        }
+        // ==================== HELPER METHODS ====================
+        /**
+         * Check if URL is internal to the current site
+         */
+        isInternalUrl(url) {
+            // Relative URLs are internal
+            if (url.startsWith('/') || url.startsWith('./') || url.startsWith('../')) {
+                return true;
+            }
+            // Check if we're in a browser environment
+            if (typeof window === 'undefined') {
+                return true;
+            }
+            // Check if same origin
+            try {
+                const urlObj = new URL(url, window.location.href);
+                return urlObj.origin === window.location.origin;
+            }
+            catch {
+                return true; // Assume internal on error
+            }
+        }
+        /**
+         * Try client-side navigation for SPAs
+         */
+        tryClientSideNavigation(url) {
+            if (typeof window === 'undefined') {
+                return false;
+            }
+            // Try History API pushState
+            try {
+                window.history.pushState({}, '', url);
+                window.dispatchEvent(new PopStateEvent('popstate'));
+                // Also dispatch hashchange for hash routing
+                if (url.includes('#')) {
+                    window.dispatchEvent(new HashChangeEvent('hashchange'));
+                }
+                return true;
+            }
+            catch {
+                return false;
+            }
+        }
+        /**
+         * Validate navigation URL
+         */
+        validateNavigationUrl(url) {
+            // Reject javascript: and data: URLs
+            if (/^(javascript|data):/i.test(url)) {
+                return false;
+            }
+            // Check if we're in a browser environment
+            if (typeof window === 'undefined') {
+                return true;
+            }
+            // Only allow relative URLs or same-origin
+            try {
+                const urlObj = new URL(url, window.location.href);
+                return urlObj.origin === window.location.origin || url.startsWith('/');
+            }
+            catch {
+                return url.startsWith('/');
+            }
+        }
+        /**
+         * Sanitize CSS selector to prevent injection
+         */
+        sanitizeSelector(selector) {
+            // Remove potentially dangerous characters
+            return selector
+                .replace(/[<>'"]/g, '')
+                .replace(/javascript:/gi, '')
+                .replace(/data:/gi, '')
+                .trim();
+        }
+        /**
+         * Validate custom action is in whitelist
+         */
+        isAllowedCustomAction(actionName) {
+            return this.config.customActions !== undefined &&
+                Object.prototype.hasOwnProperty.call(this.config.customActions, actionName);
+        }
+        /**
+         * Remove highlight overlay
+         */
+        removeHighlight() {
+            if (this.highlightOverlay) {
+                this.highlightOverlay.remove();
+                this.highlightOverlay = null;
+            }
+        }
+        /**
+         * Inject required styles
+         */
+        injectStyles() {
+            if (typeof document === 'undefined') {
+                return;
+            }
+            if (document.getElementById('astermind-agent-styles')) {
+                return;
+            }
+            const style = document.createElement('style');
+            style.id = 'astermind-agent-styles';
+            style.textContent = `
+            @keyframes astermind-highlight-pulse {
+                0%, 100% {
+                    box-shadow: 0 0 0 0 rgba(79, 70, 229, 0.4);
+                }
+                50% {
+                    box-shadow: 0 0 0 10px rgba(79, 70, 229, 0);
+                }
+            }
+
+            .astermind-highlight-overlay {
+                transition: all 0.2s ease-out;
+            }
+        `;
+            document.head.appendChild(style);
+        }
+        /**
+         * Sleep utility
+         */
+        sleep(ms) {
+            return new Promise(resolve => setTimeout(resolve, ms));
+        }
+        /**
+         * Get agent configuration
+         */
+        getConfig() {
+            return this.config;
+        }
+        /**
+         * Get the intent classifier
+         */
+        getClassifier() {
+            return this.classifier;
+        }
+        /**
+         * Reset action count (for testing)
+         */
+        resetActionCount() {
+            this.actionCount = 0;
+            this.lastActionReset = Date.now();
+        }
+    }
+
+    // src/agentic/register.ts
+    // Helper for registering agentic capabilities with CyberneticClient
+    /**
+     * Register agentic capabilities with a CyberneticClient
+     *
+     * This function is the bridge between core and agentic modules.
+     * It must be called after creating the client to enable agentic features.
+     *
+     * @example
+     * ```typescript
+     * import { CyberneticClient, registerAgenticCapabilities } from '@astermind/cybernetic-chatbot-client';
+     *
+     * const client = new CyberneticClient({
+     *     apiUrl: 'https://api.example.com',
+     *     apiKey: 'am_xxx_123',
+     *     agentic: {
+     *         enabled: true,
+     *         allowedActions: ['click', 'fill', 'scroll'],
+     *         confirmActions: true
+     *     }
+     * });
+     *
+     * // Register agentic capabilities
+     * registerAgenticCapabilities(client);
+     *
+     * // Now client supports agentic responses
+     * const response = await client.ask('Click the Add to Cart button');
+     * ```
+     *
+     * @param client - The CyberneticClient instance to register capabilities with
+     */
+    function registerAgenticCapabilities(client) {
+        const capabilities = {
+            agent: CyberneticAgent,
+            intentClassifier: CyberneticIntentClassifier
+        };
+        client.registerAgentic(capabilities);
+    }
+
+    // src/index.ts
+    // Main package exports (core + tree-shakeable agentic)
+    // Core exports
+    function createClient(config) {
+        return new CyberneticClient(config);
+    }
+
+    exports.ApiClient = ApiClient;
+    exports.CyberneticAgent = CyberneticAgent;
+    exports.CyberneticCache = CyberneticCache;
+    exports.CyberneticClient = CyberneticClient;
+    exports.CyberneticIntentClassifier = CyberneticIntentClassifier;
+    exports.CyberneticLocalRAG = CyberneticLocalRAG;
+    exports.LicenseManager = LicenseManager;
+    exports.REQUIRED_FEATURES = REQUIRED_FEATURES;
+    exports.createClient = createClient;
+    exports.createLicenseManager = createLicenseManager;
+    exports.detectEnvironment = detectEnvironment;
+    exports.getEnforcementMode = getEnforcementMode;
+    exports.getTokenExpiration = getTokenExpiration;
+    exports.isValidJWTFormat = isValidJWTFormat;
+    exports.loadConfig = loadConfig;
+    exports.registerAgenticCapabilities = registerAgenticCapabilities;
+    exports.validateConfig = validateConfig;
+    exports.verifyLicenseToken = verifyLicenseToken;
+
+}));
+//# sourceMappingURL=cybernetic-chatbot-client.umd.js.map