cmp-memory-system 1.0.0

package/dist/services/cross-project-sync.js

@@ -0,0 +1,235 @@
+/**
+ * Cross-Project Sync Service
+ *
+ * Synchronizes memories across different projects in the MetaNautical ecosystem.
+ * - Shares relevant learnings between projects
+ * - Maintains project isolation while enabling knowledge transfer
+ * - Syncs common patterns and gotchas
+ */
+import { createDrizzleClient } from '../db/drizzle-client.js';
+// =============================================================================
+// ECOSYSTEM SYSTEMS
+// =============================================================================
+export const ECOSYSTEM_SYSTEMS = [
+    'SWARMSCALE',
+    'PANEL',
+    'ECOSYSTEM',
+    'ELLIOT',
+    'CONNECTA_HOTEL',
+    'CONNECTA_CREW',
+];
+// =============================================================================
+// CROSS-PROJECT SYNC SERVICE
+// =============================================================================
+export class CrossProjectSyncService {
+    clients = new Map();
+    /**
+     * Get or create a client for a system
+     */
+    getClient(system) {
+        let client = this.clients.get(system);
+        if (!client) {
+            client = createDrizzleClient(system);
+            this.clients.set(system, client);
+        }
+        return client;
+    }
+    /**
+     * Sync memories from source to target systems
+     */
+    async sync(config) {
+        const result = {
+            synced: 0,
+            skipped: 0,
+            errors: [],
+        };
+        const sourceClient = this.getClient(config.sourceSystem);
+        // Get shareable memories from source
+        const memories = await this.getShareableMemories(sourceClient, config);
+        for (const memory of memories) {
+            const content = memory.content;
+            if (!content)
+                continue;
+            // Sync to each target system
+            for (const targetSystem of config.targetSystems) {
+                if (targetSystem === config.sourceSystem)
+                    continue;
+                try {
+                    const synced = await this.syncMemoryToSystem(memory, content, config.sourceSystem, targetSystem);
+                    if (synced) {
+                        result.synced++;
+                    }
+                    else {
+                        result.skipped++;
+                    }
+                }
+                catch (error) {
+                    result.errors.push(`Failed to sync ${memory.id} to ${targetSystem}: ${error}`);
+                }
+            }
+        }
+        return result;
+    }
+    /**
+     * Get ecosystem-wide patterns (shared across all systems)
+     */
+    async getEcosystemPatterns() {
+        const allPatterns = [];
+        for (const system of ECOSYSTEM_SYSTEMS) {
+            try {
+                const client = this.getClient(system);
+                const patterns = await client.getTriggeredPatterns(3);
+                allPatterns.push(...patterns);
+            }
+            catch {
+                // Skip systems that fail
+            }
+        }
+        // Deduplicate by pattern ID
+        const uniquePatterns = new Map();
+        for (const pattern of allPatterns) {
+            const content = pattern.content;
+            const patternId = content?.patternId;
+            if (patternId && !uniquePatterns.has(patternId)) {
+                uniquePatterns.set(patternId, pattern);
+            }
+        }
+        return Array.from(uniquePatterns.values());
+    }
+    /**
+     * Get memories shared across all systems (tagged with 'ecosystem' or 'shared')
+     */
+    async getSharedMemories() {
+        const sharedMemories = [];
+        for (const system of ECOSYSTEM_SYSTEMS) {
+            try {
+                const client = this.getClient(system);
+                const memories = await client.list({
+                    type: 'memory',
+                    tags: ['ecosystem', 'shared'],
+                    limit: 50,
+                });
+                for (const memory of memories) {
+                    sharedMemories.push({ ...memory, system });
+                }
+            }
+            catch {
+                // Skip systems that fail
+            }
+        }
+        return sharedMemories;
+    }
+    /**
+     * Share a memory to the ecosystem (tag it for sync)
+     */
+    async shareToEcosystem(memoryId, sourceSystem) {
+        const client = this.getClient(sourceSystem);
+        const memory = await client.get(memoryId);
+        if (!memory)
+            return false;
+        const existingTags = memory.tags ?? [];
+        if (existingTags.includes('ecosystem'))
+            return true;
+        await client.update(memoryId, {
+            tags: [...existingTags, 'ecosystem', 'shared'],
+        });
+        return true;
+    }
+    /**
+     * Get sync status for a system
+     */
+    async getSyncStatus(system) {
+        const client = this.getClient(system);
+        const [all, shared, received] = await Promise.all([
+            client.list({ type: 'memory', limit: 1000 }),
+            client.list({ type: 'memory', tags: ['shared'], limit: 1000 }),
+            client.list({ type: 'memory', tags: ['synced-from'], limit: 1000 }),
+        ]);
+        return {
+            totalMemories: all.length,
+            sharedMemories: shared.length,
+            receivedMemories: received.length,
+        };
+    }
+    // ===========================================================================
+    // PRIVATE METHODS
+    // ===========================================================================
+    /**
+     * Get memories that should be synced
+     */
+    async getShareableMemories(client, config) {
+        // Get memories with sync tags
+        const memories = await client.list({
+            type: 'memory',
+            limit: 200,
+        });
+        return memories.filter(m => {
+            const tags = m.tags ?? [];
+            // Must have at least one sync tag
+            const hasSyncTag = config.syncTags.some(t => tags.includes(t));
+            if (!hasSyncTag)
+                return false;
+            // Must not have exclude tags
+            const hasExcludeTag = config.excludeTags.some(t => tags.includes(t));
+            if (hasExcludeTag)
+                return false;
+            return true;
+        });
+    }
+    /**
+     * Sync a single memory to a target system
+     */
+    async syncMemoryToSystem(memory, content, sourceSystem, targetSystem) {
+        const targetClient = this.getClient(targetSystem);
+        // Check if already synced
+        const existing = await targetClient.list({
+            type: 'memory',
+            tags: [`synced-from:${memory.id}`],
+            limit: 1,
+        });
+        if (existing.length > 0) {
+            // Already synced, update if newer
+            const existingItem = existing[0];
+            const existingTime = existingItem.updatedAt?.getTime() ?? 0;
+            const memoryTime = memory.updatedAt?.getTime() ?? 0;
+            if (memoryTime > existingTime) {
+                // Update the synced copy
+                await targetClient.update(existingItem.id, {
+                    content: {
+                        ...content,
+                        syncedFrom: {
+                            system: sourceSystem,
+                            id: memory.id,
+                            syncedAt: new Date().toISOString(),
+                        },
+                    },
+                });
+                return true;
+            }
+            return false; // No update needed
+        }
+        // Create synced copy
+        await targetClient.createMemory({
+            title: `[${sourceSystem}] ${content.title}`,
+            body: content.body,
+            domain: content.domain,
+            source: 'system',
+        }, [
+            'synced',
+            `synced-from:${memory.id}`,
+            `synced-from-system:${sourceSystem}`,
+            ...(memory.tags ?? []).filter(t => !t.startsWith('synced')),
+        ]);
+        return true;
+    }
+}
+// =============================================================================
+// FACTORY
+// =============================================================================
+/**
+ * Create a cross-project sync service
+ */
+export function createCrossProjectSyncService() {
+    return new CrossProjectSyncService();
+}
+//# sourceMappingURL=cross-project-sync.js.map

