noormme 1.2.0 → 1.2.1

package/dist/esm/agentic/improvement/HiveLink.js

@@ -22,62 +22,69 @@ export class HiveLink {
      * Promote high-confidence local knowledge to global "Hive" knowledge.
      * This creates a new, session-agnostic entry or updates an existing global one.
      */
-    async broadcastKnowledge(minConfidence = 0.9) {
-        console.log(`[HiveLink] Broadcasting knowledge with confidence >= ${minConfidence}`);
+    async broadcastKnowledge(options = {}) {
+        const minConfidence = options.minConfidence ?? 0.9;
+        const limit = options.limit ?? 100;
+        const offset = options.offset ?? 0;
+        console.log(`[HiveLink] Broadcasting knowledge (limit=${limit}, offset=${offset}) with confidence >= ${minConfidence}`);
         // Find high-confidence items that are "local" (have a source_session_id)
         const items = (await this.typedDb
             .selectFrom(this.knowledgeTable)
             .selectAll()
             .where('confidence', '>=', minConfidence)
             .where('source_session_id', 'is not', null) // Only local items
+            .limit(limit)
+            .offset(offset)
             .execute());
         let promotedCount = 0;
         for (const item of items) {
-            // Check if a global version already exists
-            const existingGlobal = await this.typedDb
-                .selectFrom(this.knowledgeTable)
-                .selectAll()
-                .where('entity', '=', item.entity)
-                .where('fact', '=', item.fact)
-                .where('source_session_id', 'is', null)
-                .executeTakeFirst();
-            if (existingGlobal) {
-                // Reinforce existing global knowledge
-                // Calculate new confidence: average of existing and new, heavily weighted towards max
-                const newConfidence = Math.min(0.99, Math.max(existingGlobal.confidence, item.confidence) + 0.01);
-                await this.db
-                    .updateTable(this.knowledgeTable)
-                    .set({
-                    confidence: newConfidence,
-                    updated_at: new Date(),
-                })
-                    .where('id', '=', existingGlobal.id)
-                    .execute();
-            }
-            else {
-                // Create new global knowledge
-                const tags = item.tags ? [...item.tags] : [];
-                if (!tags.includes('hive_mind'))
-                    tags.push('hive_mind');
-                await this.db
-                    .insertInto(this.knowledgeTable)
-                    .values({
-                    entity: item.entity,
-                    fact: item.fact,
-                    confidence: item.confidence, // Carry over confidence
-                    source_session_id: null, // Global
-                    tags: JSON.stringify(tags),
-                    metadata: JSON.stringify({
-                        ...item.metadata,
-                        promoted_from: item.id,
-                        promoted_at: new Date(),
-                    }),
-                    created_at: new Date(),
-                    updated_at: new Date(),
-                })
-                    .execute();
-                promotedCount++;
-            }
+            await this.db.transaction().execute(async (trx) => {
+                // Check if a global version already exists
+                const existingGlobal = await trx
+                    .selectFrom(this.knowledgeTable)
+                    .selectAll()
+                    .where('entity', '=', item.entity)
+                    .where('fact', '=', item.fact)
+                    .where('source_session_id', 'is', null)
+                    .forUpdate() // Audit Phase 15: prevent concurrent promotion duplication
+                    .executeTakeFirst();
+                if (existingGlobal) {
+                    // Reinforce existing global knowledge
+                    const newConfidence = Math.min(0.99, Math.max(existingGlobal.confidence, item.confidence) + 0.01);
+                    await trx
+                        .updateTable(this.knowledgeTable)
+                        .set({
+                        confidence: newConfidence,
+                        updated_at: new Date(),
+                    })
+                        .where('id', '=', existingGlobal.id)
+                        .execute();
+                }
+                else {
+                    // Create new global knowledge
+                    const tags = item.tags ? [...item.tags] : [];
+                    if (!tags.includes('hive_mind'))
+                        tags.push('hive_mind');
+                    await trx
+                        .insertInto(this.knowledgeTable)
+                        .values({
+                        entity: item.entity,
+                        fact: item.fact,
+                        confidence: item.confidence,
+                        source_session_id: null,
+                        tags: JSON.stringify(tags),
+                        metadata: JSON.stringify({
+                            ...item.metadata,
+                            promoted_from: item.id,
+                            promoted_at: new Date(),
+                        }),
+                        created_at: new Date(),
+                        updated_at: new Date(),
+                    })
+                        .execute();
+                    promotedCount++;
+                }
+            });
         }
         return promotedCount;
     }
@@ -102,8 +109,8 @@ export class HiveLink {
         return Number(result[0]?.numUpdatedRows ?? 1);
     }
     /**
-     * Propagate high-performing capabilities globally and block known-bad ones.
-     * High-Throughput Refactor: Batch updates and optimized set-based checks.
+     * Propagate high-performing capabilities globally using the "Sovereign Draft" protocol.
+     * Uses Bayesian Convergence and Shadow Promotion to avoid deadlocks.
      */
     async broadcastSkills() {
         if (!this.config.evolution?.enableHiveLink &&
@@ -111,81 +118,96 @@ export class HiveLink {
             console.log('[HiveLink] Skill broadcasting disabled by config.');
             return 0;
         }
-        console.log(`[HiveLink] Broadcasting emergent skills across the Hive (Performance-Aware)...`);
+        console.log(`[HiveLink] Executing Sovereign Draft for emergent skills...`);
         let broadcastCount = 0;
         const capTable = this.config.capabilitiesTable || 'agent_capabilities';
-        await this.db.transaction().execute(async (trx) => {
-            // 1. Resolve Verified Skills with "Survival of the Fittest" logic
-            const verifiedSkills = await this.cortex.capabilities.getCapabilities('verified');
-            for (const skill of verifiedSkills) {
-                const meta = typeof skill.metadata === 'string'
-                    ? JSON.parse(skill.metadata)
-                    : skill.metadata || {};
-                if (meta.broadcasted)
-                    continue;
-                // Check for competing global versions
-                const baseName = meta.mutatedFrom || skill.name;
-                const competitor = await trx
+        // 1. Resolve Verified Skills with Bayesian "Alpha" selection
+        const verifiedSkills = await this.cortex.capabilities.getCapabilities('verified');
+        // Group verified skills by lineage (base tool name)
+        const lineageGroups = new Map();
+        for (const skill of verifiedSkills) {
+            const meta = typeof skill.metadata === 'string' ? JSON.parse(skill.metadata) : (skill.metadata || {});
+            const lineage = meta.lineage || skill.name;
+            if (!lineageGroups.has(lineage))
+                lineageGroups.set(lineage, []);
+            lineageGroups.get(lineage).push({ skill, meta });
+        }
+        for (const [lineage, variants] of lineageGroups.entries()) {
+            // Bayesian Winner Selection
+            // Score = (anchored_reliability * totalCount + K * prior) / (totalCount + K)
+            // For simplicity, we use anchored_reliability which already incorporates this weighting
+            const alphaCandidate = variants.reduce((prev, curr) => {
+                const pAnchored = prev.meta.anchored_reliability ?? 0;
+                const cAnchored = curr.meta.anchored_reliability ?? 0;
+                return cAnchored > pAnchored ? curr : prev;
+            });
+            // Non-Blocking Set Update: Flag Alpha and Shadow versions
+            await this.db.transaction().execute(async (trx) => {
+                const currentMeta = alphaCandidate.meta || {};
+                const updatedMeta = {
+                    ...currentMeta,
+                    is_alpha: true,
+                    broadcasted: true,
+                    broadcasted_at: new Date()
+                };
+                // Flag the winner as Alpha
+                // Audit Phase 15: Lock candidate before promotion
+                const winner = await trx
                     .selectFrom(capTable)
-                    .selectAll()
-                    .where('name', 'like', `%${baseName}%`)
-                    .where('status', '=', 'verified')
-                    .where('id', '!=', skill.id)
+                    .select('id')
+                    .where('id', '=', alphaCandidate.skill.id)
+                    .forUpdate()
                     .executeTakeFirst();
-                let shouldBroadcast = true;
-                if (competitor) {
-                    const comp = competitor;
-                    const compRel = comp.reliability || 0;
-                    // Performance-Based Conflict Resolution: Only broadcast if reliability is strictly better
-                    // or if it's a direct version upgrade with equal/better reliability
-                    const isNewer = this.compareVersions(skill.version, comp.version) > 0;
-                    if (compRel > skill.reliability) {
-                        shouldBroadcast = false;
-                    }
-                    else if (compRel === skill.reliability && !isNewer) {
-                        shouldBroadcast = false;
-                    }
-                }
-                if (shouldBroadcast) {
+                if (winner) {
                     await trx
                         .updateTable(capTable)
                         .set({
-                        metadata: JSON.stringify({
-                            ...meta,
-                            broadcasted: true,
-                            hive_verified: true,
-                            broadcasted_at: new Date(),
-                            conflict_resolved: !!competitor,
-                        }),
+                        metadata: JSON.stringify(updatedMeta),
                     })
-                        .where('id', '=', skill.id)
+                        .where('id', '=', winner.id)
                         .execute();
-                    broadcastCount++;
                 }
-            }
-            // 2. Broadcast Blacklisted Skills (Immediate Immune Propagations)
-            const blacklisted = await this.cortex.capabilities.getCapabilities('blacklisted');
-            for (const skill of blacklisted) {
-                const meta = typeof skill.metadata === 'string'
-                    ? JSON.parse(skill.metadata)
-                    : skill.metadata || {};
-                if (!meta.broadcasted) {
-                    await trx
-                        .updateTable(capTable)
-                        .set({
-                        metadata: JSON.stringify({
-                            ...meta,
-                            broadcasted: true,
-                            hive_blacklisted: true,
-                            blocked_at: new Date(),
-                        }),
-                    })
-                        .where('id', '=', skill.id)
-                        .execute();
-                    broadcastCount++;
+                // Flag others in the same lineage as Shadow (Dialect-safe approach)
+                const shadowIds = variants
+                    .filter(v => v.skill.id !== alphaCandidate.skill.id)
+                    .map(v => v.skill.id);
+                if (shadowIds.length > 0) {
+                    // We fetch and update individually or use a bulk update if the dialect supports complex JSON manipulation.
+                    // For maximum compatibility (Postgres/SQLite), we do it in a loop for the shadows if the count is small.
+                    for (const sid of shadowIds) {
+                        const sMatch = variants.find(v => v.skill.id === sid);
+                        const sMeta = sMatch?.meta || {};
+                        await trx.updateTable(capTable)
+                            .set({
+                            metadata: JSON.stringify({ ...sMeta, is_alpha: false, is_shadow: true }),
+                            status: 'experimental'
+                        })
+                            .where('id', '=', sid)
+                            .execute();
+                    }
                 }
-            }
-        });
+            });
+            broadcastCount += variants.length;
+        }
+        // 2. Broadcast Blacklisted Skills (Immune Prophet)
+        const blacklisted = await this.cortex.capabilities.getCapabilities('blacklisted');
+        const blackIDs = blacklisted
+            .filter(s => {
+            const meta = typeof s.metadata === 'string' ? JSON.parse(s.metadata) : (s.metadata || {});
+            return !meta.broadcasted;
+        })
+            .map(s => s.id);
+        if (blackIDs.length > 0) {
+            await this.db
+                .updateTable(capTable)
+                .set({
+                metadata: sql `json_set(metadata, '$.broadcasted', true, '$.hive_blacklisted', true)`,
+                updated_at: new Date()
+            })
+                .where('id', 'in', blackIDs)
+                .execute();
+            broadcastCount += blackIDs.length;
+        }
         return broadcastCount;
     }
     /**

package/dist/esm/agentic/improvement/KnowledgeDistiller.js

@@ -101,6 +101,7 @@ export class KnowledgeDistiller {
                 return this.parseKnowledge(updated);
             }
             // Conflict Detection: Check if a similar entity has a conflicting fact
+            // Audit Phase 11: Explicit transaction propagation
             await this.challengeKnowledge(entity, fact, confidence, trx);
             // Create new
             const initialMeta = {
@@ -195,35 +196,38 @@ export class KnowledgeDistiller {
      * Record a retrieval hit for a knowledge item.
      */
     async recordHit(id) {
-        const existing = await this.typedDb
-            .selectFrom(this.knowledgeTable)
-            .selectAll()
-            .where('id', '=', id)
-            .executeTakeFirst();
-        if (!existing)
-            return;
-        const metadata = typeof existing.metadata === 'string'
-            ? JSON.parse(existing.metadata)
-            : existing.metadata || {};
-        metadata.hit_count = (metadata.hit_count || 0) + 1;
-        metadata.last_retrieved_at = new Date().toISOString();
-        await this.db
-            .updateTable(this.knowledgeTable)
-            .set({
-            metadata: JSON.stringify(metadata),
-            updated_at: new Date(),
-        })
-            .where('id', '=', id)
-            .execute();
-        // Production Hardening: Emit a metric event for this hit to enable efficient hotspot detection
-        await this.db
-            .insertInto(this.config.metricsTable || 'agent_metrics')
-            .values({
-            metric_name: `entity_hit_${existing.entity}`,
-            metric_value: 1,
-            created_at: new Date(),
-        })
-            .execute();
+        await this.db.transaction().execute(async (trx) => {
+            const existing = await trx
+                .selectFrom(this.knowledgeTable)
+                .selectAll()
+                .where('id', '=', id)
+                .forUpdate() // Audit Phase 11: Atomic hit record
+                .executeTakeFirst();
+            if (!existing)
+                return;
+            const metadata = typeof existing.metadata === 'string'
+                ? JSON.parse(existing.metadata)
+                : existing.metadata || {};
+            metadata.hit_count = (metadata.hit_count || 0) + 1;
+            metadata.last_retrieved_at = new Date().toISOString();
+            await trx
+                .updateTable(this.knowledgeTable)
+                .set({
+                metadata: JSON.stringify(metadata),
+                updated_at: new Date(),
+            })
+                .where('id', '=', id)
+                .execute();
+            // Production Hardening: Emit a metric event for this hit to enable efficient hotspot detection
+            await trx
+                .insertInto(this.config.metricsTable || 'agent_metrics')
+                .values({
+                metric_name: `entity_hit_${existing.entity}`,
+                metric_value: 1,
+                created_at: new Date(),
+            })
+                .execute();
+        });
     }
     /**
      * Calculate the "Fitness" of a memory item.
@@ -246,6 +250,8 @@ export class KnowledgeDistiller {
      * we degrade the confidence of the old facts.
      */
     async challengeKnowledge(entity, competingFact, confidence, trxOrDb = this.db) {
+        // Audit Phase 11: Semantic sanitization of competing fact
+        const safeFact = competingFact.slice(0, 500).replace(/[\u0000-\u001F\u007F-\u009F]/g, '').replace(/<\|.*?\|>/g, '');
         const query = trxOrDb
             .selectFrom(this.knowledgeTable)
             .selectAll()
@@ -267,7 +273,7 @@ export class KnowledgeDistiller {
                     newStatus = 'disputed';
                     newMeta = {
                         ...newMeta,
-                        status_reason: `Contradicted by: ${competingFact}`,
+                        status_reason: `Contradicted by: ${safeFact}`,
                     };
                     penalty = 0.1;
                 }
@@ -275,7 +281,7 @@ export class KnowledgeDistiller {
                     newStatus = 'deprecated';
                     newMeta = {
                         ...newMeta,
-                        status_reason: `Superseded by: ${competingFact}`,
+                        status_reason: `Superseded by: ${safeFact}`,
                     };
                     penalty = 0.4;
                 }
@@ -416,22 +422,24 @@ export class KnowledgeDistiller {
      */
     async consolidateKnowledge() {
         let totalMerged = 0;
-        // Find entities with multiple facts
+        // Find entities with multiple facts (Paginated to handle scale)
         const candidates = await this.db
             .selectFrom(this.knowledgeTable)
             .select('entity')
             .groupBy('entity')
             .having((eb) => eb.fn.count('id'), '>', 1)
+            .limit(500) // Audit Phase 11: Chunked search
             .execute();
         for (const cand of candidates) {
             const entity = cand.entity;
             const items = await this.getKnowledgeByEntity(entity);
-            // Iterative merging inside the entity bucket
+            // Iterative merging inside the entity bucket (Paginated check)
             const mergedIds = new Set();
-            for (let i = 0; i < items.length; i++) {
+            const iterLimit = Math.min(items.length, 100);
+            for (let i = 0; i < iterLimit; i++) {
                 if (mergedIds.has(items[i].id))
                     continue;
-                for (let j = i + 1; j < items.length; j++) {
+                for (let j = i + 1; j < iterLimit; j++) {
                     if (mergedIds.has(items[j].id))
                         continue;
                     const sim = calculateSimilarity(items[i].fact, items[j].fact);

package/dist/esm/agentic/improvement/QuotaManager.d.ts

@@ -0,0 +1,41 @@
+import type { Kysely } from '../../kysely.js';
+import type { AgenticConfig } from '../../types/index.js';
+import type { Cortex } from '../Cortex.js';
+/**
+ * QuotaManager enforces resource limits across personas and swarms.
+ */
+export declare class QuotaManager {
+    private db;
+    private cortex;
+    private config;
+    private resourcesTable;
+    private metricsTable;
+    private rateCache;
+    private readonly CACHE_TTL;
+    constructor(db: Kysely<any>, cortex: Cortex, config?: AgenticConfig);
+    /**
+     * Check if a quota is violated for a given target.
+     */
+    checkQuota(targetType: 'persona' | 'swarm' | 'global', targetId?: string | null): Promise<{
+        allowed: boolean;
+        reason?: string;
+    }>;
+    /**
+     * Fetches active quotas for a given target.
+     */
+    private getActiveQuotas;
+    /**
+     * Calculates current usage for a specific quota window.
+     */
+    private getCurrentUsage;
+    /**
+     * Resolves exchange rate via persistent metric store or live update.
+     * Implements a true Oracle pattern for resource normalization.
+     */
+    private getExchangeRate;
+    /**
+     * Manually sync exchange rates from an external provider (Oracle pulse).
+     */
+    syncExchangeRates(rates: Record<string, number>): Promise<void>;
+    private getPeriodInMs;
+}

package/dist/esm/agentic/improvement/QuotaManager.js

@@ -0,0 +1,182 @@
+/// <reference types="./QuotaManager.d.ts" />
+import { sql } from '../../raw-builder/sql.js';
+/**
+ * QuotaManager enforces resource limits across personas and swarms.
+ */
+export class QuotaManager {
+    db;
+    cortex;
+    config;
+    resourcesTable;
+    metricsTable;
+    rateCache = new Map();
+    CACHE_TTL = 1000 * 60 * 60; // 1 hour cache
+    constructor(db, cortex, config = {}) {
+        this.db = db;
+        this.cortex = cortex;
+        this.config = config;
+        this.resourcesTable = config.resourcesTable || 'agent_resource_usage';
+        this.metricsTable = config.metricsTable || 'agent_metrics';
+    }
+    /**
+     * Check if a quota is violated for a given target.
+     */
+    async checkQuota(targetType, targetId = null) {
+        const quotas = await this.getActiveQuotas(targetType, targetId);
+        for (const quota of quotas) {
+            const usage = await this.getCurrentUsage(quota);
+            // Currency Conversion Logic: Convert usage to target currency if specified
+            let normalizedUsage = usage;
+            if (quota.metric === 'cost' && quota.metadata?.currency && quota.metadata.currency !== 'USD') {
+                const rate = await this.getExchangeRate(quota.metadata.currency);
+                normalizedUsage = usage * rate;
+            }
+            if (normalizedUsage >= quota.limit) {
+                const limitStr = quota.metric === 'cost'
+                    ? `${quota.metadata?.currency || '$'}${quota.limit}`
+                    : `${quota.limit}`;
+                return {
+                    allowed: false,
+                    reason: `Quota exceeded: ${quota.metric} limit is ${limitStr}, current is ${normalizedUsage.toFixed(4)} (${quota.period})`
+                };
+            }
+        }
+        return { allowed: true };
+    }
+    /**
+     * Fetches active quotas for a given target.
+     */
+    async getActiveQuotas(targetType, targetId) {
+        const quotas = [];
+        // 1. Fetch from PolicyEnforcer (Global & Type-specific)
+        const policies = await this.cortex.policies.getActivePolicies();
+        for (const policy of policies) {
+            if (policy.type === 'budget' &&
+                (policy.definition.targetType === targetType ||
+                    (!policy.definition.targetType && targetType === 'global'))) {
+                quotas.push({
+                    id: policy.id,
+                    targetType: targetType,
+                    targetId: targetId,
+                    metric: policy.definition.metric || 'cost',
+                    limit: policy.definition.limit || 0,
+                    period: policy.definition.period || 'hourly',
+                    currentUsage: 0,
+                    createdAt: policy.createdAt,
+                    updatedAt: policy.updatedAt,
+                    metadata: policy.metadata
+                });
+            }
+        }
+        // 2. Fetch from Persona metadata (Specific override)
+        if (targetType === 'persona' && targetId) {
+            const persona = await this.db
+                .selectFrom(this.config.personasTable || 'agent_personas')
+                .select('metadata')
+                .where('id', '=', targetId)
+                .executeTakeFirst();
+            if (persona) {
+                const meta = typeof persona.metadata === 'string'
+                    ? JSON.parse(persona.metadata)
+                    : persona.metadata || {};
+                if (meta.quotas) {
+                    quotas.push(...meta.quotas);
+                }
+            }
+        }
+        return quotas;
+    }
+    /**
+     * Calculates current usage for a specific quota window.
+     */
+    async getCurrentUsage(quota) {
+        const windowMs = this.getPeriodInMs(quota.period);
+        const startTime = new Date(Date.now() - windowMs);
+        let query = this.db
+            .selectFrom(this.resourcesTable)
+            .where('created_at', '>', startTime);
+        if (quota.targetType === 'persona' && quota.targetId) {
+            query = query.where('agent_id', '=', quota.targetId);
+        }
+        else if (quota.targetType === 'swarm' && quota.targetId) {
+            // PRODUCTION HARDENING: Efficient JSON filtering
+            query = query.where((eb) => eb.or([
+                eb(sql `json_extract(metadata, '$.swarm_id')`, '=', quota.targetId),
+                eb(sql `metadata->>'swarm_id'`, '=', String(quota.targetId))
+            ]));
+        }
+        const metricField = quota.metric === 'cost' ? 'cost' :
+            quota.metric === 'tokens_input' ? 'input_tokens' :
+                quota.metric === 'tokens_output' ? 'output_tokens' :
+                    sql `input_tokens + output_tokens`;
+        const result = await query
+            .select((eb) => eb.fn.sum(metricField).as('total'))
+            .executeTakeFirst();
+        const usage = Number(result?.total || 0);
+        // Audit Phase 7: Floating-point drift protection
+        const epsilon = 1e-10;
+        return usage < epsilon ? 0 : usage;
+    }
+    /**
+     * Resolves exchange rate via persistent metric store or live update.
+     * Implements a true Oracle pattern for resource normalization.
+     */
+    async getExchangeRate(currency) {
+        // 1. Check in-memory cache
+        const cached = this.rateCache.get(currency);
+        if (cached && Date.now() - cached.timestamp < this.CACHE_TTL) {
+            return cached.rate;
+        }
+        // 2. Check persistent metric store
+        const record = await this.db
+            .selectFrom(this.metricsTable)
+            .select(['metric_value', 'created_at'])
+            .where('metric_name', '=', `exchange_rate_${currency}`)
+            .orderBy('created_at', 'desc')
+            .executeTakeFirst();
+        if (record && Date.now() - new Date(record.created_at).getTime() < this.CACHE_TTL * 24) {
+            const rate = Number(record.metric_value);
+            this.rateCache.set(currency, { rate, timestamp: Date.now() });
+            return rate;
+        }
+        // 3. Fallback to base rates if unreachable (Statically hardened)
+        const baseRates = {
+            'ETH': 0.00032,
+            'BTC': 0.000015,
+            'EUR': 0.92,
+            'GBP': 0.79
+        };
+        const fallback = baseRates[currency] || 1.0;
+        // Log the need for sync
+        console.warn(`[QuotaManager] Exchange rate for ${currency} is stale or missing. Using hardened fallback: ${fallback}`);
+        return fallback;
+    }
+    /**
+     * Manually sync exchange rates from an external provider (Oracle pulse).
+     */
+    async syncExchangeRates(rates) {
+        await this.db.transaction().execute(async (trx) => {
+            for (const [currency, rate] of Object.entries(rates)) {
+                await trx
+                    .insertInto(this.metricsTable)
+                    .values({
+                    metric_name: `exchange_rate_${currency}`,
+                    metric_value: rate,
+                    created_at: new Date()
+                })
+                    .execute();
+                this.rateCache.set(currency, { rate, timestamp: Date.now() });
+            }
+        });
+        console.log(`[QuotaManager] Synchronized ${Object.keys(rates).length} exchange rates.`);
+    }
+    getPeriodInMs(period) {
+        switch (period) {
+            case 'hourly': return 3600000;
+            case 'daily': return 86400000;
+            case 'monthly': return 86400000 * 30;
+            case 'infinite': return Date.now();
+            default: return 3600000;
+        }
+    }
+}