cortex-mcp 1.0.1

package/dist/memory/anticipation-engine.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Anticipation Engine — Proactive memory surfacing.
+ *
+ * Instead of waiting to be asked, this module predicts what memories
+ * are relevant based on the current file, directory, and recent activity.
+ *
+ * Like how walking into your kitchen makes you remember you need milk.
+ */
+import { MemoryStore } from '../db/memory-store';
+import { ScoredMemory } from '../types';
+export interface AnticipationResult {
+    fileMemories: ScoredMemory[];
+    directoryMemories: ScoredMemory[];
+    relatedTypeMemories: ScoredMemory[];
+}
+export declare function anticipate(memoryStore: MemoryStore, currentFile?: string): AnticipationResult;
+/** Format anticipation results for injection */
+export declare function formatAnticipation(result: AnticipationResult): string;
+//# sourceMappingURL=anticipation-engine.d.ts.map

package/dist/memory/anticipation-engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"anticipation-engine.d.ts","sourceRoot":"","sources":["../../src/memory/anticipation-engine.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,EAAc,YAAY,EAAE,MAAM,UAAU,CAAC;AAEpD,MAAM,WAAW,kBAAkB;IAC/B,YAAY,EAAE,YAAY,EAAE,CAAC;IAC7B,iBAAiB,EAAE,YAAY,EAAE,CAAC;IAClC,mBAAmB,EAAE,YAAY,EAAE,CAAC;CACvC;AAED,wBAAgB,UAAU,CACtB,WAAW,EAAE,WAAW,EACxB,WAAW,CAAC,EAAE,MAAM,GACrB,kBAAkB,CA0DpB;AAED,gDAAgD;AAChD,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,kBAAkB,GAAG,MAAM,CAiBrE"}

package/dist/memory/anticipation-engine.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.anticipate = anticipate;
+exports.formatAnticipation = formatAnticipation;
+const types_1 = require("../types");
+function anticipate(memoryStore, currentFile) {
+    const result = {
+        fileMemories: [],
+        directoryMemories: [],
+        relatedTypeMemories: [],
+    };
+    if (!currentFile)
+        return result;
+    // 1. Direct file memories — exact file match
+    const fileMemories = memoryStore.getByFile(currentFile, 10);
+    result.fileMemories = fileMemories.map((m, i) => ({
+        memory: m,
+        score: 1.0 - (i * 0.05),
+        matchMethod: 'anticipation:file',
+    }));
+    // 2. Directory memories — same folder = likely related
+    const dir = currentFile.replace(/[\\/][^\\/]+$/, '');
+    if (dir && dir !== currentFile) {
+        const allActive = memoryStore.getActive(200);
+        const dirMemories = allActive.filter(m => m.relatedFiles?.some(f => f.startsWith(dir) || f.includes(dir)));
+        result.directoryMemories = dirMemories.slice(0, 5).map((m, i) => ({
+            memory: m,
+            score: 0.7 - (i * 0.05),
+            matchMethod: 'anticipation:directory',
+        }));
+    }
+    // 3. File type memories — .ts file? surface TS-related conventions
+    const ext = currentFile.split('.').pop()?.toLowerCase();
+    if (ext) {
+        const typeKeywords = {
+            ts: ['typescript', 'type', 'interface', 'enum'],
+            tsx: ['react', 'component', 'jsx', 'hook', 'state'],
+            css: ['style', 'css', 'theme', 'color', 'font'],
+            py: ['python', 'pip', 'def', 'class'],
+            js: ['javascript', 'node', 'require', 'module'],
+            sql: ['database', 'query', 'table', 'migration'],
+            json: ['config', 'package', 'settings'],
+        };
+        const keywords = typeKeywords[ext];
+        if (keywords) {
+            const conventions = memoryStore.getByType(types_1.MemoryType.CONVENTION, 50);
+            const matched = conventions.filter(c => keywords.some(k => c.intent.toLowerCase().includes(k)));
+            result.relatedTypeMemories = matched.slice(0, 3).map((m, i) => ({
+                memory: m,
+                score: 0.5 - (i * 0.05),
+                matchMethod: 'anticipation:filetype',
+            }));
+        }
+    }
+    return result;
+}
+/** Format anticipation results for injection */
+function formatAnticipation(result) {
+    const all = [
+        ...result.fileMemories,
+        ...result.directoryMemories,
+        ...result.relatedTypeMemories,
+    ];
+    if (all.length === 0)
+        return '';
+    const lines = ['## 🔮 Anticipated Context (for current file)'];
+    const seen = new Set();
+    for (const m of all.slice(0, 8)) {
+        if (seen.has(m.memory.id))
+            continue;
+        seen.add(m.memory.id);
+        lines.push(`- [${m.memory.type}] ${m.memory.intent}${m.memory.reason ? ` — ${m.memory.reason}` : ''}`);
+    }
+    return lines.join('\n');
+}
+//# sourceMappingURL=anticipation-engine.js.map