package/dist/services/cross-project-sync.js.map

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

package/dist/services/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Services Index
+ *
+ * Export all memory services for easy consumption.
+ */
+export { SemanticSearchService, createSemanticSearchService, type SemanticSearchResult, type MemoryWithEmbedding, } from './semantic-search.js';
+export { AutoInjectService, createAutoInjectService, type SessionContext, type InjectedMemory, type InjectedPattern, type SessionStats, } from './auto-inject.js';
+export { MemoryConsolidationService, createConsolidationService, type ConsolidationResult, type ConflictInfo, type DecayResult, } from './memory-consolidation.js';
+export { AutoTagService, createAutoTagService, type AutoTagResult, type BatchTagResult, } from './auto-tag.js';
+export { CrossProjectSyncService, createCrossProjectSyncService, ECOSYSTEM_SYSTEMS, type SyncConfig, type SyncResult, type SharedMemory, } from './cross-project-sync.js';
+export { WeeklyDigestService, createWeeklyDigestService, type WeeklyDigest, type DigestSummary, type DigestHighlight, type DigestPattern, type DigestRecommendation, type DigestTrend, } from './weekly-digest.js';
+export { TaskTracker, getTaskTracker, createTaskTracker, type StartTaskOptions, type UpdateTaskOptions, type CompleteTaskOptions, } from './TaskTracker.js';
+export { IdeaCollector, getIdeaCollector, createIdeaCollector, type IdeaInput, type ImprovementInput, type IdeaStats, type ImprovementStats, } from './IdeaCollector.js';
+export { WorkPlanManager, getWorkPlanManager, createWorkPlanManager, type CreatePlanOptions, type PlanTask, type PlanSummary, } from './WorkPlanManager.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/services/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/services/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EACL,qBAAqB,EACrB,2BAA2B,EAC3B,KAAK,oBAAoB,EACzB,KAAK,mBAAmB,GACzB,MAAM,sBAAsB,CAAA;AAE7B,OAAO,EACL,iBAAiB,EACjB,uBAAuB,EACvB,KAAK,cAAc,EACnB,KAAK,cAAc,EACnB,KAAK,eAAe,EACpB,KAAK,YAAY,GAClB,MAAM,kBAAkB,CAAA;AAEzB,OAAO,EACL,0BAA0B,EAC1B,0BAA0B,EAC1B,KAAK,mBAAmB,EACxB,KAAK,YAAY,EACjB,KAAK,WAAW,GACjB,MAAM,2BAA2B,CAAA;AAElC,OAAO,EACL,cAAc,EACd,oBAAoB,EACpB,KAAK,aAAa,EAClB,KAAK,cAAc,GACpB,MAAM,eAAe,CAAA;AAEtB,OAAO,EACL,uBAAuB,EACvB,6BAA6B,EAC7B,iBAAiB,EACjB,KAAK,UAAU,EACf,KAAK,UAAU,EACf,KAAK,YAAY,GAClB,MAAM,yBAAyB,CAAA;AAEhC,OAAO,EACL,mBAAmB,EACnB,yBAAyB,EACzB,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,KAAK,eAAe,EACpB,KAAK,aAAa,EAClB,KAAK,oBAAoB,EACzB,KAAK,WAAW,GACjB,MAAM,oBAAoB,CAAA;AAM3B,OAAO,EACL,WAAW,EACX,cAAc,EACd,iBAAiB,EACjB,KAAK,gBAAgB,EACrB,KAAK,iBAAiB,EACtB,KAAK,mBAAmB,GACzB,MAAM,kBAAkB,CAAA;AAEzB,OAAO,EACL,aAAa,EACb,gBAAgB,EAChB,mBAAmB,EACnB,KAAK,SAAS,EACd,KAAK,gBAAgB,EACrB,KAAK,SAAS,EACd,KAAK,gBAAgB,GACtB,MAAM,oBAAoB,CAAA;AAE3B,OAAO,EACL,eAAe,EACf,kBAAkB,EAClB,qBAAqB,EACrB,KAAK,iBAAiB,EACtB,KAAK,QAAQ,EACb,KAAK,WAAW,GACjB,MAAM,sBAAsB,CAAA"}

