nexus-prime 0.2.0

package/dist/core/memory.js

@@ -0,0 +1,304 @@
+/**
+ * Three-Tier Brain-Inspired Memory System
+ *
+ * CORTEX: Long-term memory (persistent)
+ * HIPPOCAMPUS: Medium-term (recent 24-48 hours)
+ * PREFRONTAL: Working memory (~7 items)
+ */
+export class MemorySystem {
+    cortex;
+    hippocampus;
+    prefrontal;
+    decayRate = 0.0001;
+    consolidationThreshold = 0.5;
+    constructor(options) {
+        // Initialize Cortex (Long-term)
+        this.cortex = {
+            patterns: new Map(),
+            synapses: new Map(),
+            semanticGraph: {
+                nodes: new Map(),
+                edges: new Map()
+            }
+        };
+        // Initialize Hippocampus (Medium-term)
+        this.hippocampus = {
+            recentPatterns: [],
+            window: options?.hippocampusWindowHours ?? 48,
+            bindings: new Map()
+        };
+        // Initialize Prefrontal (Working)
+        this.prefrontal = {
+            activeContext: [],
+            maxItems: options?.prefrontalMaxItems ?? 7
+        };
+    }
+    // ==================== CORTEX OPERATIONS ====================
+    /**
+     * Store pattern in long-term memory (Cortex)
+     */
+    store(pattern, priority = 1.0) {
+        this.cortex.patterns.set(pattern.id, pattern);
+        this.cortex.synapses.set(pattern.id, priority);
+        // Add to semantic graph
+        this.addToGraph(pattern);
+    }
+    /**
+     * Recall patterns from Cortex
+     */
+    recall(query, k = 5) {
+        const scores = [];
+        for (const [id, pattern] of this.cortex.patterns) {
+            const similarity = this.cosineSimilarity(query, pattern.structure);
+            const recency = this.computeRecency(pattern);
+            const weight = this.cortex.synapses.get(id) ?? 1.0;
+            const score = similarity * (1 + weight) * recency;
+            scores.push({ pattern, score });
+        }
+        // Return top-k
+        return scores
+            .sort((a, b) => b.score - a.score)
+            .slice(0, k);
+    }
+    /**
+     * Hebbian strengthening: patterns that co-occur get stronger
+     */
+    hebbianStrengthen(pattern) {
+        const related = this.findRelated(pattern);
+        for (const rel of related) {
+            const currentWeight = this.cortex.synapses.get(rel.id) ?? 1.0;
+            this.cortex.synapses.set(rel.id, currentWeight + pattern.confidence * 0.01);
+        }
+    }
+    /**
+     * Decay unused patterns
+     */
+    decayUnused() {
+        for (const [id] of this.cortex.synapses) {
+            if (!this.wasRecentlyAccessed(id)) {
+                const currentWeight = this.cortex.synapses.get(id) ?? 1.0;
+                this.cortex.synapses.set(id, currentWeight * (1 - this.decayRate));
+            }
+        }
+        // Prune very weak synapses
+        for (const [id, weight] of this.cortex.synapses) {
+            if (weight < 0.01) {
+                this.cortex.patterns.delete(id);
+                this.cortex.synapses.delete(id);
+                this.removeFromGraph(id);
+            }
+        }
+    }
+    // ==================== HIPPOCAMPUS OPERATIONS ====================
+    /**
+     * Add pattern to recent memory (Hippocampus)
+     */
+    addToRecent(pattern) {
+        this.hippocampus.recentPatterns.unshift(pattern);
+        // Trim to window
+        const maxPatterns = this.hippocampus.window * 10; // ~10 patterns per hour
+        if (this.hippocampus.recentPatterns.length > maxPatterns) {
+            this.hippocampus.recentPatterns = this.hippocampus.recentPatterns.slice(0, maxPatterns);
+        }
+    }
+    /**
+     * Create temporary binding between patterns
+     */
+    bind(patternA, patternB) {
+        this.hippocampus.bindings.set(patternA, patternB);
+    }
+    /**
+     * Get recent patterns
+     */
+    getRecent(k = 10) {
+        return this.hippocampus.recentPatterns.slice(0, k);
+    }
+    /**
+     * Consolidate: Transfer important patterns from Hippocampus to Cortex
+     */
+    consolidate() {
+        for (const pattern of this.hippocampus.recentPatterns) {
+            if (pattern.confidence > this.consolidationThreshold) {
+                // Promote to Cortex
+                this.store(pattern, pattern.confidence);
+                this.hebbianStrengthen(pattern);
+            }
+        }
+        // Clear recent (they're now in Cortex or decayed)
+        this.hippocampus.recentPatterns = [];
+    }
+    // ==================== PREFRONTAL OPERATIONS ====================
+    /**
+     * Add to working memory
+     */
+    addToWorking(item) {
+        if (!this.prefrontal.activeContext.includes(item)) {
+            this.prefrontal.activeContext.unshift(item);
+            // Enforce capacity limit (Miller's Law: ~7 items)
+            if (this.prefrontal.activeContext.length > this.prefrontal.maxItems) {
+                this.prefrontal.activeContext.pop();
+            }
+        }
+    }
+    /**
+     * Get working memory
+     */
+    getWorking() {
+        return [...this.prefrontal.activeContext];
+    }
+    /**
+     * Clear working memory
+     */
+    clearWorking() {
+        this.prefrontal.activeContext = [];
+    }
+    /**
+     * Keep only specific items in working memory
+     */
+    retain(items) {
+        this.prefrontal.activeContext = items.filter(item => this.prefrontal.activeContext.includes(item));
+    }
+    // ==================== LEARNING ====================
+    /**
+     * Learn from experience
+     */
+    learn(experience) {
+        // Extract pattern from experience
+        const pattern = {
+            id: `pattern_${experience.agentId}_${experience.timestamp}`,
+            structure: this.embedExperience(experience),
+            weight: experience.value,
+            confidence: experience.value,
+            origin: experience.agentId,
+            timestamp: experience.timestamp,
+            examples: [experience.action]
+        };
+        if (experience.value > 0.5) {
+            // High value: store prominently
+            this.store(pattern, experience.value);
+            this.addToRecent(pattern);
+            // Very high value: trigger consolidation immediately
+            if (experience.value > 0.9) {
+                this.hebbianStrengthen(pattern);
+            }
+        }
+        else {
+            // Low value: just add to recent, let it decay
+            this.addToRecent(pattern);
+        }
+        return pattern;
+    }
+    /**
+     * Compress multiple experiences into a single pattern
+     */
+    compress(experiences) {
+        if (experiences.length === 0) {
+            throw new Error('No experiences to compress');
+        }
+        if (experiences.length === 1) {
+            return this.learn(experiences[0]);
+        }
+        // Average embeddings
+        const embeddings = experiences.map(e => this.embedExperience(e));
+        const avgEmbedding = embeddings[0].map((_, i) => embeddings.reduce((sum, e) => sum + e[i], 0) / embeddings.length);
+        // Average value
+        const avgValue = experiences.reduce((sum, e) => sum + e.value, 0) / experiences.length;
+        return {
+            id: `compressed_${Date.now()}`,
+            structure: avgEmbedding,
+            weight: avgValue,
+            confidence: avgValue,
+            origin: 'system',
+            timestamp: Date.now(),
+            examples: experiences.map(e => e.action)
+        };
+    }
+    // ==================== SEMANTIC GRAPH ====================
+    addToGraph(pattern) {
+        this.cortex.semanticGraph.nodes.set(pattern.id, {
+            id: pattern.id,
+            type: 'pattern',
+            embedding: pattern.structure,
+            metadata: { confidence: pattern.confidence }
+        });
+    }
+    removeFromGraph(patternId) {
+        this.cortex.semanticGraph.nodes.delete(patternId);
+        // Remove edges
+        for (const [source, edges] of this.cortex.semanticGraph.edges) {
+            this.cortex.semanticGraph.edges.set(source, edges.filter(e => e.target !== patternId));
+        }
+    }
+    findRelated(pattern) {
+        const related = [];
+        for (const [id, p] of this.cortex.patterns) {
+            if (id !== pattern.id) {
+                const similarity = this.cosineSimilarity(pattern.structure, p.structure);
+                if (similarity > 0.7) {
+                    related.push(p);
+                }
+            }
+        }
+        return related;
+    }
+    // ==================== UTILITIES ====================
+    cosineSimilarity(a, b) {
+        if (a.length !== b.length)
+            return 0;
+        let dotProduct = 0;
+        let normA = 0;
+        let normB = 0;
+        for (let i = 0; i < a.length; i++) {
+            dotProduct += a[i] * b[i];
+            normA += a[i] * a[i];
+            normB += b[i] * b[i];
+        }
+        return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB) || 1);
+    }
+    computeRecency(pattern) {
+        const age = Date.now() - pattern.timestamp;
+        const hour = 60 * 60 * 1000;
+        return Math.exp(-age / (24 * hour)); // Decay over 24 hours
+    }
+    recentlyAccessed = new Set();
+    wasRecentlyAccessed(id) {
+        if (this.recentlyAccessed.has(id)) {
+            this.recentlyAccessed.delete(id);
+            return true;
+        }
+        return false;
+    }
+    markAccessed(id) {
+        this.recentlyAccessed.add(id);
+    }
+    embedExperience(experience) {
+        // Simple hash-based embedding for now
+        // In production, use actual embeddings
+        const hash = this.hashString(`${experience.action}_${experience.outcome}`);
+        const embedding = [];
+        for (let i = 0; i < 64; i++) {
+            embedding.push(((hash >> i) & 1) ? 1 : 0);
+        }
+        return embedding;
+    }
+    hashString(str) {
+        let hash = 0;
+        for (let i = 0; i < str.length; i++) {
+            hash = ((hash << 5) - hash) + str.charCodeAt(i);
+            hash |= 0;
+        }
+        return Math.abs(hash);
+    }
+    // ==================== STATE ====================
+    getCortex() {
+        return this.cortex;
+    }
+    getHippocampus() {
+        return this.hippocampus;
+    }
+    getPrefrontal() {
+        return this.prefrontal;
+    }
+}
+export const createMemory = (options) => new MemorySystem(options);
+//# sourceMappingURL=memory.js.map