package/dist/memory/anticipation-engine.js.map

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

package/dist/memory/attention-ranker.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Attention Ranker — Re-ranks memories based on what you're doing RIGHT NOW.
+ *
+ * Debugging? Bug fixes and corrections rise to the top.
+ * Coding? Conventions and decisions become priority.
+ * Reviewing? Insights and architecture matter most.
+ *
+ * This is like how your brain filters: at a restaurant, food memories are
+ * strong; at a library, book memories are strong. Same data, different priority.
+ */
+import { ScoredMemory } from '../types';
+export type ActionContext = 'debugging' | 'coding' | 'reviewing' | 'chatting' | 'exploring' | 'unknown';
+/** Detect action context from topic/file keywords */
+export declare function detectActionContext(topic?: string, currentFile?: string): ActionContext;
+/** Re-rank memories based on current action context */
+export declare function rankByAttention(memories: ScoredMemory[], context: ActionContext): ScoredMemory[];
+/** Format the context indicator for injection */
+export declare function formatAttentionContext(context: ActionContext): string;
+//# sourceMappingURL=attention-ranker.d.ts.map

package/dist/memory/attention-ranker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attention-ranker.d.ts","sourceRoot":"","sources":["../../src/memory/attention-ranker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EAAc,YAAY,EAAE,MAAM,UAAU,CAAC;AAEpD,MAAM,MAAM,aAAa,GAAG,WAAW,GAAG,QAAQ,GAAG,WAAW,GAAG,UAAU,GAAG,WAAW,GAAG,SAAS,CAAC;AA4CxG,qDAAqD;AACrD,wBAAgB,mBAAmB,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,aAAa,CAiBvF;AAED,uDAAuD;AACvD,wBAAgB,eAAe,CAC3B,QAAQ,EAAE,YAAY,EAAE,EACxB,OAAO,EAAE,aAAa,GACvB,YAAY,EAAE,CAShB;AAED,iDAAiD;AACjD,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,aAAa,GAAG,MAAM,CAUrE"}