package/dist/services/index.js

@@ -0,0 +1,18 @@
+/**
+ * Services Index
+ *
+ * Export all memory services for easy consumption.
+ */
+export { SemanticSearchService, createSemanticSearchService, } from './semantic-search.js';
+export { AutoInjectService, createAutoInjectService, } from './auto-inject.js';
+export { MemoryConsolidationService, createConsolidationService, } from './memory-consolidation.js';
+export { AutoTagService, createAutoTagService, } from './auto-tag.js';
+export { CrossProjectSyncService, createCrossProjectSyncService, ECOSYSTEM_SYSTEMS, } from './cross-project-sync.js';
+export { WeeklyDigestService, createWeeklyDigestService, } from './weekly-digest.js';
+// =============================================================================
+// WORKFLOW SERVICES (NEW)
+// =============================================================================
+export { TaskTracker, getTaskTracker, createTaskTracker, } from './TaskTracker.js';
+export { IdeaCollector, getIdeaCollector, createIdeaCollector, } from './IdeaCollector.js';
+export { WorkPlanManager, getWorkPlanManager, createWorkPlanManager, } from './WorkPlanManager.js';
+//# sourceMappingURL=index.js.map

package/dist/services/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/services/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EACL,qBAAqB,EACrB,2BAA2B,GAG5B,MAAM,sBAAsB,CAAA;AAE7B,OAAO,EACL,iBAAiB,EACjB,uBAAuB,GAKxB,MAAM,kBAAkB,CAAA;AAEzB,OAAO,EACL,0BAA0B,EAC1B,0BAA0B,GAI3B,MAAM,2BAA2B,CAAA;AAElC,OAAO,EACL,cAAc,EACd,oBAAoB,GAGrB,MAAM,eAAe,CAAA;AAEtB,OAAO,EACL,uBAAuB,EACvB,6BAA6B,EAC7B,iBAAiB,GAIlB,MAAM,yBAAyB,CAAA;AAEhC,OAAO,EACL,mBAAmB,EACnB,yBAAyB,GAO1B,MAAM,oBAAoB,CAAA;AAE3B,gFAAgF;AAChF,0BAA0B;AAC1B,gFAAgF;AAEhF,OAAO,EACL,WAAW,EACX,cAAc,EACd,iBAAiB,GAIlB,MAAM,kBAAkB,CAAA;AAEzB,OAAO,EACL,aAAa,EACb,gBAAgB,EAChB,mBAAmB,GAKpB,MAAM,oBAAoB,CAAA;AAE3B,OAAO,EACL,eAAe,EACf,kBAAkB,EAClB,qBAAqB,GAItB,MAAM,sBAAsB,CAAA"}

