snow-flow 1.3.4 → 1.3.5

package/dist/memory/hierarchical-memory-system.js

@@ -0,0 +1,401 @@
+"use strict";
+/**
+ * Hierarchical Memory System for Snow-Flow
+ * Extends base MemorySystem with ServiceNow-specific patterns
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HierarchicalMemorySystem = void 0;
+const memory_system_1 = require("./memory-system");
+const logger_1 = require("../utils/logger");
+class HierarchicalMemorySystem extends memory_system_1.MemorySystem {
+    constructor(options) {
+        super(options);
+        this.namespaceIndex = new Map();
+        this.typeIndex = new Map();
+        this.tagIndex = new Map();
+        this.logger = new logger_1.Logger('HierarchicalMemorySystem');
+    }
+    /**
+     * Initialize with enhanced tables for hierarchical storage
+     */
+    async initialize() {
+        await super.initialize();
+        await this.createHierarchicalTables();
+        await this.buildIndexes();
+    }
+    /**
+     * Create additional tables for hierarchical organization
+     */
+    async createHierarchicalTables() {
+        const tables = [
+            // Enhanced memory store with namespace and type
+            `CREATE TABLE IF NOT EXISTS hierarchical_memory (
+        key TEXT PRIMARY KEY,
+        namespace TEXT NOT NULL,
+        type TEXT NOT NULL,
+        value TEXT NOT NULL,
+        metadata TEXT,
+        ttl INTEGER,
+        created_at INTEGER DEFAULT (strftime('%s', 'now') * 1000),
+        updated_at INTEGER DEFAULT (strftime('%s', 'now') * 1000),
+        expires_at INTEGER,
+        version INTEGER DEFAULT 1
+      )`,
+            // Tag associations
+            `CREATE TABLE IF NOT EXISTS memory_tags (
+        key TEXT NOT NULL,
+        tag TEXT NOT NULL,
+        PRIMARY KEY (key, tag),
+        FOREIGN KEY (key) REFERENCES hierarchical_memory(key) ON DELETE CASCADE
+      )`,
+            // Relationships between memory entries
+            `CREATE TABLE IF NOT EXISTS memory_relationships (
+        source_key TEXT NOT NULL,
+        target_key TEXT NOT NULL,
+        relationship_type TEXT NOT NULL,
+        metadata TEXT,
+        created_at INTEGER DEFAULT (strftime('%s', 'now') * 1000),
+        PRIMARY KEY (source_key, target_key, relationship_type),
+        FOREIGN KEY (source_key) REFERENCES hierarchical_memory(key) ON DELETE CASCADE,
+        FOREIGN KEY (target_key) REFERENCES hierarchical_memory(key) ON DELETE CASCADE
+      )`,
+            // Agent memory associations
+            `CREATE TABLE IF NOT EXISTS agent_memory (
+        agent_id TEXT NOT NULL,
+        memory_key TEXT NOT NULL,
+        access_type TEXT NOT NULL, -- 'read', 'write', 'owner'
+        accessed_at INTEGER DEFAULT (strftime('%s', 'now') * 1000),
+        PRIMARY KEY (agent_id, memory_key),
+        FOREIGN KEY (memory_key) REFERENCES hierarchical_memory(key) ON DELETE CASCADE
+      )`,
+            // Memory access patterns for learning
+            `CREATE TABLE IF NOT EXISTS memory_access_patterns (
+        pattern_id TEXT PRIMARY KEY,
+        pattern_type TEXT NOT NULL,
+        frequency INTEGER DEFAULT 1,
+        last_accessed INTEGER DEFAULT (strftime('%s', 'now') * 1000),
+        metadata TEXT
+      )`,
+        ];
+        for (const table of tables) {
+            await this.execute(table);
+        }
+        // Create indexes for performance
+        const indexes = [
+            'CREATE INDEX IF NOT EXISTS idx_namespace ON hierarchical_memory(namespace)',
+            'CREATE INDEX IF NOT EXISTS idx_type ON hierarchical_memory(type)',
+            'CREATE INDEX IF NOT EXISTS idx_expires ON hierarchical_memory(expires_at)',
+            'CREATE INDEX IF NOT EXISTS idx_tags ON memory_tags(tag)',
+            'CREATE INDEX IF NOT EXISTS idx_relationships ON memory_relationships(relationship_type)',
+            'CREATE INDEX IF NOT EXISTS idx_agent_memory ON agent_memory(agent_id)',
+        ];
+        for (const index of indexes) {
+            await this.execute(index);
+        }
+    }
+    /**
+     * Store with hierarchical organization
+     */
+    async storeHierarchical(entry) {
+        if (!entry.key)
+            throw new Error('Key is required');
+        // Extract namespace and type from key pattern
+        const keyParts = entry.key.split('/');
+        const namespace = entry.namespace || keyParts[0] || 'default';
+        const type = entry.type || keyParts[1] || 'general';
+        const metadata = {
+            created: new Date().toISOString(),
+            updated: new Date().toISOString(),
+            version: 1,
+            tags: entry.metadata?.tags || [],
+            relationships: entry.metadata?.relationships || {},
+            dependencies: entry.metadata?.dependencies || {},
+            ...entry.metadata,
+        };
+        const ttl = entry.ttl || 86400000 * 7; // 7 days default
+        const expiresAt = Date.now() + ttl;
+        // Check if exists for versioning
+        const existing = await this.getHierarchical(entry.key);
+        if (existing) {
+            metadata.version = (existing.metadata?.version || 0) + 1;
+            metadata.created = existing.metadata?.created || metadata.created;
+        }
+        // Store in hierarchical table
+        await this.execute(`
+      INSERT OR REPLACE INTO hierarchical_memory 
+      (key, namespace, type, value, metadata, ttl, expires_at, version, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `, [
+            entry.key,
+            namespace,
+            type,
+            JSON.stringify(entry.value),
+            JSON.stringify(metadata),
+            ttl,
+            expiresAt,
+            metadata.version,
+            Date.now()
+        ]);
+        // Update tags
+        if (metadata.tags.length > 0) {
+            await this.updateTags(entry.key, metadata.tags);
+        }
+        // Update indexes
+        this.updateLocalIndexes(entry.key, namespace, type, metadata.tags);
+        // Store in base system for compatibility
+        await super.store(entry.key, entry.value, ttl);
+        this.emit('memory:hierarchical:stored', { key: entry.key, namespace, type });
+    }
+    /**
+     * Get with full hierarchical metadata
+     */
+    async getHierarchical(key) {
+        const result = await this.query(`
+      SELECT * FROM hierarchical_memory 
+      WHERE key = ? AND expires_at > ?
+    `, [key, Date.now()]);
+        if (!result || result.length === 0)
+            return null;
+        const row = result[0];
+        const tags = await this.getTags(key);
+        return {
+            key: row.key,
+            namespace: row.namespace,
+            type: row.type,
+            value: JSON.parse(row.value),
+            metadata: {
+                ...JSON.parse(row.metadata || '{}'),
+                tags,
+            },
+            ttl: row.ttl,
+        };
+    }
+    /**
+     * Search with hierarchical patterns
+     */
+    async search(options) {
+        let sql = 'SELECT DISTINCT h.* FROM hierarchical_memory h';
+        const params = [];
+        const conditions = [];
+        // Join with tags if needed
+        if (options.tags && options.tags.length > 0) {
+            sql += ' INNER JOIN memory_tags t ON h.key = t.key';
+            conditions.push(`t.tag IN (${options.tags.map(() => '?').join(',')})`);
+            params.push(...options.tags);
+        }
+        // Add namespace filter
+        if (options.namespace) {
+            conditions.push('h.namespace = ?');
+            params.push(options.namespace);
+        }
+        // Add type filter
+        if (options.type) {
+            conditions.push('h.type = ?');
+            params.push(options.type);
+        }
+        // Add pattern matching
+        if (options.pattern) {
+            conditions.push('h.key LIKE ?');
+            params.push(`%${options.pattern}%`);
+        }
+        // Add expiration filter
+        if (!options.includeExpired) {
+            conditions.push('h.expires_at > ?');
+            params.push(Date.now());
+        }
+        // Combine conditions
+        if (conditions.length > 0) {
+            sql += ' WHERE ' + conditions.join(' AND ');
+        }
+        // Add ordering and limit
+        sql += ' ORDER BY h.updated_at DESC';
+        if (options.limit) {
+            sql += ' LIMIT ?';
+            params.push(options.limit);
+        }
+        const results = await this.query(sql, params);
+        // Fetch tags and format results
+        const entries = [];
+        for (const row of results) {
+            const tags = await this.getTags(row.key);
+            entries.push({
+                key: row.key,
+                namespace: row.namespace,
+                type: row.type,
+                value: JSON.parse(row.value),
+                metadata: {
+                    ...JSON.parse(row.metadata || '{}'),
+                    tags,
+                },
+                ttl: row.ttl,
+            });
+        }
+        return entries;
+    }
+    /**
+     * Create relationship between entries
+     */
+    async createRelationship(sourceKey, targetKey, relationshipType, metadata) {
+        await this.execute(`
+      INSERT OR REPLACE INTO memory_relationships 
+      (source_key, target_key, relationship_type, metadata)
+      VALUES (?, ?, ?, ?)
+    `, [sourceKey, targetKey, relationshipType, JSON.stringify(metadata || {})]);
+        this.emit('memory:relationship:created', { sourceKey, targetKey, relationshipType });
+    }
+    /**
+     * Get related entries
+     */
+    async getRelated(key, relationshipType) {
+        let sql = `
+      SELECT DISTINCT h.* 
+      FROM hierarchical_memory h
+      INNER JOIN memory_relationships r ON (h.key = r.target_key OR h.key = r.source_key)
+      WHERE (r.source_key = ? OR r.target_key = ?) AND h.key != ?
+    `;
+        const params = [key, key, key];
+        if (relationshipType) {
+            sql += ' AND r.relationship_type = ?';
+            params.push(relationshipType);
+        }
+        const results = await this.query(sql, params);
+        const entries = [];
+        for (const row of results) {
+            const entry = await this.getHierarchical(row.key);
+            if (entry)
+                entries.push(entry);
+        }
+        return entries;
+    }
+    /**
+     * Associate memory with agent
+     */
+    async associateWithAgent(agentId, memoryKey, accessType) {
+        await this.execute(`
+      INSERT OR REPLACE INTO agent_memory (agent_id, memory_key, access_type)
+      VALUES (?, ?, ?)
+    `, [agentId, memoryKey, accessType]);
+    }
+    /**
+     * Get agent's memory entries
+     */
+    async getAgentMemory(agentId, accessType) {
+        let sql = `
+      SELECT h.* FROM hierarchical_memory h
+      INNER JOIN agent_memory a ON h.key = a.memory_key
+      WHERE a.agent_id = ?
+    `;
+        const params = [agentId];
+        if (accessType) {
+            sql += ' AND a.access_type = ?';
+            params.push(accessType);
+        }
+        const results = await this.query(sql, params);
+        const entries = [];
+        for (const row of results) {
+            const entry = await this.getHierarchical(row.key);
+            if (entry)
+                entries.push(entry);
+        }
+        return entries;
+    }
+    /**
+     * Track access pattern for learning
+     */
+    async trackAccessPattern(patternType, metadata) {
+        const patternId = `${patternType}_${Date.now()}`;
+        await this.execute(`
+      INSERT INTO memory_access_patterns (pattern_id, pattern_type, metadata)
+      VALUES (?, ?, ?)
+      ON CONFLICT(pattern_id) DO UPDATE SET
+        frequency = frequency + 1,
+        last_accessed = strftime('%s', 'now') * 1000
+    `, [patternId, patternType, JSON.stringify(metadata || {})]);
+    }
+    /**
+     * Get namespace statistics
+     */
+    async getNamespaceStats() {
+        const results = await this.query(`
+      SELECT namespace, COUNT(*) as count
+      FROM hierarchical_memory
+      WHERE expires_at > ?
+      GROUP BY namespace
+    `, [Date.now()]);
+        const stats = {};
+        for (const row of results) {
+            stats[row.namespace] = row.count;
+        }
+        return stats;
+    }
+    /**
+     * Helper methods
+     */
+    async updateTags(key, tags) {
+        // Remove existing tags
+        await this.execute('DELETE FROM memory_tags WHERE key = ?', [key]);
+        // Insert new tags
+        for (const tag of tags) {
+            await this.execute('INSERT INTO memory_tags (key, tag) VALUES (?, ?)', [key, tag]);
+        }
+    }
+    async getTags(key) {
+        const results = await this.query('SELECT tag FROM memory_tags WHERE key = ?', [key]);
+        return results.map(r => r.tag);
+    }
+    updateLocalIndexes(key, namespace, type, tags) {
+        // Update namespace index
+        if (!this.namespaceIndex.has(namespace)) {
+            this.namespaceIndex.set(namespace, new Set());
+        }
+        this.namespaceIndex.get(namespace).add(key);
+        // Update type index
+        if (!this.typeIndex.has(type)) {
+            this.typeIndex.set(type, new Set());
+        }
+        this.typeIndex.get(type).add(key);
+        // Update tag index
+        for (const tag of tags) {
+            if (!this.tagIndex.has(tag)) {
+                this.tagIndex.set(tag, new Set());
+            }
+            this.tagIndex.get(tag).add(key);
+        }
+    }
+    async buildIndexes() {
+        // Build indexes from existing data
+        const results = await this.query(`
+      SELECT key, namespace, type FROM hierarchical_memory 
+      WHERE expires_at > ?
+    `, [Date.now()]);
+        for (const row of results) {
+            const tags = await this.getTags(row.key);
+            this.updateLocalIndexes(row.key, row.namespace, row.type, tags);
+        }
+    }
+    /**
+     * Cleanup expired entries
+     */
+    async cleanupExpired() {
+        const result = await this.query(`
+      DELETE FROM hierarchical_memory 
+      WHERE expires_at <= ?
+      RETURNING key
+    `, [Date.now()]);
+        // Update local indexes
+        for (const row of result) {
+            // Remove from indexes
+            for (const [namespace, keys] of this.namespaceIndex) {
+                keys.delete(row.key);
+            }
+            for (const [type, keys] of this.typeIndex) {
+                keys.delete(row.key);
+            }
+            for (const [tag, keys] of this.tagIndex) {
+                keys.delete(row.key);
+            }
+        }
+        return result.length;
+    }
+}
+exports.HierarchicalMemorySystem = HierarchicalMemorySystem;