package/dist/memory/attention-ranker.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectActionContext = detectActionContext;
+exports.rankByAttention = rankByAttention;
+exports.formatAttentionContext = formatAttentionContext;
+/**
+ * Attention Ranker — Re-ranks memories based on what you're doing RIGHT NOW.
+ *
+ * Debugging? Bug fixes and corrections rise to the top.
+ * Coding? Conventions and decisions become priority.
+ * Reviewing? Insights and architecture matter most.
+ *
+ * This is like how your brain filters: at a restaurant, food memories are
+ * strong; at a library, book memories are strong. Same data, different priority.
+ */
+const types_1 = require("../types");
+/** Multiplier map: action → memory type → boost factor */
+const ATTENTION_WEIGHTS = {
+    debugging: {
+        [types_1.MemoryType.BUG_FIX]: 2.0,
+        [types_1.MemoryType.CORRECTION]: 1.8,
+        [types_1.MemoryType.FAILED_SUGGESTION]: 1.5,
+        [types_1.MemoryType.INSIGHT]: 1.2,
+        [types_1.MemoryType.DECISION]: 1.0,
+        [types_1.MemoryType.CONVENTION]: 0.8,
+    },
+    coding: {
+        [types_1.MemoryType.CONVENTION]: 2.0,
+        [types_1.MemoryType.DECISION]: 1.8,
+        [types_1.MemoryType.PROVEN_PATTERN]: 1.5,
+        [types_1.MemoryType.CORRECTION]: 1.3,
+        [types_1.MemoryType.BUG_FIX]: 1.0,
+        [types_1.MemoryType.INSIGHT]: 0.9,
+    },
+    reviewing: {
+        [types_1.MemoryType.INSIGHT]: 2.0,
+        [types_1.MemoryType.DECISION]: 1.5,
+        [types_1.MemoryType.CONVENTION]: 1.3,
+        [types_1.MemoryType.CORRECTION]: 1.2,
+        [types_1.MemoryType.BUG_FIX]: 1.0,
+    },
+    chatting: {
+        // Balanced for general conversation
+        [types_1.MemoryType.DECISION]: 1.3,
+        [types_1.MemoryType.CORRECTION]: 1.3,
+        [types_1.MemoryType.CONVENTION]: 1.2,
+        [types_1.MemoryType.BUG_FIX]: 1.2,
+        [types_1.MemoryType.INSIGHT]: 1.1,
+    },
+    exploring: {
+        [types_1.MemoryType.INSIGHT]: 1.8,
+        [types_1.MemoryType.DEPENDENCY]: 1.5,
+        [types_1.MemoryType.DECISION]: 1.3,
+        [types_1.MemoryType.CONVENTION]: 1.0,
+    },
+    unknown: {}, // No boost — use raw scores
+};
+/** Detect action context from topic/file keywords */
+function detectActionContext(topic, currentFile) {
+    const text = `${topic || ''} ${currentFile || ''}`.toLowerCase();
+    if (/\b(bug|fix|error|crash|fail|debug|issue|broken|not working)\b/.test(text)) {
+        return 'debugging';
+    }
+    if (/\b(implement|build|add|create|feature|code|function|class)\b/.test(text)) {
+        return 'coding';
+    }
+    if (/\b(review|check|audit|examine|look at|analyze)\b/.test(text)) {
+        return 'reviewing';
+    }
+    if (/\b(explore|understand|how|what|why|explain|learn)\b/.test(text)) {
+        return 'exploring';
+    }
+    return 'chatting'; // default
+}
+/** Re-rank memories based on current action context */
+function rankByAttention(memories, context) {
+    const weights = ATTENTION_WEIGHTS[context];
+    return memories
+        .map(m => ({
+        ...m,
+        score: m.score * (weights[m.memory.type] || 1.0),
+    }))
+        .sort((a, b) => b.score - a.score);
+}
+/** Format the context indicator for injection */
+function formatAttentionContext(context) {
+    const labels = {
+        debugging: '[DEBUG] Debug mode -- bug fixes and corrections prioritized',
+        coding: '[CODE] Coding mode -- conventions and decisions prioritized',
+        reviewing: '[REVIEW] Review mode -- insights and architecture prioritized',
+        chatting: '[CHAT] Chat mode -- balanced context',
+        exploring: '[EXPLORE] Explore mode -- insights and stack info prioritized',
+        unknown: '',
+    };
+    return labels[context];
+}
+//# sourceMappingURL=attention-ranker.js.map

package/dist/memory/attention-ranker.js.map

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