package/dist/services/memory-consolidation.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Memory Consolidation Service
+ *
+ * Automatically consolidates and cleans up memories:
+ * - Merges similar/duplicate memories
+ * - Archives stale memories (decay)
+ * - Detects conflicts between memories
+ */
+import { SemanticSearchService } from './semantic-search.js';
+import type { DrizzleMemoryClient } from '../db/drizzle-client.js';
+import type { DevItem, MemoryContent } from '../types/index.js';
+export interface ConsolidationResult {
+    analyzed: number;
+    merged: number;
+    archived: number;
+    conflicts: ConflictInfo[];
+}
+export interface ConflictInfo {
+    memoryIds: string[];
+    titles: string[];
+    reason: string;
+    suggestion: string;
+}
+export interface DecayResult {
+    analyzed: number;
+    decayed: number;
+    archived: number;
+}
+export interface MemoryWithMeta extends MemoryContent {
+    accessCount?: number;
+    lastAccessed?: string;
+    mergedFrom?: string[];
+    decayScore?: number;
+}
+export declare class MemoryConsolidationService {
+    private client;
+    private searchService;
+    constructor(client: DrizzleMemoryClient, searchService: SemanticSearchService);
+    /**
+     * Run full consolidation process
+     */
+    consolidate(options?: {
+        similarityThreshold?: number;
+        maxMerges?: number;
+        dryRun?: boolean;
+    }): Promise<ConsolidationResult>;
+    /**
+     * Apply memory decay - reduce priority of unused memories
+     */
+    applyDecay(options?: {
+        daysThreshold?: number;
+        decayFactor?: number;
+        archiveThreshold?: number;
+        dryRun?: boolean;
+    }): Promise<DecayResult>;
+    /**
+     * Detect conflicts between memories
+     */
+    detectConflicts(memories?: DevItem[]): Promise<ConflictInfo[]>;
+    /**
+     * Record memory access (for decay algorithm)
+     */
+    recordAccess(memoryId: string): Promise<void>;
+    /**
+     * Merge multiple memories into one
+     */
+    private mergeMemories;
+    /**
+     * Check for contradictions between two memories
+     */
+    private checkContradiction;
+}
+/**
+ * Create a memory consolidation service
+ */
+export declare function createConsolidationService(client: DrizzleMemoryClient, searchService: SemanticSearchService): MemoryConsolidationService;
+//# sourceMappingURL=memory-consolidation.d.ts.map

