@gsep/core 0.8.0

package/dist/interfaces/StorageAdapter.d.ts

@@ -0,0 +1,82 @@
+import type { Genome, UserDNA, MutationLog, GeneRegistryEntry } from '../types/index.js';
+import type { SemanticFact } from '../memory/LayeredMemory.js';
+export interface StorageAdapter {
+    initialize(): Promise<void>;
+    saveGenome(genome: Genome): Promise<void>;
+    loadGenome(genomeId: string): Promise<Genome | null>;
+    deleteGenome(genomeId: string): Promise<void>;
+    listGenomes(): Promise<Genome[]>;
+    saveDNA(userId: string, genomeId: string, dna: UserDNA): Promise<void>;
+    loadDNA(userId: string, genomeId: string): Promise<UserDNA | null>;
+    logMutation(mutation: MutationLog): Promise<void>;
+    getMutationHistory(genomeId: string, limit?: number): Promise<MutationLog[]>;
+    getGeneMutationHistory(genomeId: string, gene: string, limit?: number): Promise<MutationLog[]>;
+    recordInteraction(interaction: {
+        genomeId: string;
+        userId: string;
+        userMessage: string;
+        assistantResponse: string;
+        toolCalls: unknown[];
+        score?: number;
+        timestamp: Date;
+    }): Promise<void>;
+    getRecentInteractions(genomeId: string, userId: string, limit?: number): Promise<unknown[]>;
+    recordFeedback(feedback: {
+        genomeId: string;
+        userId: string;
+        gene: string;
+        sentiment: 'positive' | 'negative' | 'neutral';
+        timestamp: Date;
+    }): Promise<void>;
+    getAnalytics(genomeId: string): Promise<{
+        totalMutations: number;
+        totalInteractions: number;
+        avgFitnessImprovement: number;
+        userSatisfaction: number;
+        topGenes: Array<{
+            gene: string;
+            fitness: number;
+        }>;
+    }>;
+    saveFact(fact: SemanticFact, userId: string, genomeId: string): Promise<void>;
+    getFacts(userId: string, genomeId: string, includeExpired?: boolean): Promise<SemanticFact[]>;
+    getFact(factId: string): Promise<SemanticFact | null>;
+    updateFact(factId: string, updates: Partial<SemanticFact>): Promise<void>;
+    deleteFact(factId: string): Promise<void>;
+    deleteUserFacts(userId: string, genomeId: string): Promise<void>;
+    cleanExpiredFacts(userId: string, genomeId: string): Promise<number>;
+    saveToGeneRegistry?(entry: GeneRegistryEntry): Promise<void>;
+    queryGeneRegistry?(familyId: string, gene?: string, minFitness?: number): Promise<GeneRegistryEntry[]>;
+    getBestRegistryGene?(familyId: string, gene: string): Promise<GeneRegistryEntry | null>;
+    saveCalibrationPoint?(point: {
+        contextKey: string;
+        layer?: 0 | 1 | 2;
+        operator?: string;
+        taskType?: string;
+        threshold: number;
+        totalCandidates: number;
+        passedSandbox: number;
+        deployedSuccessfully: number;
+        rolledBack: number;
+        falsePositiveRate: number;
+        falseNegativeRate: number;
+        optimalThreshold: number;
+        timestamp: Date;
+    }): Promise<void>;
+    getCalibrationHistory?(contextKey: string, limit?: number): Promise<Array<{
+        contextKey: string;
+        layer?: number;
+        operator?: string;
+        taskType?: string;
+        threshold: number;
+        totalCandidates: number;
+        passedSandbox: number;
+        deployedSuccessfully: number;
+        rolledBack: number;
+        falsePositiveRate: number;
+        falseNegativeRate: number;
+        optimalThreshold: number;
+        timestamp: Date;
+    }>>;
+}
+//# sourceMappingURL=StorageAdapter.d.ts.map

package/dist/interfaces/StorageAdapter.d.ts.map

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

package/dist/interfaces/StorageAdapter.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=StorageAdapter.js.map

package/dist/interfaces/StorageAdapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"StorageAdapter.js","sourceRoot":"","sources":["../../src/interfaces/StorageAdapter.ts"],"names":[],"mappings":""}

package/dist/memory/AnalyticMemoryEngine.d.ts