package/dist/memory/auto-learner.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Auto-Learner — Extracts memory-worthy patterns from text automatically.
+ *
+ * How it works:
+ * 1. The AI passes its response text to `auto_learn` tool after every reply
+ * 2. This module scans for decision/correction/convention/bug-fix patterns
+ * 3. Matching patterns are stored automatically — zero manual effort
+ *
+ * Pattern detection uses keyword signals + sentence structure analysis.
+ * No LLM needed — pure regex + heuristics, fast and reliable.
+ */
+export type MemoryType = 'DECISION' | 'CORRECTION' | 'CONVENTION' | 'BUG_FIX' | 'INSIGHT' | 'FAILED_ATTEMPT' | 'BUSINESS_RULE' | 'GOTCHA' | 'CURRENT_TASK';
+export interface ExtractedMemory {
+    type: MemoryType;
+    content: string;
+    confidence: number;
+    reason: string;
+}
+export declare function extractMemories(text: string): ExtractedMemory[];
+//# sourceMappingURL=auto-learner.d.ts.map

package/dist/memory/auto-learner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auto-learner.d.ts","sourceRoot":"","sources":["../../src/memory/auto-learner.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,MAAM,MAAM,UAAU,GAAG,UAAU,GAAG,YAAY,GAAG,YAAY,GAAG,SAAS,GAAG,SAAS,GACnF,gBAAgB,GAAG,eAAe,GAAG,QAAQ,GAAG,cAAc,CAAC;AAErE,MAAM,WAAW,eAAe;IAC5B,IAAI,EAAE,UAAU,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;CAClB;AAiJD,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,eAAe,EAAE,CA8C/D"}

package/dist/memory/auto-learner.js