package/dist/memory/snow-flow-memory-patterns.js

@@ -0,0 +1,199 @@
+"use strict";
+/**
+ * Snow-Flow Memory Patterns
+ * Hierarchical memory organization for ServiceNow development
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SnowFlowWorkflowExamples = exports.SNOW_FLOW_AGENT_CAPABILITIES = exports.SnowFlowMemoryOrganizer = void 0;
+class SnowFlowMemoryOrganizer {
+    /**
+     * Generate hierarchical key for ServiceNow artifacts
+     */
+    static generateKey(category, type, name) {
+        const sanitizedName = name.toLowerCase().replace(/\s+/g, '_').replace(/[^a-z0-9_]/g, '');
+        return `${category}/${type}/${sanitizedName}`;
+    }
+    /**
+     * Store widget information with metadata
+     */
+    static getWidgetMemoryStructure(widgetName) {
+        return {
+            key: this.generateKey('artifacts', 'widgets', widgetName),
+            metadata: {
+                type: 'service_portal_widget',
+                created: new Date().toISOString(),
+                tags: ['widget', 'ui', 'service-portal'],
+            },
+            searchableFields: ['name', 'title', 'description', 'template', 'script'],
+        };
+    }
+    /**
+     * Store flow information with relationships
+     */
+    static getFlowMemoryStructure(flowName) {
+        return {
+            key: this.generateKey('artifacts', 'flows', flowName),
+            metadata: {
+                type: 'flow_designer',
+                created: new Date().toISOString(),
+                tags: ['flow', 'automation', 'workflow'],
+            },
+            relationships: {
+                triggers: [],
+                actions: [],
+                subflows: [],
+                tables: [],
+            },
+        };
+    }
+    /**
+     * Store script information with dependencies
+     */
+    static getScriptMemoryStructure(scriptName, scriptType) {
+        return {
+            key: this.generateKey('code', `${scriptType}-scripts`, scriptName),
+            metadata: {
+                type: scriptType,
+                created: new Date().toISOString(),
+                tags: ['script', scriptType],
+            },
+            dependencies: {
+                tables: [],
+                scriptIncludes: [],
+                glideRecords: [],
+                apis: [],
+            },
+        };
+    }
+    /**
+     * Store test results with coverage
+     */
+    static getTestMemoryStructure(testName, testType) {
+        return {
+            key: this.generateKey('tests', testType, testName),
+            metadata: {
+                type: `${testType}_test`,
+                executed: new Date().toISOString(),
+                tags: ['test', testType],
+            },
+            results: {
+                passed: 0,
+                failed: 0,
+                skipped: 0,
+                coverage: 0,
+                duration: 0,
+            },
+        };
+    }
+    /**
+     * Store deployment information
+     */
+    static getDeploymentMemoryStructure(updateSetName) {
+        return {
+            key: this.generateKey('deploy', 'update-sets', updateSetName),
+            metadata: {
+                type: 'update_set',
+                created: new Date().toISOString(),
+                tags: ['deployment', 'update-set'],
+            },
+            contents: {
+                artifacts: [],
+                dependencies: [],
+                conflicts: [],
+                targetInstance: '',
+            },
+        };
+    }
+}
+exports.SnowFlowMemoryOrganizer = SnowFlowMemoryOrganizer;
+/**
+ * Agent capability mappings for ServiceNow development
+ */
+exports.SNOW_FLOW_AGENT_CAPABILITIES = {
+    // UI Development
+    'widget-developer': ['html', 'css', 'javascript', 'angular', 'service-portal-api'],
+    'ui-designer': ['ui-builder', 'themes', 'branding', 'responsive-design'],
+    // Flow Development
+    'flow-builder': ['flow-designer', 'triggers', 'actions', 'subflows', 'approvals'],
+    'integration-specialist': ['rest-api', 'soap', 'mid-server', 'integration-hub'],
+    // Scripting
+    'script-developer': ['glide-api', 'business-rules', 'script-includes', 'scheduled-jobs'],
+    'client-scripter': ['client-scripts', 'ui-policies', 'catalog-client-scripts'],
+    // Data & Configuration
+    'data-architect': ['tables', 'relationships', 'acls', 'data-policies'],
+    'security-engineer': ['security-rules', 'authentication', 'encryption', 'audit'],
+    // Testing & Quality
+    'test-engineer': ['atf', 'unit-testing', 'regression-testing', 'performance-testing'],
+    'quality-analyst': ['code-review', 'best-practices', 'performance-optimization'],
+    // Documentation & Training
+    'technical-writer': ['api-docs', 'user-guides', 'runbooks', 'knowledge-articles'],
+    'solution-architect': ['architecture-docs', 'design-patterns', 'roadmaps'],
+};
+/**
+ * Example usage patterns for ServiceNow development
+ */
+class SnowFlowWorkflowExamples {
+    /**
+     * Example: Create incident dashboard widget
+     */
+    static async createIncidentDashboard() {
+        // 1. Store requirements
+        await memory.store('specs/requirements/incident-dashboard', {
+            title: 'Incident Dashboard Widget',
+            features: ['real-time updates', 'priority filtering', 'assignment groups'],
+            acceptance: ['shows active incidents', 'updates every 30s', 'filterable'],
+        });
+        // 2. Spawn specialized agents
+        const agents = await Promise.all([
+            agentSpawn({ type: 'widget-developer', capabilities: exports.SNOW_FLOW_AGENT_CAPABILITIES['widget-developer'] }),
+            agentSpawn({ type: 'ui-designer', capabilities: exports.SNOW_FLOW_AGENT_CAPABILITIES['ui-designer'] }),
+            agentSpawn({ type: 'test-engineer', capabilities: exports.SNOW_FLOW_AGENT_CAPABILITIES['test-engineer'] }),
+        ]);
+        // 3. Coordinate work
+        await agentCommunicate({
+            to: agents[0].id,
+            message: 'Create widget structure based on specs/requirements/incident-dashboard'
+        });
+        await agentCommunicate({
+            to: agents[1].id,
+            message: 'Design responsive layout for incident data visualization'
+        });
+        // 4. Store artifacts
+        await memory.store('artifacts/widgets/incident-dashboard', {
+            html: '<!-- widget template -->',
+            css: '/* widget styles */',
+            clientScript: '// client controller',
+            serverScript: '// server script',
+        });
+        // 5. Track progress
+        await taskUpdate({ taskId: 'incident-dashboard', progress: 100 });
+    }
+    /**
+     * Example: Create approval workflow
+     */
+    static async createApprovalFlow() {
+        // 1. Store flow design
+        await memory.store('architecture/decisions/approval-flow', {
+            pattern: 'multi-level-approval',
+            levels: ['manager', 'director', 'vp'],
+            escalation: 'time-based',
+        });
+        // 2. Spawn flow specialists
+        const flowBuilder = await agentSpawn({
+            type: 'flow-builder',
+            capabilities: exports.SNOW_FLOW_AGENT_CAPABILITIES['flow-builder']
+        });
+        // 3. Build flow with memory reference
+        await agentCommunicate({
+            to: flowBuilder.id,
+            message: 'Build approval flow using architecture/decisions/approval-flow pattern'
+        });
+        // 4. Store flow artifact
+        await memory.store('artifacts/flows/equipment-approval', {
+            trigger: 'record.inserted',
+            actions: ['lookup-manager', 'send-approval', 'wait-response', 'update-record'],
+            table: 'x_company_equipment',
+        });
+    }
+}
+exports.SnowFlowWorkflowExamples = SnowFlowWorkflowExamples;