package/dist/services/memory-consolidation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-consolidation.d.ts","sourceRoot":"","sources":["../../src/services/memory-consolidation.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAA;AAC5D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAA;AAClE,OAAO,KAAK,EAAE,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAA;AAM/D,MAAM,WAAW,mBAAmB;IAClC,QAAQ,EAAE,MAAM,CAAA;IAChB,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,MAAM,CAAA;IAChB,SAAS,EAAE,YAAY,EAAE,CAAA;CAC1B;AAED,MAAM,WAAW,YAAY;IAC3B,SAAS,EAAE,MAAM,EAAE,CAAA;IACnB,MAAM,EAAE,MAAM,EAAE,CAAA;IAChB,MAAM,EAAE,MAAM,CAAA;IACd,UAAU,EAAE,MAAM,CAAA;CACnB;AAED,MAAM,WAAW,WAAW;IAC1B,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,EAAE,MAAM,CAAA;IACf,QAAQ,EAAE,MAAM,CAAA;CACjB;AAED,MAAM,WAAW,cAAe,SAAQ,aAAa;IACnD,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,UAAU,CAAC,EAAE,MAAM,EAAE,CAAA;IACrB,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB;AAMD,qBAAa,0BAA0B;IACrC,OAAO,CAAC,MAAM,CAAqB;IACnC,OAAO,CAAC,aAAa,CAAuB;gBAG1C,MAAM,EAAE,mBAAmB,EAC3B,aAAa,EAAE,qBAAqB;IAMtC;;OAEG;IACG,WAAW,CAAC,OAAO,CAAC,EAAE;QAC1B,mBAAmB,CAAC,EAAE,MAAM,CAAA;QAC5B,SAAS,CAAC,EAAE,MAAM,CAAA;QAClB,MAAM,CAAC,EAAE,OAAO,CAAA;KACjB,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAkEhC;;OAEG;IACG,UAAU,CAAC,OAAO,CAAC,EAAE;QACzB,aAAa,CAAC,EAAE,MAAM,CAAA;QACtB,WAAW,CAAC,EAAE,MAAM,CAAA;QACpB,gBAAgB,CAAC,EAAE,MAAM,CAAA;QACzB,MAAM,CAAC,EAAE,OAAO,CAAA;KACjB,GAAG,OAAO,CAAC,WAAW,CAAC;IA4DxB;;OAEG;IACG,eAAe,CAAC,QAAQ,CAAC,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC;IA6CpE;;OAEG;IACG,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAuBnD;;OAEG;YACW,aAAa;IA0D3B;;OAEG;IACH,OAAO,CAAC,kBAAkB;CAyC3B;AAMD;;GAEG;AACH,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,mBAAmB,EAC3B,aAAa,EAAE,qBAAqB,GACnC,0BAA0B,CAE5B"}

package/dist/services/memory-consolidation.js