package/dist/core/memory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory.js","sourceRoot":"","sources":["../../src/core/memory.ts"],"names":[],"mappings":"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"}

package/dist/core/optimize.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Attention Economics & Token Optimization
+ *
+ * Intelligent token allocation that mimics brain attention.
+ * Compresses familiar patterns, expands novel ones.
+ */
+export declare class AttentionEconomics {
+    private totalAttention;
+    private allocations;
+    private history;
+    constructor(totalAttention?: number);
+    /**
+     * Allocate attention across agents based on multiple factors
+     */
+    allocate(agents: Array<{
+        id: string;
+        performance: number;
+        reliability: number;
+        urgency: number;
+        potential: number;
+    }>): Map<string, number>;
+    /**
+     * Get current allocation for an agent
+     */
+    getAllocation(agentId: string): number;
+    /**
+     * Record agent performance for future allocation
+     */
+    recordPerformance(agentId: string, value: number): void;
+    /**
+     * Get average performance
+     */
+    getAveragePerformance(agentId: string): number;
+}
+export declare class TokenOptimizer {
+    private maxTokens;
+    private compressionDictionary;
+    private familiarityScores;
+    constructor(maxTokens?: number);
+    /**
+     * Optimize token allocation for a task
+     */
+    optimize(task: string, context: string[]): {
+        tokens: number;
+        strategy: 'compress' | 'expand' | 'standard';
+        breakdown: Array<{
+            part: string;
+            tokens: number;
+        }>;
+    };
+    /**
+     * Compress tokens using learned dictionary
+     */
+    compress(text: string): string;
+    /**
+     * Expand compressed tokens back to text
+     */
+    expand(compressed: string): string;
+    /**
+     * Update compression dictionary
+     */
+    updateDictionary(phrase: string, token: string): void;
+    /**
+     * Speculate: generate variations for novel situations
+     */
+    speculate(text: string, n?: number): string[];
+    /**
+     * Rank speculations by potential
+     */
+    rankByPotential(variations: string[]): string[];
+    private decompose;
+    private estimateComplexity;
+    private computeRelevance;
+    private isFamiliar;
+    private isNovel;
+    markFamiliar(subtask: string): void;
+    markNovel(subtask: string): void;
+}
+export declare class InfiniteContext {
+    private attentionBudget;
+    private index;
+    private attentionRouter;
+    constructor(attentionBudget?: number);
+    /**
+     * Index content for retrieval
+     */
+    indexContent(key: string, content: string[]): void;
+    /**
+     * Think: retrieve relevant context regardless of "distance"
+     */
+    think(query: string, maxItems?: number): string[];
+    /**
+     * Update attention weights
+     */
+    updateAttention(key: string, value: number): void;
+}
+export declare const createAttentionEconomics: (totalAttention?: number) => AttentionEconomics;
+export declare const createTokenOptimizer: (maxTokens?: number) => TokenOptimizer;
+export declare const createInfiniteContext: (attentionBudget?: number) => InfiniteContext;
+//# sourceMappingURL=optimize.d.ts.map