@@ -0,0 +1,179 @@
+"use strict";
+/**
+ * Auto-Learner — Extracts memory-worthy patterns from text automatically.
+ *
+ * How it works:
+ * 1. The AI passes its response text to `auto_learn` tool after every reply
+ * 2. This module scans for decision/correction/convention/bug-fix patterns
+ * 3. Matching patterns are stored automatically — zero manual effort
+ *
+ * Pattern detection uses keyword signals + sentence structure analysis.
+ * No LLM needed — pure regex + heuristics, fast and reliable.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractMemories = extractMemories;
+// ─── Signal Patterns ──────────────────────────────────────────────────────────
+const PATTERNS = [
+    // CORRECTION — "don't use X", "never do Y", "avoid Z", "wrong approach"
+    {
+        type: 'CORRECTION',
+        signals: [
+            /\b(don'?t|do not|never|avoid|stop using|instead of|rather than)\b.{5,80}/gi,
+            /\b(wrong|incorrect|mistake|bug|error|issue|problem)\b.{5,60}(fix|correct|should|use|replace)/gi,
+            /\b(fixed|corrected|resolved)\b.{5,60}/gi,
+        ],
+        confidence: 0.75,
+        reason: 'Auto-detected correction pattern',
+    },
+    // DECISION — "we decided", "we'll use", "going with", "chosen"
+    {
+        type: 'DECISION',
+        signals: [
+            /\b(we('ll| will| are going to| decided to)?)\s+(use|adopt|switch|go with|choose|pick|implement)\b.{5,80}/gi,
+            /\b(decided|chosen|selected|picked|going with|sticking with)\b.{5,80}/gi,
+            /\b(use|using)\s+\w+\s+(instead of|over|rather than)\s+\w+/gi,
+        ],
+        confidence: 0.70,
+        reason: 'Auto-detected decision pattern',
+    },
+    // CONVENTION — "always", "should always", "must", "standard", "convention"
+    {
+        type: 'CONVENTION',
+        signals: [
+            /\b(always|must|should always|make sure to|remember to|convention|standard|rule)\b.{5,80}/gi,
+            /\b(format|naming|style|pattern|structure)\b.{5,60}(should|must|always|use)/gi,
+            /\b(use\s+\w+\s+for\s+all|every\s+\w+\s+should|all\s+\w+\s+must)\b.{5,60}/gi,
+        ],
+        confidence: 0.65,
+        reason: 'Auto-detected convention pattern',
+    },
+    // BUG_FIX — "the bug was", "root cause", "the fix is", "was causing"
+    {
+        type: 'BUG_FIX',
+        signals: [
+            /\b(bug|the (issue|problem|cause) was|root cause|was causing|the fix)\b.{5,80}/gi,
+            /\b(fixed by|resolved by|the solution (is|was))\b.{5,80}/gi,
+            /\b(crash|exception|error|fail(ed|ure)?)\b.{5,60}(because|due to|caused by|fixed)/gi,
+        ],
+        confidence: 0.80,
+        reason: 'Auto-detected bug fix pattern',
+    },
+    // INSIGHT — "key insight", "important to note", "worth remembering"
+    {
+        type: 'INSIGHT',
+        signals: [
+            /\b(key insight|important(ly)?|worth (noting|remembering)|note that|keep in mind)\b.{5,80}/gi,
+            /\b(the reason (is|why)|this (works|happens) because)\b.{5,80}/gi,
+        ],
+        confidence: 0.55,
+        reason: 'Auto-detected insight pattern',
+    },
+    // ─── NEW PATTERNS ─────────────────────────────────────────────────
+    // FAILED_ATTEMPT — "didn't work", "tried X but", "doesn't solve", "abandoned"
+    {
+        type: 'FAILED_ATTEMPT',
+        signals: [
+            /\b(didn'?t work|does(n'?t| not) work|failed|not working|broken)\b.{5,80}/gi,
+            /\btried\b.{3,60}\b(but|however|didn'?t|failed|abandoned|gave up)\b/gi,
+            /\b(abandoned|scrapped|reverted|rolled back|gave up on)\b.{5,80}/gi,
+            /\b(doesn'?t solve|won'?t fix|not the (right|correct) approach)\b.{5,80}/gi,
+        ],
+        confidence: 0.75,
+        reason: 'Auto-detected failed attempt — prevents repeating dead ends',
+    },
+    // BUSINESS_RULE — "users can", "admins have", "when X then Y", domain logic
+    {
+        type: 'BUSINESS_RULE',
+        signals: [
+            /\b(users?|admins?|editors?|viewers?|customers?|clients?|members?)\s+(can|cannot|must|should|have|are allowed|are not allowed)\b.{5,80}/gi,
+            /\b(role|permission|access|authorization)\b.{5,60}\b(admin|editor|viewer|owner|manager|user)\b/gi,
+            /\bwhen\s+.{5,40}\s+(then|must|should|always|never)\b.{5,60}/gi,
+            /\b(business rule|domain rule|requirement|constraint)\b.{3,80}/gi,
+            /\b(only\s+(admins?|owners?|managers?)\s+can)\b.{5,60}/gi,
+        ],
+        confidence: 0.70,
+        reason: 'Auto-detected business rule / domain logic',
+    },
+    // GOTCHA — "be careful", "watch out", "NEVER do X on Y", "dangerous"
+    {
+        type: 'GOTCHA',
+        signals: [
+            /\b(be careful|watch out|careful with|danger(ous)?|warning|caution)\b.{5,80}/gi,
+            /\bNEVER\b.{5,80}/g, // uppercase NEVER = strong warning
+            /\b(will (break|crash|delete|corrupt|destroy))\b.{5,60}/gi,
+            /\b(cascad(e|ing) delete|data loss|side effect|race condition)\b.{5,60}/gi,
+            /\b(gotcha|pitfall|trap|footgun|sharp edge)\b.{5,60}/gi,
+        ],
+        confidence: 0.80,
+        reason: 'Auto-detected gotcha/warning — prevents dangerous operations',
+    },
+    // CURRENT_TASK — "working on", "current priority", "this week", "next step"
+    {
+        type: 'CURRENT_TASK',
+        signals: [
+            /\b(working on|building|implementing|focusing on)\b.{5,80}/gi,
+            /\b(current(ly)?|right now|this (week|sprint|phase))\b.{5,60}\b(priority|focus|task|goal)\b/gi,
+            /\b(priority is|main (goal|task|focus) is)\b.{5,80}/gi,
+            /\b(next step|todo|to-do|need to (build|implement|fix|add))\b.{5,80}/gi,
+        ],
+        confidence: 0.60,
+        reason: 'Auto-detected current task / priority',
+    },
+];
+// ─── Sentence Splitter ────────────────────────────────────────────────────────
+function splitSentences(text) {
+    // Split on sentence boundaries, keeping reasonable length
+    return text
+        .replace(/\n+/g, ' ')
+        .split(/(?<=[.!?])\s+/)
+        .map(s => s.trim())
+        .filter(s => s.length > 20 && s.length < 300);
+}
+// ─── Dedup Filter ─────────────────────────────────────────────────────────────
+function normalize(text) {
+    return text.toLowerCase().replace(/[^a-z0-9\s]/g, '').replace(/\s+/g, ' ').trim();
+}
+// ─── Main Extractor ───────────────────────────────────────────────────────────
+function extractMemories(text) {
+    if (!text || text.length < 30)
+        return [];
+    const sentences = splitSentences(text);
+    const results = [];
+    const seen = new Set();
+    for (const sentence of sentences) {
+        for (const pattern of PATTERNS) {
+            let matched = false;
+            for (const signal of pattern.signals) {
+                signal.lastIndex = 0; // reset regex state
+                if (signal.test(sentence)) {
+                    matched = true;
+                    break;
+                }
+            }
+            if (!matched)
+                continue;
+            // Clean up the sentence for storage
+            const content = sentence
+                .replace(/^(so|and|but|also|note that|remember that|keep in mind that)\s+/i, '')
+                .replace(/\s+/g, ' ')
+                .trim();
+            if (content.length < 15)
+                continue;
+            // Dedup by normalized content
+            const key = `${pattern.type}:${normalize(content).slice(0, 60)}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            results.push({
+                type: pattern.type,
+                content,
+                confidence: pattern.confidence,
+                reason: pattern.reason,
+            });
+            break; // One match per sentence is enough
+        }
+    }
+    // Return only high-confidence matches (avoid noise)
+    return results.filter(r => r.confidence >= 0.55);
+}
+//# sourceMappingURL=auto-learner.js.map

package/dist/memory/auto-learner.js.map

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

package/dist/memory/confidence-decay.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Confidence Decay + Reinforcement — Time-based memory aging.
+ *
+ * Memories that are never accessed gradually lose importance.
+ * Memories that are frequently accessed get stronger.
+ *
+ * Like how the brain strengthens neural pathways that are used often
+ * and prunes connections that are never activated.
+ *
+ * Formula: effective_importance = base_importance * decay_factor * access_boost
+ * - decay_factor = 1 / (1 + age_in_days * 0.02) — slow exponential decay
+ * - access_boost = 1 + (accessCount * 0.1) — capped at 2x
+ */
+import { MemoryStore } from '../db/memory-store';
+import { ScoredMemory } from '../types';
+/** Calculate effective importance with decay and reinforcement */
+export declare function effectiveImportance(baseImportance: number, timestamp: number, accessCount: number, lastAccessed?: number): number;
+/** Apply decay + reinforcement scoring to search results */
+export declare function applyConfidenceDecay(memories: ScoredMemory[]): ScoredMemory[];
+/** Run periodic maintenance — decay old, unused memories */
+export declare function runDecayMaintenance(memoryStore: MemoryStore): number;
+//# sourceMappingURL=confidence-decay.d.ts.map

