@astermind/cybernetic-chatbot-client 1.0.6

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

@@ -0,0 +1,3265 @@
+// 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);
+}
+
+export { ApiClient, CyberneticAgent, CyberneticCache, CyberneticClient, CyberneticIntentClassifier, CyberneticLocalRAG, LicenseManager, REQUIRED_FEATURES, createClient, createLicenseManager, detectEnvironment, getEnforcementMode, getTokenExpiration, isValidJWTFormat, loadConfig, registerAgenticCapabilities, validateConfig, verifyLicenseToken };
+//# sourceMappingURL=cybernetic-chatbot-client.esm.js.map