package/dist/core/optimize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"optimize.d.ts","sourceRoot":"","sources":["../../src/core/optimize.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,cAAc,CAAS;IAC/B,OAAO,CAAC,WAAW,CAAkC;IACrD,OAAO,CAAC,OAAO,CAAoC;gBAEvC,cAAc,GAAE,MAAY;IAIxC;;OAEG;IACH,QAAQ,CAAC,MAAM,EAAE,KAAK,CAAC;QACrB,EAAE,EAAE,MAAM,CAAC;QACX,WAAW,EAAE,MAAM,CAAC;QACpB,WAAW,EAAE,MAAM,CAAC;QACpB,OAAO,EAAE,MAAM,CAAC;QAChB,SAAS,EAAE,MAAM,CAAC;KACnB,CAAC,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC;IA6BxB;;OAEG;IACH,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM;IAItC;;OAEG;IACH,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;IAcvD;;OAEG;IACH,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM;CAQ/C;AAID,qBAAa,cAAc;IAIb,OAAO,CAAC,SAAS;IAH7B,OAAO,CAAC,qBAAqB,CAAkC;IAC/D,OAAO,CAAC,iBAAiB,CAAkC;gBAEvC,SAAS,GAAE,MAAe;IAE9C;;OAEG;IACH,QAAQ,CACN,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EAAE,GAChB;QACD,MAAM,EAAE,MAAM,CAAC;QACf,QAAQ,EAAE,UAAU,GAAG,QAAQ,GAAG,UAAU,CAAC;QAC7C,SAAS,EAAE,KAAK,CAAC;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,MAAM,EAAE,MAAM,CAAA;SAAE,CAAC,CAAC;KACpD;IA4CD;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAW9B;;OAEG;IACH,MAAM,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM;IAUlC;;OAEG;IACH,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;IAIrD;;OAEG;IACH,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,CAAC,GAAE,MAAU,GAAG,MAAM,EAAE;IAMhD;;OAEG;IACH,eAAe,CAAC,UAAU,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE;IAW/C,OAAO,CAAC,SAAS;IAKjB,OAAO,CAAC,kBAAkB;IAM1B,OAAO,CAAC,gBAAgB;IAiBxB,OAAO,CAAC,UAAU;IAKlB,OAAO,CAAC,OAAO;IAKf,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAKnC,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;CAIjC;AAID,qBAAa,eAAe;IAId,OAAO,CAAC,eAAe;IAHnC,OAAO,CAAC,KAAK,CAAoC;IACjD,OAAO,CAAC,eAAe,CAAkC;gBAErC,eAAe,GAAE,MAAY;IAEjD;;OAEG;IACH,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI;IAIlD;;OAEG;IACH,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE;IAsCjD;;OAEG;IACH,eAAe,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;CAGlD;AAID,eAAO,MAAM,wBAAwB,GAAI,iBAAiB,MAAM,uBACxB,CAAC;AAEzC,eAAO,MAAM,oBAAoB,GAAI,YAAY,MAAM,mBACxB,CAAC;AAEhC,eAAO,MAAM,qBAAqB,GAAI,kBAAkB,MAAM,oBACxB,CAAC"}