package/dist/memory/confidence-decay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"confidence-decay.d.ts","sourceRoot":"","sources":["../../src/memory/confidence-decay.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAOxC,kEAAkE;AAClE,wBAAgB,mBAAmB,CAC/B,cAAc,EAAE,MAAM,EACtB,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,MAAM,EACnB,YAAY,CAAC,EAAE,MAAM,GACtB,MAAM,CAmBR;AAED,4DAA4D;AAC5D,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,YAAY,EAAE,GAAG,YAAY,EAAE,CAc7E;AAED,4DAA4D;AAC5D,wBAAgB,mBAAmB,CAAC,WAAW,EAAE,WAAW,GAAG,MAAM,CAqBpE"}

package/dist/memory/confidence-decay.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.effectiveImportance = effectiveImportance;
+exports.applyConfidenceDecay = applyConfidenceDecay;
+exports.runDecayMaintenance = runDecayMaintenance;
+const DECAY_RATE = 0.02; // 2% per day
+const ACCESS_BOOST_RATE = 0.1; // 10% per access
+const MAX_ACCESS_BOOST = 2.0;
+const MIN_IMPORTANCE = 0.1; // Never fully forget
+/** Calculate effective importance with decay and reinforcement */
+function effectiveImportance(baseImportance, timestamp, accessCount, lastAccessed) {
+    const ageInDays = (Date.now() - timestamp) / 86400000;
+    // Decay: older memories lose importance (but slowly)
+    const decayFactor = 1 / (1 + ageInDays * DECAY_RATE);
+    // Reinforcement: frequently accessed memories get stronger
+    const accessBoost = Math.min(MAX_ACCESS_BOOST, 1 + (accessCount * ACCESS_BOOST_RATE));
+    // Recent access counteracts decay
+    let recencyBoost = 1.0;
+    if (lastAccessed) {
+        const daysSinceAccess = (Date.now() - lastAccessed) / 86400000;
+        if (daysSinceAccess < 1)
+            recencyBoost = 1.3; // accessed today
+        else if (daysSinceAccess < 7)
+            recencyBoost = 1.1; // accessed this week
+    }
+    const effective = baseImportance * decayFactor * accessBoost * recencyBoost;
+    return Math.max(MIN_IMPORTANCE, Math.min(1.0, effective));
+}
+/** Apply decay + reinforcement scoring to search results */
+function applyConfidenceDecay(memories) {
+    return memories.map(m => {
+        const boost = effectiveImportance(m.memory.importance, m.memory.timestamp, m.memory.accessCount, m.memory.lastAccessed);
+        return {
+            ...m,
+            score: m.score * boost,
+        };
+    }).sort((a, b) => b.score - a.score);
+}
+/** Run periodic maintenance — decay old, unused memories */
+function runDecayMaintenance(memoryStore) {
+    const active = memoryStore.getActive(500);
+    let decayed = 0;
+    for (const m of active) {
+        const current = m.importance;
+        const effective = effectiveImportance(current, m.timestamp, m.accessCount, m.lastAccessed);
+        // Only update if significant change (>5% difference)
+        if (Math.abs(current - effective) > 0.05) {
+            memoryStore.update(m.id, { importance: effective });
+            decayed++;
+        }
+    }
+    return decayed;
+}
+//# sourceMappingURL=confidence-decay.js.map