package/dist/queen/queen-memory-system.js

@@ -0,0 +1,313 @@
+"use strict";
+/**
+ * Queen Memory System with Hierarchical Patterns
+ * Enhanced memory system for ServiceNow Queen Agent coordination
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueenMemorySystem = void 0;
+const snow_flow_memory_patterns_1 = require("../memory/snow-flow-memory-patterns");
+const logger_1 = require("../utils/logger");
+const events_1 = require("events");
+class QueenMemorySystem extends events_1.EventEmitter {
+    constructor(memory) {
+        super();
+        this.objectiveCache = new Map();
+        this.agentIndex = new Map(); // agentId -> memory keys
+        this.memory = memory;
+        this.logger = new logger_1.Logger('QueenMemorySystem');
+    }
+    /**
+     * Store objective with full context
+     */
+    async storeObjective(objectiveId, objective) {
+        const key = `objectives/${objectiveId}/definition`;
+        await this.memory.storeHierarchical({
+            key,
+            namespace: 'objectives',
+            type: 'definition',
+            value: objective,
+            metadata: {
+                tags: ['objective', 'requirement', objective.priority || 'medium'],
+                created: new Date().toISOString(),
+            },
+            ttl: 86400000 * 30, // 30 days
+        });
+        this.objectiveCache.set(objectiveId, objective);
+        this.emit('objective:stored', { objectiveId, objective });
+    }
+    /**
+     * Store task analysis with patterns
+     */
+    async storeTaskAnalysis(objectiveId, analysis) {
+        const key = `objectives/${objectiveId}/analysis`;
+        await this.memory.storeHierarchical({
+            key,
+            namespace: 'objectives',
+            type: 'analysis',
+            value: analysis,
+            metadata: {
+                tags: ['analysis', analysis.taskType, 'complexity-' + analysis.estimatedComplexity],
+                relationships: {
+                    requires: analysis.dependencies || [],
+                    similar: analysis.similarPatterns || [],
+                },
+            },
+        });
+        // Track patterns for learning
+        if (analysis.similarPatterns && analysis.similarPatterns.length > 0) {
+            await this.memory.trackAccessPattern('pattern_reuse', {
+                objectiveId,
+                patterns: analysis.similarPatterns,
+            });
+        }
+    }
+    /**
+     * Store agent profile with capabilities
+     */
+    async storeAgentProfile(agentId, profile) {
+        const key = `agents/${agentId}/profile`;
+        await this.memory.storeHierarchical({
+            key,
+            namespace: 'agents',
+            type: 'profile',
+            value: profile,
+            metadata: {
+                tags: ['agent', profile.type, profile.status, ...profile.capabilities],
+            },
+        });
+        // Update agent index
+        if (!this.agentIndex.has(agentId)) {
+            this.agentIndex.set(agentId, new Set());
+        }
+        this.agentIndex.get(agentId).add(key);
+    }
+    /**
+     * Store agent task assignment
+     */
+    async storeAgentTask(agentId, taskId, task) {
+        const key = `agents/${agentId}/tasks/${taskId}`;
+        await this.memory.storeHierarchical({
+            key,
+            namespace: 'agents',
+            type: 'task',
+            value: task,
+            metadata: {
+                tags: ['task', 'agent-task', `priority-${task.priority}`],
+                relationships: {
+                    assignedTo: [agentId],
+                    dependsOn: task.dependencies || [],
+                },
+            },
+        });
+        // Create relationship
+        await this.memory.createRelationship(`agents/${agentId}/profile`, key, 'assigned_task', { assignedAt: new Date().toISOString() });
+        this.agentIndex.get(agentId)?.add(key);
+    }
+    /**
+     * Store ServiceNow artifact with full metadata
+     */
+    async storeArtifact(artifact) {
+        const key = `artifacts/${artifact.type}s/${artifact.name}`;
+        const memoryStructure = this.getArtifactMemoryStructure(artifact);
+        await this.memory.storeHierarchical({
+            key,
+            namespace: 'artifacts',
+            type: artifact.type,
+            value: {
+                ...artifact,
+                memoryMetadata: memoryStructure,
+            },
+            metadata: {
+                tags: ['artifact', artifact.type, 'servicenow'],
+                relationships: {
+                    dependsOn: artifact.dependencies || [],
+                    deployedTo: artifact.deployment ? [artifact.deployment.instance] : [],
+                },
+            },
+        });
+        // Store deployment info separately if exists
+        if (artifact.deployment) {
+            await this.storeDeployment(artifact.name, artifact.deployment);
+        }
+    }
+    /**
+     * Store deployment information
+     */
+    async storeDeployment(artifactName, deployment) {
+        const deploymentId = `${artifactName}_${deployment.instance}_${Date.now()}`;
+        const key = `artifacts/deployments/${deploymentId}`;
+        await this.memory.storeHierarchical({
+            key,
+            namespace: 'artifacts',
+            type: 'deployment',
+            value: deployment,
+            metadata: {
+                tags: ['deployment', deployment.status, deployment.instance],
+            },
+        });
+    }
+    /**
+     * Store successful pattern for learning
+     */
+    async storeSuccessfulPattern(pattern) {
+        const key = `patterns/successful/${pattern.type}/${Date.now()}`;
+        await this.memory.storeHierarchical({
+            key,
+            namespace: 'patterns',
+            type: 'successful',
+            value: pattern,
+            metadata: {
+                tags: ['pattern', 'success', pattern.type],
+            },
+            ttl: 86400000 * 90, // 90 days
+        });
+        this.emit('pattern:learned', { type: 'success', pattern });
+    }
+    /**
+     * Store failure pattern for avoidance
+     */
+    async storeFailurePattern(pattern) {
+        const key = `patterns/failures/${pattern.type}/${Date.now()}`;
+        await this.memory.storeHierarchical({
+            key,
+            namespace: 'patterns',
+            type: 'failure',
+            value: pattern,
+            metadata: {
+                tags: ['pattern', 'failure', pattern.type],
+            },
+            ttl: 86400000 * 90, // 90 days
+        });
+        this.emit('pattern:learned', { type: 'failure', pattern });
+    }
+    /**
+     * Find similar objectives from history
+     */
+    async findSimilarObjectives(objective, limit = 5) {
+        // Search by objective keywords
+        const keywords = objective.toLowerCase().split(' ')
+            .filter(word => word.length > 3);
+        const results = await this.memory.search({
+            namespace: 'objectives',
+            type: 'definition',
+            limit: limit * 2, // Get more to filter
+        });
+        // Score by keyword matches
+        const scored = results.map(entry => {
+            const desc = (entry.value.description || '').toLowerCase();
+            const score = keywords.reduce((sum, keyword) => sum + (desc.includes(keyword) ? 1 : 0), 0);
+            return { entry, score };
+        });
+        // Return top matches
+        return scored
+            .filter(item => item.score > 0)
+            .sort((a, b) => b.score - a.score)
+            .slice(0, limit)
+            .map(item => item.entry);
+    }
+    /**
+     * Get successful patterns for a task type
+     */
+    async getSuccessfulPatterns(taskType) {
+        return await this.memory.search({
+            namespace: 'patterns',
+            type: 'successful',
+            tags: [taskType],
+            limit: 10,
+        });
+    }
+    /**
+     * Get agent's complete memory
+     */
+    async getAgentMemory(agentId) {
+        return await this.memory.getAgentMemory(agentId);
+    }
+    /**
+     * Get swarm coordination data
+     */
+    async getSwarmData(swarmId) {
+        const [topology, communication, consensus] = await Promise.all([
+            this.memory.getHierarchical(`swarm/${swarmId}/topology`),
+            this.memory.search({
+                namespace: 'swarm',
+                pattern: `${swarmId}/communication`,
+            }),
+            this.memory.search({
+                namespace: 'swarm',
+                pattern: `${swarmId}/consensus`,
+            }),
+        ]);
+        return {
+            topology: topology?.value || null,
+            communication: communication.map(c => c.value),
+            consensus: consensus.map(c => c.value),
+        };
+    }
+    /**
+     * Store inter-agent communication
+     */
+    async storeAgentCommunication(fromAgent, toAgent, message, swarmId) {
+        const key = swarmId
+            ? `swarm/${swarmId}/communication/${Date.now()}`
+            : `agents/communication/${fromAgent}_to_${toAgent}_${Date.now()}`;
+        await this.memory.storeHierarchical({
+            key,
+            namespace: swarmId ? 'swarm' : 'agents',
+            type: 'communication',
+            value: {
+                from: fromAgent,
+                to: toAgent,
+                message,
+                timestamp: new Date().toISOString(),
+            },
+            metadata: {
+                tags: ['communication', 'agent-message'],
+                relationships: {
+                    from: [fromAgent],
+                    to: [toAgent],
+                },
+            },
+        });
+    }
+    /**
+     * Get namespace statistics for monitoring
+     */
+    async getMemoryStats() {
+        const namespaces = await this.memory.getNamespaceStats();
+        return {
+            namespaces,
+            totalEntries: Object.values(namespaces).reduce((sum, count) => sum + count, 0),
+            patterns: namespaces['patterns'] || 0,
+            artifacts: namespaces['artifacts'] || 0,
+            agents: namespaces['agents'] || 0,
+        };
+    }
+    /**
+     * Helper to get artifact memory structure
+     */
+    getArtifactMemoryStructure(artifact) {
+        switch (artifact.type) {
+            case 'widget':
+                return snow_flow_memory_patterns_1.SnowFlowMemoryOrganizer.getWidgetMemoryStructure(artifact.name);
+            case 'flow':
+                return snow_flow_memory_patterns_1.SnowFlowMemoryOrganizer.getFlowMemoryStructure(artifact.name);
+            case 'script':
+                return snow_flow_memory_patterns_1.SnowFlowMemoryOrganizer.getScriptMemoryStructure(artifact.name, artifact.scriptType || 'server');
+            default:
+                return {
+                    key: snow_flow_memory_patterns_1.SnowFlowMemoryOrganizer.generateKey('artifacts', artifact.type, artifact.name),
+                    metadata: {
+                        type: artifact.type,
+                        created: new Date().toISOString(),
+                    },
+                };
+        }
+    }
+    /**
+     * Clean up expired entries
+     */
+    async cleanup() {
+        return await this.memory.cleanupExpired();
+    }
+}
+exports.QueenMemorySystem = QueenMemorySystem;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "snow-flow",
-  "version": "1.3.4",
+  "version": "1.3.5",
   "description": "ServiceNow Queen Agent - Hive-Mind Intelligence for ServiceNow Development inspired by claude-flow. Transform complex workflows into elegant one-command orchestration.",
   "main": "dist/index.js",
   "type": "commonjs",