@@ -0,0 +1,298 @@
+/**
+ * Memory Consolidation Service
+ *
+ * Automatically consolidates and cleans up memories:
+ * - Merges similar/duplicate memories
+ * - Archives stale memories (decay)
+ * - Detects conflicts between memories
+ */
+// =============================================================================
+// MEMORY CONSOLIDATION SERVICE
+// =============================================================================
+export class MemoryConsolidationService {
+    client;
+    searchService;
+    constructor(client, searchService) {
+        this.client = client;
+        this.searchService = searchService;
+    }
+    /**
+     * Run full consolidation process
+     */
+    async consolidate(options) {
+        const threshold = options?.similarityThreshold ?? 0.85;
+        const maxMerges = options?.maxMerges ?? 50;
+        const dryRun = options?.dryRun ?? false;
+        const result = {
+            analyzed: 0,
+            merged: 0,
+            archived: 0,
+            conflicts: [],
+        };
+        // Get all memories
+        const memories = await this.client.list({ type: 'memory', limit: 500 });
+        result.analyzed = memories.length;
+        // Find similar pairs
+        const processed = new Set();
+        const mergeGroups = [];
+        for (const memory of memories) {
+            if (processed.has(memory.id))
+                continue;
+            const content = memory.content;
+            if (!content)
+                continue;
+            // Find similar memories
+            const similar = await this.searchService.search(`${content.title}\n${content.body}`, { threshold, limit: 10 });
+            // Group similar memories
+            const group = similar
+                .filter(s => s.item.id !== memory.id && !processed.has(s.item.id))
+                .filter(s => s.score >= threshold);
+            if (group.length > 0) {
+                const groupItems = [memory, ...group.map(g => g.item)];
+                mergeGroups.push(groupItems);
+                groupItems.forEach(item => processed.add(item.id));
+            }
+            else {
+                processed.add(memory.id);
+            }
+        }
+        // Check for conflicts (same domain, different content)
+        result.conflicts = await this.detectConflicts(memories);
+        // Merge groups
+        if (!dryRun) {
+            for (const group of mergeGroups.slice(0, maxMerges)) {
+                const merged = await this.mergeMemories(group);
+                if (merged) {
+                    result.merged++;
+                    result.archived += group.length - 1;
+                }
+            }
+        }
+        else {
+            result.merged = Math.min(mergeGroups.length, maxMerges);
+            result.archived = mergeGroups.reduce((sum, g) => sum + g.length - 1, 0);
+        }
+        return result;
+    }
+    /**
+     * Apply memory decay - reduce priority of unused memories
+     */
+    async applyDecay(options) {
+        const daysThreshold = options?.daysThreshold ?? 30;
+        const decayFactor = options?.decayFactor ?? 0.8;
+        const archiveThreshold = options?.archiveThreshold ?? 0.2;
+        const dryRun = options?.dryRun ?? false;
+        const result = {
+            analyzed: 0,
+            decayed: 0,
+            archived: 0,
+        };
+        const memories = await this.client.list({ type: 'memory', status: 'active', limit: 500 });
+        result.analyzed = memories.length;
+        const now = Date.now();
+        const thresholdMs = daysThreshold * 24 * 60 * 60 * 1000;
+        for (const memory of memories) {
+            const content = memory.content;
+            if (!content)
+                continue;
+            // Calculate age
+            const updatedAt = memory.updatedAt ? new Date(memory.updatedAt).getTime() : now;
+            const lastAccessed = content.lastAccessed
+                ? new Date(content.lastAccessed).getTime()
+                : updatedAt;
+            const age = now - Math.max(updatedAt, lastAccessed);
+            if (age > thresholdMs) {
+                // Calculate decay score
+                const currentScore = content.decayScore ?? 1.0;
+                const newScore = currentScore * decayFactor;
+                if (!dryRun) {
+                    if (newScore < archiveThreshold) {
+                        // Archive the memory
+                        await this.client.update(memory.id, { status: 'archived' });
+                        result.archived++;
+                    }
+                    else {
+                        // Update decay score
+                        await this.client.update(memory.id, {
+                            content: { ...content, decayScore: newScore },
+                        });
+                        result.decayed++;
+                    }
+                }
+                else {
+                    if (newScore < archiveThreshold) {
+                        result.archived++;
+                    }
+                    else {
+                        result.decayed++;
+                    }
+                }
+            }
+        }
+        return result;
+    }
+    /**
+     * Detect conflicts between memories
+     */
+    async detectConflicts(memories) {
+        const items = memories ?? await this.client.list({ type: 'memory', limit: 500 });
+        const conflicts = [];
+        // Group by domain
+        const byDomain = new Map();
+        for (const item of items) {
+            const content = item.content;
+            if (!content?.domain)
+                continue;
+            const domainItems = byDomain.get(content.domain) ?? [];
+            domainItems.push(item);
+            byDomain.set(content.domain, domainItems);
+        }
+        // Check each domain for conflicts
+        for (const [domain, domainItems] of byDomain) {
+            if (domainItems.length < 2)
+                continue;
+            // Look for conflicting information
+            for (let i = 0; i < domainItems.length; i++) {
+                for (let j = i + 1; j < domainItems.length; j++) {
+                    const a = domainItems[i];
+                    const b = domainItems[j];
+                    const contentA = a.content;
+                    const contentB = b.content;
+                    // Check for contradictions in titles
+                    const conflict = this.checkContradiction(contentA, contentB);
+                    if (conflict) {
+                        conflicts.push({
+                            memoryIds: [a.id, b.id],
+                            titles: [contentA.title, contentB.title],
+                            reason: conflict.reason,
+                            suggestion: conflict.suggestion,
+                        });
+                    }
+                }
+            }
+        }
+        return conflicts;
+    }
+    /**
+     * Record memory access (for decay algorithm)
+     */
+    async recordAccess(memoryId) {
+        const memory = await this.client.get(memoryId);
+        if (!memory)
+            return;
+        const content = memory.content;
+        if (!content)
+            return;
+        const updated = {
+            ...content,
+            accessCount: (content.accessCount ?? 0) + 1,
+            lastAccessed: new Date().toISOString(),
+            decayScore: 1.0, // Reset decay on access
+        };
+        await this.client.update(memoryId, {
+            content: updated,
+        });
+    }
+    // ===========================================================================
+    // PRIVATE METHODS
+    // ===========================================================================
+    /**
+     * Merge multiple memories into one
+     */
+    async mergeMemories(group) {
+        if (group.length < 2)
+            return null;
+        // Sort by priority and date (newest first)
+        const sorted = group.sort((a, b) => {
+            const priorityOrder = { critical: 4, high: 3, medium: 2, low: 1 };
+            const pA = priorityOrder[a.priority] ?? 2;
+            const pB = priorityOrder[b.priority] ?? 2;
+            if (pA !== pB)
+                return pB - pA;
+            const dateA = a.updatedAt ? new Date(a.updatedAt).getTime() : 0;
+            const dateB = b.updatedAt ? new Date(b.updatedAt).getTime() : 0;
+            return dateB - dateA;
+        });
+        const primary = sorted[0];
+        const primaryContent = primary.content;
+        const others = sorted.slice(1);
+        // Merge content
+        const mergedBody = [
+            primaryContent.body,
+            '',
+            '---',
+            'Merged from related memories:',
+            ...others.map(o => {
+                const c = o.content;
+                return `- ${c.title}: ${c.body.slice(0, 100)}...`;
+            }),
+        ].join('\n');
+        // Collect all tags
+        const allTags = new Set();
+        for (const item of group) {
+            const tags = item.tags ?? [];
+            tags.forEach(t => allTags.add(t));
+        }
+        // Update primary with merged content
+        const mergedContent = {
+            ...primaryContent,
+            body: mergedBody,
+            mergedFrom: others.map(o => o.id),
+        };
+        await this.client.update(primary.id, {
+            content: mergedContent,
+            tags: Array.from(allTags),
+        });
+        // Archive others
+        for (const other of others) {
+            await this.client.update(other.id, { status: 'archived' });
+        }
+        return primary;
+    }
+    /**
+     * Check for contradictions between two memories
+     */
+    checkContradiction(a, b) {
+        // Look for negation patterns
+        const negationPatterns = [
+            { pos: /should/i, neg: /should not|shouldn't/i },
+            { pos: /must/i, neg: /must not|mustn't/i },
+            { pos: /always/i, neg: /never/i },
+            { pos: /use/i, neg: /don't use|avoid/i },
+            { pos: /enable/i, neg: /disable/i },
+        ];
+        for (const pattern of negationPatterns) {
+            const aHasPos = pattern.pos.test(a.body) && !pattern.neg.test(a.body);
+            const bHasNeg = pattern.neg.test(b.body);
+            const bHasPos = pattern.pos.test(b.body) && !pattern.neg.test(b.body);
+            const aHasNeg = pattern.neg.test(a.body);
+            if ((aHasPos && bHasNeg) || (bHasPos && aHasNeg)) {
+                return {
+                    reason: 'Potential contradiction detected in recommendations',
+                    suggestion: 'Review these memories and consolidate into a single, consistent guideline',
+                };
+            }
+        }
+        // Check for version/date conflicts
+        const datePattern = /\b(2024|2025)\b/;
+        const aDate = a.body.match(datePattern)?.[0];
+        const bDate = b.body.match(datePattern)?.[0];
+        if (aDate && bDate && aDate !== bDate) {
+            return {
+                reason: `References different time periods (${aDate} vs ${bDate})`,
+                suggestion: 'Consider archiving the older memory or updating it',
+            };
+        }
+        return null;
+    }
+}
+// =============================================================================
+// FACTORY
+// =============================================================================
+/**
+ * Create a memory consolidation service
+ */
+export function createConsolidationService(client, searchService) {
+    return new MemoryConsolidationService(client, searchService);
+}
+//# sourceMappingURL=memory-consolidation.js.map