package/dist/memory/confidence-decay.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"confidence-decay.js","sourceRoot":"","sources":["../../src/memory/confidence-decay.ts"],"names":[],"mappings":";;AAsBA,kDAwBC;AAGD,oDAcC;AAGD,kDAqBC;AAvED,MAAM,UAAU,GAAG,IAAI,CAAC,CAAC,aAAa;AACtC,MAAM,iBAAiB,GAAG,GAAG,CAAC,CAAC,iBAAiB;AAChD,MAAM,gBAAgB,GAAG,GAAG,CAAC;AAC7B,MAAM,cAAc,GAAG,GAAG,CAAC,CAAC,qBAAqB;AAEjD,kEAAkE;AAClE,SAAgB,mBAAmB,CAC/B,cAAsB,EACtB,SAAiB,EACjB,WAAmB,EACnB,YAAqB;IAErB,MAAM,SAAS,GAAG,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,SAAS,CAAC,GAAG,QAAQ,CAAC;IAEtD,qDAAqD;IACrD,MAAM,WAAW,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,SAAS,GAAG,UAAU,CAAC,CAAC;IAErD,2DAA2D;IAC3D,MAAM,WAAW,GAAG,IAAI,CAAC,GAAG,CAAC,gBAAgB,EAAE,CAAC,GAAG,CAAC,WAAW,GAAG,iBAAiB,CAAC,CAAC,CAAC;IAEtF,kCAAkC;IAClC,IAAI,YAAY,GAAG,GAAG,CAAC;IACvB,IAAI,YAAY,EAAE,CAAC;QACf,MAAM,eAAe,GAAG,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,YAAY,CAAC,GAAG,QAAQ,CAAC;QAC/D,IAAI,eAAe,GAAG,CAAC;YAAE,YAAY,GAAG,GAAG,CAAC,CAAC,iBAAiB;aACzD,IAAI,eAAe,GAAG,CAAC;YAAE,YAAY,GAAG,GAAG,CAAC,CAAC,qBAAqB;IAC3E,CAAC;IAED,MAAM,SAAS,GAAG,cAAc,GAAG,WAAW,GAAG,WAAW,GAAG,YAAY,CAAC;IAC5E,OAAO,IAAI,CAAC,GAAG,CAAC,cAAc,EAAE,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,SAAS,CAAC,CAAC,CAAC;AAC9D,CAAC;AAED,4DAA4D;AAC5D,SAAgB,oBAAoB,CAAC,QAAwB;IACzD,OAAO,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE;QACpB,MAAM,KAAK,GAAG,mBAAmB,CAC7B,CAAC,CAAC,MAAM,CAAC,UAAU,EACnB,CAAC,CAAC,MAAM,CAAC,SAAS,EAClB,CAAC,CAAC,MAAM,CAAC,WAAW,EACpB,CAAC,CAAC,MAAM,CAAC,YAAY,CACxB,CAAC;QAEF,OAAO;YACH,GAAG,CAAC;YACJ,KAAK,EAAE,CAAC,CAAC,KAAK,GAAG,KAAK;SACzB,CAAC;IACN,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC;AACzC,CAAC;AAED,4DAA4D;AAC5D,SAAgB,mBAAmB,CAAC,WAAwB;IACxD,MAAM,MAAM,GAAG,WAAW,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;IAC1C,IAAI,OAAO,GAAG,CAAC,CAAC;IAEhB,KAAK,MAAM,CAAC,IAAI,MAAM,EAAE,CAAC;QACrB,MAAM,OAAO,GAAG,CAAC,CAAC,UAAU,CAAC;QAC7B,MAAM,SAAS,GAAG,mBAAmB,CACjC,OAAO,EACP,CAAC,CAAC,SAAS,EACX,CAAC,CAAC,WAAW,EACb,CAAC,CAAC,YAAY,CACjB,CAAC;QAEF,qDAAqD;QACrD,IAAI,IAAI,CAAC,GAAG,CAAC,OAAO,GAAG,SAAS,CAAC,GAAG,IAAI,EAAE,CAAC;YACvC,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,UAAU,EAAE,SAAS,EAAE,CAAC,CAAC;YACpD,OAAO,EAAE,CAAC;QACd,CAAC;IACL,CAAC;IAED,OAAO,OAAO,CAAC;AACnB,CAAC"}

package/dist/memory/embedding-manager.d.ts

@@ -0,0 +1,5 @@
+export declare function startEmbeddingWorker(): void;
+export declare function embedText(text: string): Promise<number[]>;
+export declare function isWorkerReady(): boolean;
+export declare function terminateWorker(): void;
+//# sourceMappingURL=embedding-manager.d.ts.map

package/dist/memory/embedding-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"embedding-manager.d.ts","sourceRoot":"","sources":["../../src/memory/embedding-manager.ts"],"names":[],"mappings":"AAaA,wBAAgB,oBAAoB,IAAI,IAAI,CA6B3C;AAED,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAiBzD;AAED,wBAAgB,aAAa,IAAI,OAAO,CAEvC;AAED,wBAAgB,eAAe,IAAI,IAAI,CAMtC"}