package/dist/core/optimize.js

@@ -0,0 +1,263 @@
+/**
+ * Attention Economics & Token Optimization
+ *
+ * Intelligent token allocation that mimics brain attention.
+ * Compresses familiar patterns, expands novel ones.
+ */
+export class AttentionEconomics {
+    totalAttention;
+    allocations = new Map();
+    history = new Map();
+    constructor(totalAttention = 1.0) {
+        this.totalAttention = totalAttention;
+    }
+    /**
+     * Allocate attention across agents based on multiple factors
+     */
+    allocate(agents) {
+        const scores = new Map();
+        for (const agent of agents) {
+            // Composite score
+            const score = 0.4 * agent.performance +
+                0.2 * agent.reliability +
+                0.2 * agent.urgency +
+                0.2 * agent.potential;
+            scores.set(agent.id, score);
+        }
+        // Normalize to conserve attention
+        const total = Array.from(scores.values()).reduce((a, b) => a + b, 0);
+        if (total === 0) {
+            return this.allocations;
+        }
+        for (const [id, score] of scores) {
+            const normalized = (score / total) * this.totalAttention;
+            this.allocations.set(id, normalized);
+        }
+        return this.allocations;
+    }
+    /**
+     * Get current allocation for an agent
+     */
+    getAllocation(agentId) {
+        return this.allocations.get(agentId) ?? 0;
+    }
+    /**
+     * Record agent performance for future allocation
+     */
+    recordPerformance(agentId, value) {
+        if (!this.history.has(agentId)) {
+            this.history.set(agentId, []);
+        }
+        const agentHistory = this.history.get(agentId);
+        agentHistory.push(value);
+        // Keep only last 100 records
+        if (agentHistory.length > 100) {
+            agentHistory.shift();
+        }
+    }
+    /**
+     * Get average performance
+     */
+    getAveragePerformance(agentId) {
+        const history = this.history.get(agentId);
+        if (!history || history.length === 0) {
+            return 0.5; // Default
+        }
+        return history.reduce((a, b) => a + b, 0) / history.length;
+    }
+}
+// ==================== TOKEN OPTIMIZER ====================
+export class TokenOptimizer {
+    maxTokens;
+    compressionDictionary = new Map();
+    familiarityScores = new Map();
+    constructor(maxTokens = 128000) {
+        this.maxTokens = maxTokens;
+    }
+    /**
+     * Optimize token allocation for a task
+     */
+    optimize(task, context) {
+        // Decompose task into subtasks
+        const subtasks = this.decompose(task);
+        const breakdown = [];
+        let totalTokens = 0;
+        for (const subtask of subtasks) {
+            const complexity = this.estimateComplexity(subtask);
+            const relevance = this.computeRelevance(context, subtask);
+            let tokens;
+            let strategy;
+            // Determine strategy
+            const isFamiliar = this.isFamiliar(subtask);
+            const isNovel = this.isNovel(subtask);
+            if (isFamiliar) {
+                // Compress: familiar pattern, use dictionary
+                tokens = Math.floor(this.maxTokens * complexity * relevance * 0.1);
+                strategy = 'compress';
+            }
+            else if (isNovel) {
+                // Expand: novel situation, explore more
+                tokens = Math.floor(this.maxTokens * complexity * relevance * 2);
+                strategy = 'expand';
+            }
+            else {
+                // Standard allocation
+                tokens = Math.floor(this.maxTokens * complexity * relevance);
+                strategy = 'standard';
+            }
+            breakdown.push({ part: subtask, tokens });
+            totalTokens += tokens;
+        }
+        return {
+            tokens: Math.min(totalTokens, this.maxTokens),
+            strategy: totalTokens < this.maxTokens * 0.5 ? 'compress' :
+                totalTokens > this.maxTokens * 0.8 ? 'expand' : 'standard',
+            breakdown
+        };
+    }
+    /**
+     * Compress tokens using learned dictionary
+     */
+    compress(text) {
+        // Simple compression: replace known phrases
+        let compressed = text;
+        for (const [phrase, token] of this.compressionDictionary) {
+            compressed = compressed.replace(new RegExp(phrase, 'g'), token);
+        }
+        return compressed;
+    }
+    /**
+     * Expand compressed tokens back to text
+     */
+    expand(compressed) {
+        let expanded = compressed;
+        for (const [token, phrase] of this.compressionDictionary) {
+            expanded = expanded.replace(new RegExp(token, 'g'), phrase);
+        }
+        return expanded;
+    }
+    /**
+     * Update compression dictionary
+     */
+    updateDictionary(phrase, token) {
+        this.compressionDictionary.set(phrase, token);
+    }
+    /**
+     * Speculate: generate variations for novel situations
+     */
+    speculate(text, n = 3) {
+        // In production, use actual LLM for speculation
+        // For now, return variations
+        return Array.from({ length: n }, (_, i) => `${text}_variant_${i}`);
+    }
+    /**
+     * Rank speculations by potential
+     */
+    rankByPotential(variations) {
+        // Simple ranking based on familiarity
+        return variations.sort((a, b) => {
+            const scoreA = this.familiarityScores.get(a) ?? 0;
+            const scoreB = this.familiarityScores.get(b) ?? 0;
+            return scoreB - scoreA;
+        });
+    }
+    // ==================== HELPERS ====================
+    decompose(task) {
+        // Simple decomposition by splitting on common separators
+        return task.split(/[,;]| and | then /).map(s => s.trim()).filter(Boolean);
+    }
+    estimateComplexity(subtask) {
+        // Simple heuristic: longer = more complex
+        const words = subtask.split(/\s+/).length;
+        return Math.min(1, words / 20);
+    }
+    computeRelevance(context, subtask) {
+        // Simple word overlap
+        const subtaskWords = new Set(subtask.toLowerCase().split(/\s+/));
+        let overlap = 0;
+        for (const ctx of context) {
+            const ctxWords = ctx.toLowerCase().split(/\s+/);
+            for (const word of ctxWords) {
+                if (subtaskWords.has(word)) {
+                    overlap++;
+                }
+            }
+        }
+        return Math.min(1, overlap / Math.max(subtaskWords.size, 1));
+    }
+    isFamiliar(subtask) {
+        const score = this.familiarityScores.get(subtask) ?? 0;
+        return score > 0.7;
+    }
+    isNovel(subtask) {
+        const score = this.familiarityScores.get(subtask) ?? 0;
+        return score < 0.3;
+    }
+    markFamiliar(subtask) {
+        const current = this.familiarityScores.get(subtask) ?? 0;
+        this.familiarityScores.set(subtask, Math.min(1, current + 0.1));
+    }
+    markNovel(subtask) {
+        const current = this.familiarityScores.get(subtask) ?? 0;
+        this.familiarityScores.set(subtask, Math.max(0, current - 0.1));
+    }
+}
+// ==================== INFINITE CONTEXT ====================
+export class InfiniteContext {
+    attentionBudget;
+    index = new Map();
+    attentionRouter = new Map();
+    constructor(attentionBudget = 100) {
+        this.attentionBudget = attentionBudget;
+    }
+    /**
+     * Index content for retrieval
+     */
+    indexContent(key, content) {
+        this.index.set(key, content);
+    }
+    /**
+     * Think: retrieve relevant context regardless of "distance"
+     */
+    think(query, maxItems) {
+        const queryWords = new Set(query.toLowerCase().split(/\s+/));
+        const scores = [];
+        for (const [key, content] of this.index) {
+            let score = 0;
+            for (const item of content) {
+                const itemWords = item.toLowerCase().split(/\s+/);
+                for (const word of itemWords) {
+                    if (queryWords.has(word)) {
+                        score++;
+                    }
+                }
+            }
+            // Weight by attention
+            const attention = this.attentionRouter.get(key) ?? 1;
+            scores.push({ key, score: score * attention });
+        }
+        // Sort by score
+        scores.sort((a, b) => b.score - a.score);
+        // Retrieve top-k
+        const limit = maxItems ?? Math.min(this.attentionBudget, scores.length);
+        const results = [];
+        for (let i = 0; i < limit; i++) {
+            const content = this.index.get(scores[i].key);
+            if (content) {
+                results.push(...content);
+            }
+        }
+        return results;
+    }
+    /**
+     * Update attention weights
+     */
+    updateAttention(key, value) {
+        this.attentionRouter.set(key, value);
+    }
+}
+// ==================== FACTORY ====================
+export const createAttentionEconomics = (totalAttention) => new AttentionEconomics(totalAttention);
+export const createTokenOptimizer = (maxTokens) => new TokenOptimizer(maxTokens);
+export const createInfiniteContext = (attentionBudget) => new InfiniteContext(attentionBudget);
+//# sourceMappingURL=optimize.js.map