@@ -0,0 +1,106 @@
+export interface Entity {
+    id: string;
+    type: 'user' | 'tool' | 'concept' | 'project' | 'skill' | 'preference';
+    name: string;
+    attributes: Record<string, unknown>;
+    confidence: number;
+    firstSeen: Date;
+    lastSeen: Date;
+    mentionCount: number;
+}
+export interface Relation {
+    id: string;
+    from: string;
+    to: string;
+    type: RelationType;
+    weight: number;
+    evidence: string;
+    confidence: number;
+    createdAt: Date;
+}
+export type RelationType = 'prefers' | 'uses' | 'works-on' | 'skilled-in' | 'related-to' | 'requires' | 'follows' | 'implies' | 'part-of';
+export interface Inference {
+    conclusion: string;
+    basis: string[];
+    confidence: number;
+    createdAt: Date;
+}
+export interface MemoryQueryResult {
+    entities: Entity[];
+    relations: Relation[];
+    inferences: Inference[];
+    relevanceScore: number;
+}
+export interface TemporalPattern {
+    id: string;
+    description: string;
+    dayOfWeek?: number;
+    hourOfDay?: number;
+    frequency: number;
+    confidence: number;
+    prediction?: string;
+}
+export interface KnowledgeSummary {
+    topEntities: Array<{
+        name: string;
+        type: Entity['type'];
+        mentionCount: number;
+        recency: 'recent' | 'month' | 'historical';
+    }>;
+    topRelations: Array<{
+        from: string;
+        to: string;
+        type: RelationType;
+        weight: number;
+    }>;
+    topInferences: Array<{
+        conclusion: string;
+        confidence: number;
+    }>;
+    interactionPatterns: string[];
+    summary: string;
+}
+export declare class AnalyticMemoryEngine {
+    private entities;
+    private relations;
+    private inferences;
+    private temporalPatterns;
+    private observationLog;
+    recordObservation(observation: {
+        subject: string;
+        action: string;
+        object?: string;
+        context?: Record<string, unknown>;
+        timestamp?: Date;
+    }): void;
+    recordFact(fact: {
+        subject: string;
+        predicate: string;
+        value: string;
+        confidence?: number;
+    }): void;
+    query(question: string): MemoryQueryResult;
+    detectTemporalPatterns(): TemporalPattern[];
+    predict(context: {
+        dayOfWeek?: number;
+        currentTopic?: string;
+    }): Array<{
+        prediction: string;
+        confidence: number;
+    }>;
+    getEntities(): Entity[];
+    getRelations(): Relation[];
+    getInferences(): Inference[];
+    toPromptSection(currentTopic?: string): string | null;
+    getKnowledgeSummary(userId?: string): KnowledgeSummary;
+    private upsertEntity;
+    private addRelation;
+    private inferRelations;
+    private getRelatedEntities;
+    private classifyEntityType;
+    private actionToRelation;
+    private predicateToRelation;
+    private computeEffectiveConfidence;
+    private getRecencyLabel;
+}
+//# sourceMappingURL=AnalyticMemoryEngine.d.ts.map

package/dist/memory/AnalyticMemoryEngine.d.ts.map

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

package/dist/memory/AnalyticMemoryEngine.js

@@ -0,0 +1,440 @@
+const MAX_ENTITIES = 200;
+const MAX_RELATIONS = 500;
+const MAX_INFERENCES = 100;
+const MIN_CONFIDENCE_FOR_INFERENCE = 0.4;
+const HALF_LIFE_DAYS = 30;
+const DOMAIN_IMPLICATIONS = {
+    'fintech': [
+        { entity: 'security', relation: 'implies', confidence: 0.85 },
+        { entity: 'compliance', relation: 'implies', confidence: 0.80 },
+        { entity: 'precision', relation: 'implies', confidence: 0.75 },
+    ],
+    'healthcare': [
+        { entity: 'privacy', relation: 'implies', confidence: 0.90 },
+        { entity: 'compliance', relation: 'implies', confidence: 0.85 },
+    ],
+    'devops': [
+        { entity: 'automation', relation: 'implies', confidence: 0.80 },
+        { entity: 'monitoring', relation: 'implies', confidence: 0.75 },
+    ],
+    'frontend': [
+        { entity: 'accessibility', relation: 'implies', confidence: 0.65 },
+        { entity: 'responsive-design', relation: 'implies', confidence: 0.70 },
+    ],
+};
+export class AnalyticMemoryEngine {
+    entities = new Map();
+    relations = [];
+    inferences = [];
+    temporalPatterns = [];
+    observationLog = [];
+    recordObservation(observation) {
+        const ts = observation.timestamp ?? new Date();
+        this.upsertEntity({
+            id: observation.subject,
+            type: this.classifyEntityType(observation.subject),
+            name: observation.subject,
+        });
+        if (observation.object) {
+            this.upsertEntity({
+                id: observation.object,
+                type: this.classifyEntityType(observation.object),
+                name: observation.object,
+            });
+            const relationType = this.actionToRelation(observation.action);
+            this.addRelation(observation.subject, observation.object, relationType, observation.action);
+        }
+        this.observationLog.push({ action: observation.action, timestamp: ts });
+        if (this.observationLog.length > 500) {
+            this.observationLog = this.observationLog.slice(-250);
+        }
+        if (this.entities.size % 5 === 0) {
+            this.inferRelations();
+        }
+    }
+    recordFact(fact) {
+        const entity = this.upsertEntity({
+            id: fact.subject,
+            type: this.classifyEntityType(fact.subject),
+            name: fact.subject,
+        });
+        entity.attributes[fact.predicate] = fact.value;
+        const valueEntity = this.upsertEntity({
+            id: fact.value.toLowerCase().replace(/\s+/g, '-'),
+            type: this.classifyEntityType(fact.value),
+            name: fact.value,
+        });
+        const relationType = this.predicateToRelation(fact.predicate);
+        this.addRelation(entity.id, valueEntity.id, relationType, `${fact.subject} ${fact.predicate} ${fact.value}`, fact.confidence);
+    }
+    query(question) {
+        const lower = question.toLowerCase();
+        const tokens = lower.split(/\s+/);
+        const matchingEntities = [];
+        for (const entity of this.entities.values()) {
+            const nameMatch = tokens.some(t => entity.name.toLowerCase().includes(t) || t.includes(entity.name.toLowerCase()));
+            const attrMatch = Object.values(entity.attributes).some(v => typeof v === 'string' && tokens.some(t => v.toLowerCase().includes(t)));
+            if (nameMatch || attrMatch) {
+                matchingEntities.push({
+                    ...entity,
+                    attributes: { ...entity.attributes },
+                    confidence: this.computeEffectiveConfidence(entity.confidence, entity.lastSeen),
+                });
+            }
+        }
+        const entityIds = new Set(matchingEntities.map(e => e.id));
+        const matchingRelations = this.relations.filter(r => entityIds.has(r.from) || entityIds.has(r.to));
+        const matchingInferences = this.inferences.filter(inf => tokens.some(t => inf.conclusion.toLowerCase().includes(t)));
+        const relevanceScore = matchingEntities.length > 0
+            ? Math.min(1, (matchingEntities.length * 0.3 + matchingRelations.length * 0.2) / 3)
+            : 0;
+        return {
+            entities: matchingEntities,
+            relations: matchingRelations,
+            inferences: matchingInferences,
+            relevanceScore,
+        };
+    }
+    detectTemporalPatterns() {
+        const dayFrequency = new Map();
+        for (const obs of this.observationLog) {
+            const day = obs.timestamp.getDay();
+            if (!dayFrequency.has(obs.action)) {
+                dayFrequency.set(obs.action, new Map());
+            }
+            const counts = dayFrequency.get(obs.action);
+            counts.set(day, (counts.get(day) || 0) + 1);
+        }
+        const patterns = [];
+        for (const [action, dayCounts] of dayFrequency) {
+            const entries = Array.from(dayCounts.entries());
+            const totalOccurrences = entries.reduce((sum, [, c]) => sum + c, 0);
+            if (totalOccurrences < 3)
+                continue;
+            const [peakDay, peakCount] = entries.sort((a, b) => b[1] - a[1])[0];
+            const confidence = peakCount / totalOccurrences;
+            if (confidence >= 0.4) {
+                const dayNames = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
+                patterns.push({
+                    id: `temporal_${action}_${peakDay}`,
+                    description: `${action} tends to happen on ${dayNames[peakDay]}`,
+                    dayOfWeek: peakDay,
+                    frequency: peakCount,
+                    confidence,
+                    prediction: `User may need help with ${action} on ${dayNames[peakDay]}`,
+                });
+            }
+        }
+        this.temporalPatterns = patterns;
+        return patterns;
+    }
+    predict(context) {
+        const predictions = [];
+        if (context.dayOfWeek !== undefined) {
+            for (const pattern of this.temporalPatterns) {
+                if (pattern.dayOfWeek === context.dayOfWeek && pattern.prediction) {
+                    predictions.push({
+                        prediction: pattern.prediction,
+                        confidence: pattern.confidence,
+                    });
+                }
+            }
+        }
+        if (context.currentTopic) {
+            const relatedEntities = this.getRelatedEntities(context.currentTopic);
+            for (const { entity, relation } of relatedEntities) {
+                if (relation.type === 'follows') {
+                    predictions.push({
+                        prediction: `Based on history, ${entity.name} typically follows ${context.currentTopic}`,
+                        confidence: relation.confidence,
+                    });
+                }
+            }
+        }
+        return predictions.sort((a, b) => b.confidence - a.confidence);
+    }
+    getEntities() {
+        return Array.from(this.entities.values());
+    }
+    getRelations() {
+        return [...this.relations];
+    }
+    getInferences() {
+        return [...this.inferences];
+    }
+    toPromptSection(currentTopic) {
+        if (this.entities.size === 0 && this.inferences.length === 0) {
+            return null;
+        }
+        const lines = ['## Knowledge Context'];
+        const relevantEntities = currentTopic
+            ? this.getRelatedEntities(currentTopic).map(r => r.entity)
+            : Array.from(this.entities.values()).sort((a, b) => b.mentionCount - a.mentionCount).slice(0, 5);
+        if (relevantEntities.length > 0) {
+            lines.push('**Known facts:**');
+            for (const entity of relevantEntities.slice(0, 5)) {
+                const recencyLabel = this.getRecencyLabel(entity.lastSeen);
+                const attrs = Object.entries(entity.attributes)
+                    .map(([k, v]) => `${k}=${String(v)}`)
+                    .join(', ');
+                lines.push(`- ${entity.name} (${recencyLabel}): ${attrs || entity.type}`);
+            }
+        }
+        const activeInferences = this.inferences.filter(i => i.confidence >= 0.6);
+        if (activeInferences.length > 0) {
+            lines.push('**Inferences:**');
+            for (const inf of activeInferences.slice(0, 3)) {
+                lines.push(`- ${inf.conclusion} (confidence: ${(inf.confidence * 100).toFixed(0)}%)`);
+            }
+        }
+        const predictions = this.predict({
+            dayOfWeek: new Date().getDay(),
+            currentTopic,
+        });
+        if (predictions.length > 0) {
+            lines.push('**Predictions:**');
+            for (const pred of predictions.slice(0, 2)) {
+                lines.push(`- ${pred.prediction}`);
+            }
+        }
+        return lines.length > 1 ? lines.join('\n') : null;
+    }
+    getKnowledgeSummary(userId) {
+        const entitiesWithDecay = Array.from(this.entities.values())
+            .filter(e => !userId || e.id !== userId)
+            .map(e => ({
+            ...e,
+            effectiveConfidence: this.computeEffectiveConfidence(e.confidence, e.lastSeen),
+            recency: this.getRecencyLabel(e.lastSeen),
+        }))
+            .sort((a, b) => b.effectiveConfidence * b.mentionCount - a.effectiveConfidence * a.mentionCount);
+        const topEntities = entitiesWithDecay.slice(0, 5).map(e => ({
+            name: e.name,
+            type: e.type,
+            mentionCount: e.mentionCount,
+            recency: e.recency,
+        }));
+        const topRelations = this.relations
+            .sort((a, b) => b.weight - a.weight)
+            .slice(0, 5)
+            .map(r => ({ from: r.from, to: r.to, type: r.type, weight: r.weight }));
+        const topInferences = this.inferences
+            .filter(i => i.confidence >= 0.5)
+            .sort((a, b) => b.confidence - a.confidence)
+            .slice(0, 3)
+            .map(i => ({ conclusion: i.conclusion, confidence: i.confidence }));
+        const interactionPatterns = [];
+        if (this.temporalPatterns.length > 0) {
+            for (const p of this.temporalPatterns.slice(0, 2)) {
+                interactionPatterns.push(p.description);
+            }
+        }
+        const summaryParts = [];
+        const recentEntities = entitiesWithDecay.filter(e => e.recency === 'recent');
+        if (recentEntities.length > 0) {
+            summaryParts.push(`Recently active in: ${recentEntities.slice(0, 3).map(e => e.name).join(', ')}`);
+        }
+        const totalTopics = entitiesWithDecay.filter(e => e.type === 'concept' || e.type === 'tool').length;
+        if (totalTopics > 0) {
+            summaryParts.push(`${totalTopics} known topic${totalTopics > 1 ? 's' : ''}`);
+        }
+        if (topInferences.length > 0) {
+            summaryParts.push(`${topInferences.length} active inference${topInferences.length > 1 ? 's' : ''}`);
+        }
+        return {
+            topEntities,
+            topRelations,
+            topInferences,
+            interactionPatterns,
+            summary: summaryParts.length > 0 ? summaryParts.join('. ') + '.' : '',
+        };
+    }
+    upsertEntity(data) {
+        const existing = this.entities.get(data.id);
+        if (existing) {
+            existing.lastSeen = new Date();
+            existing.mentionCount++;
+            return existing;
+        }
+        const entity = {
+            id: data.id,
+            type: data.type,
+            name: data.name,
+            attributes: {},
+            confidence: 0.7,
+            firstSeen: new Date(),
+            lastSeen: new Date(),
+            mentionCount: 1,
+        };
+        if (this.entities.size >= MAX_ENTITIES) {
+            const sorted = Array.from(this.entities.entries())
+                .sort((a, b) => a[1].mentionCount - b[1].mentionCount);
+            if (sorted.length > 0) {
+                this.entities.delete(sorted[0][0]);
+            }
+        }
+        this.entities.set(data.id, entity);
+        return entity;
+    }
+    addRelation(fromId, toId, type, evidence, confidence) {
+        const existing = this.relations.find(r => r.from === fromId && r.to === toId && r.type === type);
+        if (existing) {
+            existing.weight = Math.min(1, existing.weight + 0.1);
+            existing.confidence = Math.min(1, (existing.confidence + (confidence ?? 0.7)) / 2);
+            return;
+        }
+        if (this.relations.length >= MAX_RELATIONS) {
+            this.relations.sort((a, b) => a.weight - b.weight);
+            this.relations.shift();
+        }
+        this.relations.push({
+            id: `rel_${fromId}_${toId}_${type}`,
+            from: fromId,
+            to: toId,
+            type,
+            weight: 0.5,
+            evidence,
+            confidence: confidence ?? 0.7,
+            createdAt: new Date(),
+        });
+    }
+    inferRelations() {
+        const newInferences = [];
+        for (const entity of this.entities.values()) {
+            const implications = DOMAIN_IMPLICATIONS[entity.name.toLowerCase()];
+            if (!implications)
+                continue;
+            for (const impl of implications) {
+                const impliedEntity = this.upsertEntity({
+                    id: impl.entity,
+                    type: 'concept',
+                    name: impl.entity,
+                });
+                this.addRelation(entity.id, impliedEntity.id, impl.relation, `${entity.name} implies ${impl.entity}`, impl.confidence);
+                newInferences.push({
+                    conclusion: `Since user works in ${entity.name}, ${impl.entity} is likely important`,
+                    basis: [entity.id, impliedEntity.id],
+                    confidence: impl.confidence,
+                    createdAt: new Date(),
+                });
+            }
+        }
+        for (const relAB of this.relations) {
+            if (relAB.confidence < MIN_CONFIDENCE_FOR_INFERENCE)
+                continue;
+            for (const relBC of this.relations) {
+                if (relBC.from !== relAB.to)
+                    continue;
+                if (relBC.confidence < MIN_CONFIDENCE_FOR_INFERENCE)
+                    continue;
+                if (relAB.type !== relBC.type)
+                    continue;
+                if (relAB.from === relBC.to)
+                    continue;
+                const existingAC = this.relations.find(r => r.from === relAB.from && r.to === relBC.to && r.type === relAB.type);
+                if (existingAC)
+                    continue;
+                const inferredConfidence = relAB.confidence * relBC.confidence * 0.8;
+                if (inferredConfidence < MIN_CONFIDENCE_FOR_INFERENCE)
+                    continue;
+                const fromEntity = this.entities.get(relAB.from);
+                const toEntity = this.entities.get(relBC.to);
+                newInferences.push({
+                    conclusion: `${fromEntity?.name || relAB.from} ${relAB.type} ${toEntity?.name || relBC.to} (inferred)`,
+                    basis: [relAB.id, relBC.id],
+                    confidence: inferredConfidence,
+                    createdAt: new Date(),
+                });
+            }
+        }
+        for (const inf of newInferences) {
+            const exists = this.inferences.some(i => i.conclusion === inf.conclusion);
+            if (!exists) {
+                this.inferences.push(inf);
+            }
+        }
+        if (this.inferences.length > MAX_INFERENCES) {
+            this.inferences.sort((a, b) => b.confidence - a.confidence);
+            this.inferences = this.inferences.slice(0, MAX_INFERENCES);
+        }
+    }
+    getRelatedEntities(topic) {
+        const topicLower = topic.toLowerCase();
+        const results = [];
+        let topicEntityId = null;
+        for (const entity of this.entities.values()) {
+            if (entity.name.toLowerCase().includes(topicLower) || topicLower.includes(entity.name.toLowerCase())) {
+                topicEntityId = entity.id;
+                break;
+            }
+        }
+        if (!topicEntityId)
+            return results;
+        for (const relation of this.relations) {
+            if (relation.from === topicEntityId) {
+                const entity = this.entities.get(relation.to);
+                if (entity)
+                    results.push({ entity, relation });
+            }
+            else if (relation.to === topicEntityId) {
+                const entity = this.entities.get(relation.from);
+                if (entity)
+                    results.push({ entity, relation });
+            }
+        }
+        return results.sort((a, b) => b.relation.confidence - a.relation.confidence);
+    }
+    classifyEntityType(name) {
+        const lower = name.toLowerCase();
+        if (lower.startsWith('user') || lower === 'luis')
+            return 'user';
+        if (['python', 'javascript', 'typescript', 'react', 'vue', 'docker', 'kubernetes'].includes(lower))
+            return 'tool';
+        if (['fintech', 'healthcare', 'devops', 'frontend', 'backend'].includes(lower))
+            return 'concept';
+        return 'concept';
+    }
+    actionToRelation(action) {
+        const lower = action.toLowerCase();
+        if (lower.includes('prefer'))
+            return 'prefers';
+        if (lower.includes('use') || lower.includes('uses'))
+            return 'uses';
+        if (lower.includes('work'))
+            return 'works-on';
+        if (lower.includes('skill') || lower.includes('knows'))
+            return 'skilled-in';
+        if (lower.includes('require') || lower.includes('need'))
+            return 'requires';
+        if (lower.includes('follow') || lower.includes('then') || lower.includes('after'))
+            return 'follows';
+        return 'related-to';
+    }
+    predicateToRelation(predicate) {
+        const lower = predicate.toLowerCase();
+        if (lower.includes('prefer'))
+            return 'prefers';
+        if (lower.includes('use'))
+            return 'uses';
+        if (lower.includes('work'))
+            return 'works-on';
+        if (lower.includes('skill') || lower.includes('expert'))
+            return 'skilled-in';
+        if (lower.includes('part') || lower.includes('component'))
+            return 'part-of';
+        return 'related-to';
+    }
+    computeEffectiveConfidence(storedConfidence, lastSeen) {
+        const daysSinceLastSeen = (Date.now() - lastSeen.getTime()) / (1000 * 60 * 60 * 24);
+        return storedConfidence * Math.exp(-daysSinceLastSeen / HALF_LIFE_DAYS);
+    }
+    getRecencyLabel(lastSeen) {
+        const daysSince = (Date.now() - lastSeen.getTime()) / (1000 * 60 * 60 * 24);
+        if (daysSince <= 7)
+            return 'recent';
+        if (daysSince <= 30)
+            return 'month';
+        return 'historical';
+    }
+}
+//# sourceMappingURL=AnalyticMemoryEngine.js.map