agentic-qe 2.5.4 → 2.5.6

package/dist/core/memory/SwarmMemoryManager.js

@@ -52,8 +52,15 @@ const types_1 = require("../../types");
 /**
  * SwarmMemoryManager - Manages persistent memory for agent swarm coordination
  *
+ * IMPORTANT: This class uses better-sqlite3 which is intentionally synchronous.
+ * All database operations are synchronous for maximum performance.
+ * Only initialize() is async due to filesystem operations.
+ *
+ * Issue #65: Converted from misleading async/await pattern to honest synchronous API.
+ * See: https://github.com/proffesor-for-testing/agentic-qe/issues/65
+ *
  * Features:
- * - SQLite-based persistent storage with 12-table schema
+ * - SQLite-based persistent storage with 12-table schema (SYNCHRONOUS)
  * - Partitioned key-value store
  * - TTL-based expiration with different policies per table
  * - Hint/blackboard pattern support
@@ -136,7 +143,8 @@ class SwarmMemoryManager {
             throw new Error(`Failed to create database connection: ${error}`);
         }
         // Create memory entries table with access control fields
-        await this.run(`
+        // Note: All this.run() calls are synchronous (better-sqlite3)
+        this.run(`
       CREATE TABLE IF NOT EXISTS memory_entries (
         key TEXT NOT NULL,
         partition TEXT NOT NULL DEFAULT 'default',
@@ -152,7 +160,7 @@ class SwarmMemoryManager {
       )
     `);
         // Create ACL table for advanced permissions
-        await this.run(`
+        this.run(`
       CREATE TABLE IF NOT EXISTS memory_acl (
         resource_id TEXT PRIMARY KEY,
         owner TEXT NOT NULL,
@@ -166,7 +174,7 @@ class SwarmMemoryManager {
       )
     `);
         // Create hints table for blackboard pattern
-        await this.run(`
+        this.run(`
       CREATE TABLE IF NOT EXISTS hints (
         id INTEGER PRIMARY KEY AUTOINCREMENT,
         key TEXT NOT NULL,
@@ -176,7 +184,7 @@ class SwarmMemoryManager {
       )
     `);
         // Table 3: Events (TTL: 30 days)
-        await this.run(`
+        this.run(`
       CREATE TABLE IF NOT EXISTS events (
         id TEXT PRIMARY KEY,
         type TEXT NOT NULL,
@@ -188,7 +196,7 @@ class SwarmMemoryManager {
       )
     `);
         // Table 4: Workflow State (TTL: never expires)
-        await this.run(`
+        this.run(`
       CREATE TABLE IF NOT EXISTS workflow_state (
         id TEXT PRIMARY KEY,
         step TEXT NOT NULL,
@@ -202,7 +210,7 @@ class SwarmMemoryManager {
     `);
         // Table 5: Patterns (TTL: 7 days)
         // Issue #79: Added domain and success_rate columns for learning persistence
-        await this.run(`
+        this.run(`
       CREATE TABLE IF NOT EXISTS patterns (
         id TEXT PRIMARY KEY,
         pattern TEXT NOT NULL UNIQUE,
@@ -223,31 +231,31 @@ class SwarmMemoryManager {
             const tableInfo = this.queryAll(`PRAGMA table_info(patterns)`);
             const columnNames = tableInfo.map(col => col.name);
             if (!columnNames.includes('agent_id')) {
-                await this.run(`ALTER TABLE patterns ADD COLUMN agent_id TEXT`);
+                this.run(`ALTER TABLE patterns ADD COLUMN agent_id TEXT`);
             }
             // Issue #79: Add domain column for learning persistence
             if (!columnNames.includes('domain')) {
-                await this.run(`ALTER TABLE patterns ADD COLUMN domain TEXT DEFAULT 'general'`);
+                this.run(`ALTER TABLE patterns ADD COLUMN domain TEXT DEFAULT 'general'`);
             }
             // Issue #79: Add success_rate column for learning persistence
             if (!columnNames.includes('success_rate')) {
-                await this.run(`ALTER TABLE patterns ADD COLUMN success_rate REAL DEFAULT 1.0`);
+                this.run(`ALTER TABLE patterns ADD COLUMN success_rate REAL DEFAULT 1.0`);
             }
         }
         catch (e) {
             // Ignore errors - columns might already exist
         }
         // Create indexes for O(log n) pattern queries (Issue #57)
-        await this.run(`
+        this.run(`
       CREATE INDEX IF NOT EXISTS idx_patterns_agent_confidence
       ON patterns(agent_id, confidence DESC)
     `);
-        await this.run(`
+        this.run(`
       CREATE INDEX IF NOT EXISTS idx_patterns_agent
       ON patterns(agent_id)
     `);
         // Table 6: Consensus State (TTL: 7 days)
-        await this.run(`
+        this.run(`
       CREATE TABLE IF NOT EXISTS consensus_state (
         id TEXT PRIMARY KEY,
         decision TEXT NOT NULL,
@@ -262,7 +270,7 @@ class SwarmMemoryManager {
       )
     `);
         // Table 7: Performance Metrics
-        await this.run(`
+        this.run(`
       CREATE TABLE IF NOT EXISTS performance_metrics (
         id TEXT PRIMARY KEY,
         metric TEXT NOT NULL,
@@ -273,7 +281,7 @@ class SwarmMemoryManager {
       )
     `);
         // Table 8: Artifacts (TTL: never expires)
-        await this.run(`
+        this.run(`
       CREATE TABLE IF NOT EXISTS artifacts (
         id TEXT PRIMARY KEY,
         kind TEXT NOT NULL,
@@ -286,7 +294,7 @@ class SwarmMemoryManager {
       )
     `);
         // Table 9: Sessions (for resumability)
-        await this.run(`
+        this.run(`
       CREATE TABLE IF NOT EXISTS sessions (
         id TEXT PRIMARY KEY,
         mode TEXT NOT NULL,
@@ -297,7 +305,7 @@ class SwarmMemoryManager {
       )
     `);
         // Table 10: Agent Registry
-        await this.run(`
+        this.run(`
       CREATE TABLE IF NOT EXISTS agent_registry (
         id TEXT PRIMARY KEY,
         type TEXT NOT NULL,
@@ -309,7 +317,7 @@ class SwarmMemoryManager {
       )
     `);
         // Table 11: GOAP State
-        await this.run(`
+        this.run(`
       CREATE TABLE IF NOT EXISTS goap_goals (
         id TEXT PRIMARY KEY,
         conditions TEXT NOT NULL,
@@ -318,7 +326,7 @@ class SwarmMemoryManager {
         created_at INTEGER NOT NULL
       )
     `);
-        await this.run(`
+        this.run(`
       CREATE TABLE IF NOT EXISTS goap_actions (
         id TEXT PRIMARY KEY,
         preconditions TEXT NOT NULL,
@@ -328,7 +336,7 @@ class SwarmMemoryManager {
         created_at INTEGER NOT NULL
       )
     `);
-        await this.run(`
+        this.run(`
       CREATE TABLE IF NOT EXISTS goap_plans (
         id TEXT PRIMARY KEY,
         goal_id TEXT NOT NULL,
@@ -338,7 +346,7 @@ class SwarmMemoryManager {
       )
     `);
         // Table 12: OODA Cycles
-        await this.run(`
+        this.run(`
       CREATE TABLE IF NOT EXISTS ooda_cycles (
         id TEXT PRIMARY KEY,
         phase TEXT NOT NULL,
@@ -352,29 +360,29 @@ class SwarmMemoryManager {
       )
     `);
         // Create indexes for performance
-        await this.run(`CREATE INDEX IF NOT EXISTS idx_memory_partition ON memory_entries(partition)`);
-        await this.run(`CREATE INDEX IF NOT EXISTS idx_memory_expires ON memory_entries(expires_at)`);
-        await this.run(`CREATE INDEX IF NOT EXISTS idx_memory_owner ON memory_entries(owner)`);
-        await this.run(`CREATE INDEX IF NOT EXISTS idx_memory_access ON memory_entries(access_level)`);
-        await this.run(`CREATE INDEX IF NOT EXISTS idx_hints_key ON hints(key)`);
-        await this.run(`CREATE INDEX IF NOT EXISTS idx_hints_expires ON hints(expires_at)`);
-        await this.run(`CREATE INDEX IF NOT EXISTS idx_acl_owner ON memory_acl(owner)`);
-        await this.run(`CREATE INDEX IF NOT EXISTS idx_events_type ON events(type)`);
-        await this.run(`CREATE INDEX IF NOT EXISTS idx_events_source ON events(source)`);
-        await this.run(`CREATE INDEX IF NOT EXISTS idx_events_expires ON events(expires_at)`);
-        await this.run(`CREATE INDEX IF NOT EXISTS idx_workflow_status ON workflow_state(status)`);
-        await this.run(`CREATE INDEX IF NOT EXISTS idx_patterns_confidence ON patterns(confidence)`);
-        await this.run(`CREATE INDEX IF NOT EXISTS idx_patterns_expires ON patterns(expires_at)`);
-        await this.run(`CREATE INDEX IF NOT EXISTS idx_consensus_status ON consensus_state(status)`);
-        await this.run(`CREATE INDEX IF NOT EXISTS idx_consensus_expires ON consensus_state(expires_at)`);
-        await this.run(`CREATE INDEX IF NOT EXISTS idx_metrics_metric ON performance_metrics(metric)`);
-        await this.run(`CREATE INDEX IF NOT EXISTS idx_metrics_agent ON performance_metrics(agent_id)`);
-        await this.run(`CREATE INDEX IF NOT EXISTS idx_artifacts_kind ON artifacts(kind)`);
-        await this.run(`CREATE INDEX IF NOT EXISTS idx_agent_status ON agent_registry(status)`);
-        await this.run(`CREATE INDEX IF NOT EXISTS idx_ooda_phase ON ooda_cycles(phase)`);
+        this.run(`CREATE INDEX IF NOT EXISTS idx_memory_partition ON memory_entries(partition)`);
+        this.run(`CREATE INDEX IF NOT EXISTS idx_memory_expires ON memory_entries(expires_at)`);
+        this.run(`CREATE INDEX IF NOT EXISTS idx_memory_owner ON memory_entries(owner)`);
+        this.run(`CREATE INDEX IF NOT EXISTS idx_memory_access ON memory_entries(access_level)`);
+        this.run(`CREATE INDEX IF NOT EXISTS idx_hints_key ON hints(key)`);
+        this.run(`CREATE INDEX IF NOT EXISTS idx_hints_expires ON hints(expires_at)`);
+        this.run(`CREATE INDEX IF NOT EXISTS idx_acl_owner ON memory_acl(owner)`);
+        this.run(`CREATE INDEX IF NOT EXISTS idx_events_type ON events(type)`);
+        this.run(`CREATE INDEX IF NOT EXISTS idx_events_source ON events(source)`);
+        this.run(`CREATE INDEX IF NOT EXISTS idx_events_expires ON events(expires_at)`);
+        this.run(`CREATE INDEX IF NOT EXISTS idx_workflow_status ON workflow_state(status)`);
+        this.run(`CREATE INDEX IF NOT EXISTS idx_patterns_confidence ON patterns(confidence)`);
+        this.run(`CREATE INDEX IF NOT EXISTS idx_patterns_expires ON patterns(expires_at)`);
+        this.run(`CREATE INDEX IF NOT EXISTS idx_consensus_status ON consensus_state(status)`);
+        this.run(`CREATE INDEX IF NOT EXISTS idx_consensus_expires ON consensus_state(expires_at)`);
+        this.run(`CREATE INDEX IF NOT EXISTS idx_metrics_metric ON performance_metrics(metric)`);
+        this.run(`CREATE INDEX IF NOT EXISTS idx_metrics_agent ON performance_metrics(agent_id)`);
+        this.run(`CREATE INDEX IF NOT EXISTS idx_artifacts_kind ON artifacts(kind)`);
+        this.run(`CREATE INDEX IF NOT EXISTS idx_agent_status ON agent_registry(status)`);
+        this.run(`CREATE INDEX IF NOT EXISTS idx_ooda_phase ON ooda_cycles(phase)`);
         // Table 13: Q-values (Q-learning)
         // Issue #79: Added metadata column for learning persistence
-        await this.run(`
+        this.run(`
       CREATE TABLE IF NOT EXISTS q_values (
         id INTEGER PRIMARY KEY AUTOINCREMENT,
         agent_id TEXT NOT NULL,
@@ -392,7 +400,7 @@ class SwarmMemoryManager {
         try {
             const qvTableInfo = this.queryAll(`PRAGMA table_info(q_values)`);
             if (!qvTableInfo.some(col => col.name === 'metadata')) {
-                await this.run(`ALTER TABLE q_values ADD COLUMN metadata TEXT`);
+                this.run(`ALTER TABLE q_values ADD COLUMN metadata TEXT`);
             }
         }
         catch (e) {
@@ -400,7 +408,7 @@ class SwarmMemoryManager {
         }
         // Table 14: Learning Experiences
         // Issue #79: Added metadata and created_at columns for learning persistence
-        await this.run(`
+        this.run(`
       CREATE TABLE IF NOT EXISTS learning_experiences (
         id INTEGER PRIMARY KEY AUTOINCREMENT,
         agent_id TEXT NOT NULL,
@@ -421,17 +429,17 @@ class SwarmMemoryManager {
             const leTableInfo = this.queryAll(`PRAGMA table_info(learning_experiences)`);
             const leColumnNames = leTableInfo.map(col => col.name);
             if (!leColumnNames.includes('metadata')) {
-                await this.run(`ALTER TABLE learning_experiences ADD COLUMN metadata TEXT`);
+                this.run(`ALTER TABLE learning_experiences ADD COLUMN metadata TEXT`);
             }
             if (!leColumnNames.includes('created_at')) {
-                await this.run(`ALTER TABLE learning_experiences ADD COLUMN created_at DATETIME DEFAULT CURRENT_TIMESTAMP`);
+                this.run(`ALTER TABLE learning_experiences ADD COLUMN created_at DATETIME DEFAULT CURRENT_TIMESTAMP`);
             }
         }
         catch (e) {
             // Ignore errors - columns might already exist
         }
         // Table 15: Learning History (snapshots and metrics)
-        await this.run(`
+        this.run(`
       CREATE TABLE IF NOT EXISTS learning_history (
         id INTEGER PRIMARY KEY AUTOINCREMENT,
         agent_id TEXT NOT NULL,
@@ -446,7 +454,7 @@ class SwarmMemoryManager {
       )
     `);
         // Table 16: Learning Metrics (aggregated performance data)
-        await this.run(`
+        this.run(`
       CREATE TABLE IF NOT EXISTS learning_metrics (
         id INTEGER PRIMARY KEY AUTOINCREMENT,
         agent_id TEXT NOT NULL,
@@ -458,27 +466,36 @@ class SwarmMemoryManager {
       )
     `);
         // Learning indexes for performance
-        await this.run(`CREATE INDEX IF NOT EXISTS idx_q_values_agent ON q_values(agent_id)`);
-        await this.run(`CREATE INDEX IF NOT EXISTS idx_learning_exp_agent ON learning_experiences(agent_id)`);
-        await this.run(`CREATE INDEX IF NOT EXISTS idx_learning_hist_agent ON learning_history(agent_id)`);
-        await this.run(`CREATE INDEX IF NOT EXISTS idx_learning_metrics_agent ON learning_metrics(agent_id)`);
+        this.run(`CREATE INDEX IF NOT EXISTS idx_q_values_agent ON q_values(agent_id)`);
+        this.run(`CREATE INDEX IF NOT EXISTS idx_learning_exp_agent ON learning_experiences(agent_id)`);
+        this.run(`CREATE INDEX IF NOT EXISTS idx_learning_hist_agent ON learning_history(agent_id)`);
+        this.run(`CREATE INDEX IF NOT EXISTS idx_learning_metrics_agent ON learning_metrics(agent_id)`);
         this.initialized = true;
     }
     /**
      * Store a key-value pair in memory with OpenTelemetry instrumentation
      *
-     * Automatically instruments the memory store operation with distributed tracing.
-     * Records namespace, key, value size, TTL, and operation performance metrics.
+     * NOTE: This method is async only for auto-initialization. The actual DB
+     * operations are synchronous (better-sqlite3). For maximum performance,
+     * call initialize() first and use storeSync() instead.
      *
      * @param key - Memory key
      * @param value - Value to store (will be JSON serialized)
      * @param options - Store options including partition, TTL, access control
      */
     async store(key, value, options = {}) {
-        // Auto-initialize if not initialized
+        // Auto-initialize if not initialized (only async part)
         if (!this.initialized) {
             await this.initialize();
         }
+        // Delegate to sync implementation
+        this.storeSync(key, value, options);
+    }
+    /**
+     * Synchronous store operation - use when already initialized
+     * Issue #65: Honest synchronous API for better-sqlite3
+     */
+    storeSync(key, value, options = {}) {
         if (!this.db) {
             throw new Error('Memory manager not initialized. Call initialize() first.');
         }
@@ -501,7 +518,7 @@ class SwarmMemoryManager {
             const expiresAt = options.ttl ? createdAt + (options.ttl * 1000) : null;
             const metadata = options.metadata ? JSON.stringify(options.metadata) : null;
             // Check write permission if updating existing entry
-            const existing = await this.queryOne(`SELECT owner, access_level, team_id, swarm_id FROM memory_entries WHERE key = ? AND partition = ?`, [key, partition]);
+            const existing = this.queryOne(`SELECT owner, access_level, team_id, swarm_id FROM memory_entries WHERE key = ? AND partition = ?`, [key, partition]);
             if (existing && options.owner) {
                 // Verify write permission
                 const permCheck = this.accessControl.checkPermission({
@@ -518,7 +535,7 @@ class SwarmMemoryManager {
                     throw new AccessControl_1.AccessControlError(`Write denied: ${permCheck.reason}`);
                 }
             }
-            await this.run(`INSERT OR REPLACE INTO memory_entries
+            this.run(`INSERT OR REPLACE INTO memory_entries
          (key, partition, value, metadata, created_at, expires_at, owner, access_level, team_id, swarm_id)
          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
                 key,
@@ -564,6 +581,17 @@ class SwarmMemoryManager {
         }
         return this.store(key, value, options);
     }
+    /**
+     * Synchronous set - use when already initialized
+     */
+    setSync(key, value, options = {}) {
+        if (typeof options === 'string') {
+            this.storeSync(key, value, { partition: options });
+        }
+        else {
+            this.storeSync(key, value, options);
+        }
+    }
     /**
      * Alias for retrieve() method to maintain compatibility
      * Supports both options object and partition string
@@ -575,21 +603,37 @@ class SwarmMemoryManager {
         }
         return this.retrieve(key, options);
     }
+    /**
+     * Synchronous get - use when already initialized
+     */
+    getSync(key, options = {}) {
+        if (typeof options === 'string') {
+            return this.retrieveSync(key, { partition: options });
+        }
+        return this.retrieveSync(key, options);
+    }
     /**
      * Retrieve a value from memory with OpenTelemetry instrumentation
      *
-     * Automatically instruments the memory retrieve operation with distributed tracing.
-     * Records namespace, key, whether the value was found, value size, and performance metrics.
+     * NOTE: This method is async only for auto-initialization. For maximum
+     * performance, call initialize() first and use retrieveSync() instead.
      *
      * @param key - Memory key
      * @param options - Retrieve options including partition, agentId for access control
      * @returns Retrieved value or null if not found
      */
     async retrieve(key, options = {}) {
-        // Auto-initialize if not initialized
+        // Auto-initialize if not initialized (only async part)
         if (!this.initialized) {
             await this.initialize();
         }
+        return this.retrieveSync(key, options);
+    }
+    /**
+     * Synchronous retrieve operation - use when already initialized
+     * Issue #65: Honest synchronous API for better-sqlite3
+     */
+    retrieveSync(key, options = {}) {
         if (!this.db) {
             throw new Error('Memory manager not initialized. Call initialize() first.');
         }
@@ -611,7 +655,7 @@ class SwarmMemoryManager {
                 query += ` AND (expires_at IS NULL OR expires_at > ?)`;
                 params.push(now);
             }
-            const row = await this.queryOne(query, params);
+            const row = this.queryOne(query, params);
             if (!row) {
                 // Complete span - not found
                 const durationMs = Date.now() - startTime;
@@ -662,15 +706,13 @@ class SwarmMemoryManager {
     }
     /**
      * Query/search memory entries by pattern with OpenTelemetry instrumentation
-     *
-     * Automatically instruments the memory search operation with distributed tracing.
-     * Records namespace, search pattern, result count, and performance metrics.
+     * Issue #65: Converted to synchronous API
      *
      * @param pattern - SQL LIKE pattern for key matching
      * @param options - Retrieve options including partition, agentId for access control
      * @returns Array of matching memory entries
      */
-    async query(pattern, options = {}) {
+    query(pattern, options = {}) {
         if (!this.db) {
             throw new Error('Memory manager not initialized');
         }
@@ -685,15 +727,15 @@ class SwarmMemoryManager {
         const startTime = Date.now();
         try {
             const now = Date.now();
-            let query = `SELECT key, value, partition, created_at, expires_at, owner, access_level, team_id, swarm_id
+            let queryStr = `SELECT key, value, partition, created_at, expires_at, owner, access_level, team_id, swarm_id
                    FROM memory_entries
                    WHERE partition = ? AND key LIKE ?`;
             const params = [partition, pattern];
             if (!options.includeExpired) {
-                query += ` AND (expires_at IS NULL OR expires_at > ?)`;
+                queryStr += ` AND (expires_at IS NULL OR expires_at > ?)`;
                 params.push(now);
             }
-            const rows = await this.queryAll(query, params);
+            const rows = this.queryAll(queryStr, params);
             // Filter by access control if agentId provided
             const filteredRows = options.agentId
                 ? rows.filter((row) => {
@@ -751,7 +793,7 @@ class SwarmMemoryManager {
      * @param partition - Memory partition (namespace)
      * @param options - Delete options including agentId for access control
      */
-    async delete(key, partition = 'default', options = {}) {
+    delete(key, partition = 'default', options = {}) {
         if (!this.db) {
             throw new Error('Memory manager not initialized');
         }
@@ -766,7 +808,7 @@ class SwarmMemoryManager {
         try {
             // Check delete permission if agentId provided
             if (options.agentId) {
-                const row = await this.queryOne(`SELECT owner, access_level, team_id, swarm_id FROM memory_entries WHERE key = ? AND partition = ?`, [key, partition]);
+                const row = this.queryOne(`SELECT owner, access_level, team_id, swarm_id FROM memory_entries WHERE key = ? AND partition = ?`, [key, partition]);
                 if (row) {
                     const permCheck = this.accessControl.checkPermission({
                         agentId: options.agentId,
@@ -784,10 +826,10 @@ class SwarmMemoryManager {
                     }
                 }
             }
-            await this.run(`DELETE FROM memory_entries WHERE key = ? AND partition = ?`, [key, partition]);
+            this.run(`DELETE FROM memory_entries WHERE key = ? AND partition = ?`, [key, partition]);
             // Clean up ACL if exists
             const resourceId = `${partition}:${key}`;
-            await this.run(`DELETE FROM memory_acl WHERE resource_id = ?`, [resourceId]);
+            this.run(`DELETE FROM memory_acl WHERE resource_id = ?`, [resourceId]);
             this.aclCache.delete(resourceId);
             // Complete span successfully
             const durationMs = Date.now() - startTime;
@@ -807,26 +849,26 @@ class SwarmMemoryManager {
             throw error;
         }
     }
-    async clear(partition = 'default') {
+    clear(partition = 'default') {
         if (!this.db) {
             throw new Error('Memory manager not initialized');
         }
-        await this.run(`DELETE FROM memory_entries WHERE partition = ?`, [partition]);
+        this.run(`DELETE FROM memory_entries WHERE partition = ?`, [partition]);
     }
-    async postHint(hint) {
+    postHint(hint) {
         if (!this.db) {
             throw new Error('Memory manager not initialized');
         }
         const createdAt = Date.now();
         const expiresAt = hint.ttl ? createdAt + (hint.ttl * 1000) : null;
-        await this.run(`INSERT INTO hints (key, value, created_at, expires_at) VALUES (?, ?, ?, ?)`, [hint.key, JSON.stringify(hint.value), createdAt, expiresAt]);
+        this.run(`INSERT INTO hints (key, value, created_at, expires_at) VALUES (?, ?, ?, ?)`, [hint.key, JSON.stringify(hint.value), createdAt, expiresAt]);
     }
-    async readHints(pattern) {
+    readHints(pattern) {
         if (!this.db) {
             throw new Error('Memory manager not initialized');
         }
         const now = Date.now();
-        const rows = await this.queryAll(`SELECT key, value, created_at, expires_at
+        const rows = this.queryAll(`SELECT key, value, created_at, expires_at
        FROM hints
        WHERE key LIKE ? AND (expires_at IS NULL OR expires_at > ?)
        ORDER BY created_at DESC`, [pattern, now]);
@@ -837,50 +879,50 @@ class SwarmMemoryManager {
             expiresAt: row.expires_at
         }));
     }
-    async cleanExpired() {
+    cleanExpired() {
         if (!this.db) {
             throw new Error('Memory manager not initialized');
         }
         const now = Date.now();
         // Clean memory entries
-        await this.run(`DELETE FROM memory_entries WHERE expires_at IS NOT NULL AND expires_at <= ?`, [now]);
+        this.run(`DELETE FROM memory_entries WHERE expires_at IS NOT NULL AND expires_at <= ?`, [now]);
         // Clean hints
-        await this.run(`DELETE FROM hints WHERE expires_at IS NOT NULL AND expires_at <= ?`, [now]);
+        this.run(`DELETE FROM hints WHERE expires_at IS NOT NULL AND expires_at <= ?`, [now]);
         // Clean events
-        await this.run(`DELETE FROM events WHERE expires_at IS NOT NULL AND expires_at <= ?`, [now]);
+        this.run(`DELETE FROM events WHERE expires_at IS NOT NULL AND expires_at <= ?`, [now]);
         // Clean patterns
-        await this.run(`DELETE FROM patterns WHERE expires_at IS NOT NULL AND expires_at <= ?`, [now]);
+        this.run(`DELETE FROM patterns WHERE expires_at IS NOT NULL AND expires_at <= ?`, [now]);
         // Clean consensus
-        await this.run(`DELETE FROM consensus_state WHERE expires_at IS NOT NULL AND expires_at <= ?`, [now]);
+        this.run(`DELETE FROM consensus_state WHERE expires_at IS NOT NULL AND expires_at <= ?`, [now]);
         return 0;
     }
-    async close() {
+    close() {
         if (this.db) {
             this.db.close();
             this.db = null;
             this.initialized = false;
         }
     }
-    async stats() {
+    stats() {
         if (!this.db) {
             throw new Error('Memory manager not initialized');
         }
-        const entriesCount = await this.queryOne(`SELECT COUNT(*) as count FROM memory_entries`);
-        const hintsCount = await this.queryOne(`SELECT COUNT(*) as count FROM hints`);
-        const eventsCount = await this.queryOne(`SELECT COUNT(*) as count FROM events`);
-        const workflowsCount = await this.queryOne(`SELECT COUNT(*) as count FROM workflow_state`);
-        const patternsCount = await this.queryOne(`SELECT COUNT(*) as count FROM patterns`);
-        const consensusCount = await this.queryOne(`SELECT COUNT(*) as count FROM consensus_state`);
-        const metricsCount = await this.queryOne(`SELECT COUNT(*) as count FROM performance_metrics`);
-        const artifactsCount = await this.queryOne(`SELECT COUNT(*) as count FROM artifacts`);
-        const sessionsCount = await this.queryOne(`SELECT COUNT(*) as count FROM sessions`);
-        const agentsCount = await this.queryOne(`SELECT COUNT(*) as count FROM agent_registry`);
-        const goapGoalsCount = await this.queryOne(`SELECT COUNT(*) as count FROM goap_goals`);
-        const goapActionsCount = await this.queryOne(`SELECT COUNT(*) as count FROM goap_actions`);
-        const goapPlansCount = await this.queryOne(`SELECT COUNT(*) as count FROM goap_plans`);
-        const oodaCyclesCount = await this.queryOne(`SELECT COUNT(*) as count FROM ooda_cycles`);
-        const partitionsResult = await this.queryAll(`SELECT DISTINCT partition FROM memory_entries`);
-        const accessLevelsResult = await this.queryAll(`SELECT access_level, COUNT(*) as count FROM memory_entries GROUP BY access_level`);
+        const entriesCount = this.queryOne(`SELECT COUNT(*) as count FROM memory_entries`);
+        const hintsCount = this.queryOne(`SELECT COUNT(*) as count FROM hints`);
+        const eventsCount = this.queryOne(`SELECT COUNT(*) as count FROM events`);
+        const workflowsCount = this.queryOne(`SELECT COUNT(*) as count FROM workflow_state`);
+        const patternsCount = this.queryOne(`SELECT COUNT(*) as count FROM patterns`);
+        const consensusCount = this.queryOne(`SELECT COUNT(*) as count FROM consensus_state`);
+        const metricsCount = this.queryOne(`SELECT COUNT(*) as count FROM performance_metrics`);
+        const artifactsCount = this.queryOne(`SELECT COUNT(*) as count FROM artifacts`);
+        const sessionsCount = this.queryOne(`SELECT COUNT(*) as count FROM sessions`);
+        const agentsCount = this.queryOne(`SELECT COUNT(*) as count FROM agent_registry`);
+        const goapGoalsCount = this.queryOne(`SELECT COUNT(*) as count FROM goap_goals`);
+        const goapActionsCount = this.queryOne(`SELECT COUNT(*) as count FROM goap_actions`);
+        const goapPlansCount = this.queryOne(`SELECT COUNT(*) as count FROM goap_plans`);
+        const oodaCyclesCount = this.queryOne(`SELECT COUNT(*) as count FROM ooda_cycles`);
+        const partitionsResult = this.queryAll(`SELECT DISTINCT partition FROM memory_entries`);
+        const accessLevelsResult = this.queryAll(`SELECT access_level, COUNT(*) as count FROM memory_entries GROUP BY access_level`);
         const accessLevels = {};
         accessLevelsResult.forEach(row => {
             accessLevels[row.access_level] = row.count;
@@ -907,7 +949,7 @@ class SwarmMemoryManager {
     // ============================================================================
     // Table 3: Events (TTL: 30 days)
     // ============================================================================
-    async storeEvent(event) {
+    storeEvent(event) {
         if (!this.db) {
             throw new Error('Memory manager not initialized');
         }
@@ -915,16 +957,16 @@ class SwarmMemoryManager {
         const timestamp = event.timestamp || Date.now();
         const ttl = event.ttl !== undefined ? event.ttl : this.TTL_POLICY.events;
         const expiresAt = ttl > 0 ? timestamp + (ttl * 1000) : null;
-        await this.run(`INSERT INTO events (id, type, payload, timestamp, source, ttl, expires_at)
+        this.run(`INSERT INTO events (id, type, payload, timestamp, source, ttl, expires_at)
        VALUES (?, ?, ?, ?, ?, ?, ?)`, [id, event.type, JSON.stringify(event.payload), timestamp, event.source, ttl, expiresAt]);
         return id;
     }
-    async queryEvents(type) {
+    queryEvents(type) {
         if (!this.db) {
             throw new Error('Memory manager not initialized');
         }
         const now = Date.now();
-        const rows = await this.queryAll(`SELECT id, type, payload, timestamp, source, ttl
+        const rows = this.queryAll(`SELECT id, type, payload, timestamp, source, ttl
        FROM events
        WHERE type = ? AND (expires_at IS NULL OR expires_at > ?)
        ORDER BY timestamp DESC`, [type, now]);
@@ -937,12 +979,12 @@ class SwarmMemoryManager {
             ttl: row.ttl
         }));
     }
-    async getEventsBySource(source) {
+    getEventsBySource(source) {
         if (!this.db) {
             throw new Error('Memory manager not initialized');
         }
         const now = Date.now();
-        const rows = await this.queryAll(`SELECT id, type, payload, timestamp, source, ttl
+        const rows = this.queryAll(`SELECT id, type, payload, timestamp, source, ttl
        FROM events
        WHERE source = ? AND (expires_at IS NULL OR expires_at > ?)
        ORDER BY timestamp DESC`, [source, now]);
@@ -958,20 +1000,20 @@ class SwarmMemoryManager {
     // ============================================================================
     // Table 4: Workflow State (TTL: never expires)
     // ============================================================================
-    async storeWorkflowState(workflow) {
+    storeWorkflowState(workflow) {
         if (!this.db) {
             throw new Error('Memory manager not initialized');
         }
         const now = Date.now();
         const ttl = workflow.ttl !== undefined ? workflow.ttl : this.TTL_POLICY.workflow_state;
-        await this.run(`INSERT OR REPLACE INTO workflow_state (id, step, status, checkpoint, sha, ttl, created_at, updated_at)
+        this.run(`INSERT OR REPLACE INTO workflow_state (id, step, status, checkpoint, sha, ttl, created_at, updated_at)
        VALUES (?, ?, ?, ?, ?, ?, ?, ?)`, [workflow.id, workflow.step, workflow.status, JSON.stringify(workflow.checkpoint), workflow.sha, ttl, now, now]);
     }
-    async getWorkflowState(id) {
+    getWorkflowState(id) {
         if (!this.db) {
             throw new Error('Memory manager not initialized');
         }
-        const row = await this.queryOne(`SELECT id, step, status, checkpoint, sha, ttl, created_at, updated_at
+        const row = this.queryOne(`SELECT id, step, status, checkpoint, sha, ttl, created_at, updated_at
        FROM workflow_state
        WHERE id = ?`, [id]);
         if (!row) {
@@ -988,13 +1030,13 @@ class SwarmMemoryManager {
             updatedAt: row.updated_at
         };
     }
-    async updateWorkflowState(id, updates) {
+    updateWorkflowState(id, updates) {
         if (!this.db) {
             throw new Error('Memory manager not initialized');
         }
-        const current = await this.getWorkflowState(id);
+        const current = this.getWorkflowState(id);
         const now = Date.now();
-        await this.run(`UPDATE workflow_state
+        this.run(`UPDATE workflow_state
        SET step = ?, status = ?, checkpoint = ?, sha = ?, updated_at = ?
        WHERE id = ?`, [
             updates.step || current.step,
@@ -1005,11 +1047,11 @@ class SwarmMemoryManager {
             id
         ]);
     }
-    async queryWorkflowsByStatus(status) {
+    queryWorkflowsByStatus(status) {
         if (!this.db) {
             throw new Error('Memory manager not initialized');
         }
-        const rows = await this.queryAll(`SELECT id, step, status, checkpoint, sha, ttl, created_at, updated_at
+        const rows = this.queryAll(`SELECT id, step, status, checkpoint, sha, ttl, created_at, updated_at
        FROM workflow_state
        WHERE status = ?`, [status]);
         return rows.map((row) => ({
@@ -1026,7 +1068,7 @@ class SwarmMemoryManager {
     // ============================================================================
     // Table 5: Patterns (TTL: 7 days)
     // ============================================================================
-    async storePattern(pattern) {
+    storePattern(pattern) {
         if (!this.db) {
             throw new Error('Memory manager not initialized');
         }
@@ -1036,7 +1078,7 @@ class SwarmMemoryManager {
         const expiresAt = ttl > 0 ? now + (ttl * 1000) : null;
         // Extract agent_id from metadata for indexed lookups (O(log n) vs O(n))
         const agentId = pattern.metadata?.agent_id || pattern.metadata?.agentId || null;
-        await this.run(`INSERT OR REPLACE INTO patterns (id, pattern, confidence, usage_count, metadata, ttl, expires_at, created_at, agent_id)
+        this.run(`INSERT OR REPLACE INTO patterns (id, pattern, confidence, usage_count, metadata, ttl, expires_at, created_at, agent_id)
        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
             id,
             pattern.pattern,
@@ -1052,12 +1094,12 @@ class SwarmMemoryManager {
         this.invalidatePatternCacheForAgent(agentId);
         return id;
     }
-    async getPattern(patternName) {
+    getPattern(patternName) {
         if (!this.db) {
             throw new Error('Memory manager not initialized');
         }
         const now = Date.now();
-        const row = await this.queryOne(`SELECT id, pattern, confidence, usage_count, metadata, ttl, created_at
+        const row = this.queryOne(`SELECT id, pattern, confidence, usage_count, metadata, ttl, created_at
        FROM patterns
        WHERE pattern = ? AND (expires_at IS NULL OR expires_at > ?)`, [patternName, now]);
         if (!row) {
@@ -1073,7 +1115,7 @@ class SwarmMemoryManager {
             createdAt: row.created_at
         };
     }
-    async incrementPatternUsage(patternName) {
+    incrementPatternUsage(patternName) {
         if (!this.db) {
             throw new Error('Memory manager not initialized');
         }
@@ -1103,12 +1145,12 @@ class SwarmMemoryManager {
             this.patternCache.clear();
         }
     }
-    async queryPatternsByConfidence(threshold) {
+    queryPatternsByConfidence(threshold) {
         if (!this.db) {
             throw new Error('Memory manager not initialized');
         }
         const now = Date.now();
-        const rows = await this.queryAll(`SELECT id, pattern, confidence, usage_count, metadata, ttl, created_at
+        const rows = this.queryAll(`SELECT id, pattern, confidence, usage_count, metadata, ttl, created_at
        FROM patterns
        WHERE confidence >= ? AND (expires_at IS NULL OR expires_at > ?)
        ORDER BY confidence DESC`, [threshold, now]);
@@ -1135,7 +1177,7 @@ class SwarmMemoryManager {
     escapeLikePattern(value) {
         return value.replace(/[%_\\]/g, '\\$&');
     }
-    async queryPatternsByAgent(agentId, minConfidence = 0) {
+    queryPatternsByAgent(agentId, minConfidence = 0) {
         if (!this.db) {
             throw new Error('Memory manager not initialized');
         }
@@ -1199,14 +1241,14 @@ class SwarmMemoryManager {
     // ============================================================================
     // Table 6: Consensus State (TTL: 7 days)
     // ============================================================================
-    async createConsensusProposal(proposal) {
+    createConsensusProposal(proposal) {
         if (!this.db) {
             throw new Error('Memory manager not initialized');
         }
         const now = Date.now();
         const ttl = proposal.ttl !== undefined ? proposal.ttl : this.TTL_POLICY.consensus;
         const expiresAt = ttl > 0 ? now + (ttl * 1000) : null;
-        await this.run(`INSERT INTO consensus_state (id, decision, proposer, votes, quorum, status, version, ttl, expires_at, created_at)
+        this.run(`INSERT INTO consensus_state (id, decision, proposer, votes, quorum, status, version, ttl, expires_at, created_at)
        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
             proposal.id,
             proposal.decision,
@@ -1220,12 +1262,12 @@ class SwarmMemoryManager {
             now
         ]);
     }
-    async getConsensusProposal(id) {
+    getConsensusProposal(id) {
         if (!this.db) {
             throw new Error('Memory manager not initialized');
         }
         const now = Date.now();
-        const row = await this.queryOne(`SELECT id, decision, proposer, votes, quorum, status, version, ttl, created_at
+        const row = this.queryOne(`SELECT id, decision, proposer, votes, quorum, status, version, ttl, created_at
        FROM consensus_state
        WHERE id = ? AND (expires_at IS NULL OR expires_at > ?)`, [id, now]);
         if (!row) {
@@ -1243,11 +1285,11 @@ class SwarmMemoryManager {
             createdAt: row.created_at
         };
     }
-    async voteOnConsensus(proposalId, agentId) {
+    voteOnConsensus(proposalId, agentId) {
         if (!this.db) {
             throw new Error('Memory manager not initialized');
         }
-        const proposal = await this.getConsensusProposal(proposalId);
+        const proposal = this.getConsensusProposal(proposalId);
         if (!proposal.votes.includes(agentId)) {
             proposal.votes.push(agentId);
         }
@@ -1255,17 +1297,17 @@ class SwarmMemoryManager {
         if (approved) {
             proposal.status = 'approved';
         }
-        await this.run(`UPDATE consensus_state
+        this.run(`UPDATE consensus_state
        SET votes = ?, status = ?
        WHERE id = ?`, [JSON.stringify(proposal.votes), proposal.status, proposalId]);
         return approved;
     }
-    async queryConsensusProposals(status) {
+    queryConsensusProposals(status) {
         if (!this.db) {
             throw new Error('Memory manager not initialized');
         }
         const now = Date.now();
-        const rows = await this.queryAll(`SELECT id, decision, proposer, votes, quorum, status, version, ttl, created_at
+        const rows = this.queryAll(`SELECT id, decision, proposer, votes, quorum, status, version, ttl, created_at
        FROM consensus_state
        WHERE status = ? AND (expires_at IS NULL OR expires_at > ?)`, [status, now]);
         return rows.map((row) => ({
@@ -1283,21 +1325,21 @@ class SwarmMemoryManager {
     // ============================================================================
     // Table 7: Performance Metrics
     // ============================================================================
-    async storePerformanceMetric(metric) {
+    storePerformanceMetric(metric) {
         if (!this.db) {
             throw new Error('Memory manager not initialized');
         }
         const id = metric.id || `metric-${Date.now()}-${SecureRandom_js_1.SecureRandom.generateId(5)}`;
         const timestamp = metric.timestamp || Date.now();
-        await this.run(`INSERT INTO performance_metrics (id, metric, value, unit, timestamp, agent_id)
+        this.run(`INSERT INTO performance_metrics (id, metric, value, unit, timestamp, agent_id)
        VALUES (?, ?, ?, ?, ?, ?)`, [id, metric.metric, metric.value, metric.unit, timestamp, metric.agentId || null]);
         return id;
     }
-    async queryPerformanceMetrics(metricName) {
+    queryPerformanceMetrics(metricName) {
         if (!this.db) {
             throw new Error('Memory manager not initialized');
         }
-        const rows = await this.queryAll(`SELECT id, metric, value, unit, timestamp, agent_id
+        const rows = this.queryAll(`SELECT id, metric, value, unit, timestamp, agent_id
        FROM performance_metrics
        WHERE metric = ?
        ORDER BY timestamp DESC`, [metricName]);
@@ -1310,11 +1352,11 @@ class SwarmMemoryManager {
             agentId: row.agent_id
         }));
     }
-    async getMetricsByAgent(agentId) {
+    getMetricsByAgent(agentId) {
         if (!this.db) {
             throw new Error('Memory manager not initialized');
         }
-        const rows = await this.queryAll(`SELECT id, metric, value, unit, timestamp, agent_id
+        const rows = this.queryAll(`SELECT id, metric, value, unit, timestamp, agent_id
        FROM performance_metrics
        WHERE agent_id = ?
        ORDER BY timestamp DESC`, [agentId]);
@@ -1327,23 +1369,23 @@ class SwarmMemoryManager {
             agentId: row.agent_id
         }));
     }
-    async getAverageMetric(metricName) {
+    getAverageMetric(metricName) {
         if (!this.db) {
             throw new Error('Memory manager not initialized');
         }
-        const row = await this.queryOne(`SELECT AVG(value) as avg FROM performance_metrics WHERE metric = ?`, [metricName]);
+        const row = this.queryOne(`SELECT AVG(value) as avg FROM performance_metrics WHERE metric = ?`, [metricName]);
         return row?.avg || 0;
     }
     // ============================================================================
     // Table 8: Artifacts (TTL: never expires)
     // ============================================================================
-    async createArtifact(artifact) {
+    createArtifact(artifact) {
         if (!this.db) {
             throw new Error('Memory manager not initialized');
         }
         const now = Date.now();
         const ttl = artifact.ttl !== undefined ? artifact.ttl : this.TTL_POLICY.artifacts;
-        await this.run(`INSERT INTO artifacts (id, kind, path, sha256, tags, metadata, ttl, created_at)
+        this.run(`INSERT INTO artifacts (id, kind, path, sha256, tags, metadata, ttl, created_at)
        VALUES (?, ?, ?, ?, ?, ?, ?, ?)`, [
             artifact.id,
             artifact.kind,
@@ -1355,11 +1397,11 @@ class SwarmMemoryManager {
             now
         ]);
     }
-    async getArtifact(id) {
+    getArtifact(id) {
         if (!this.db) {
             throw new Error('Memory manager not initialized');
         }
-        const row = await this.queryOne(`SELECT id, kind, path, sha256, tags, metadata, ttl, created_at
+        const row = this.queryOne(`SELECT id, kind, path, sha256, tags, metadata, ttl, created_at
        FROM artifacts
        WHERE id = ?`, [id]);
         if (!row) {
@@ -1376,11 +1418,11 @@ class SwarmMemoryManager {
             createdAt: row.created_at
         };
     }
-    async queryArtifactsByKind(kind) {
+    queryArtifactsByKind(kind) {
         if (!this.db) {
             throw new Error('Memory manager not initialized');
         }
-        const rows = await this.queryAll(`SELECT id, kind, path, sha256, tags, metadata, ttl, created_at
+        const rows = this.queryAll(`SELECT id, kind, path, sha256, tags, metadata, ttl, created_at
        FROM artifacts
        WHERE kind = ?`, [kind]);
         return rows.map((row) => ({
@@ -1394,11 +1436,11 @@ class SwarmMemoryManager {
             createdAt: row.created_at
         }));
     }
-    async queryArtifactsByTag(tag) {
+    queryArtifactsByTag(tag) {
         if (!this.db) {
             throw new Error('Memory manager not initialized');
         }
-        const rows = await this.queryAll(`SELECT id, kind, path, sha256, tags, metadata, ttl, created_at
+        const rows = this.queryAll(`SELECT id, kind, path, sha256, tags, metadata, ttl, created_at
        FROM artifacts
        WHERE tags LIKE ?`, [`%"${tag}"%`]);
         return rows.map((row) => ({
@@ -1415,12 +1457,12 @@ class SwarmMemoryManager {
     // ============================================================================
     // Table 9: Sessions (resumability)
     // ============================================================================
-    async createSession(session) {
+    createSession(session) {
         if (!this.db) {
             throw new Error('Memory manager not initialized');
         }
         const now = Date.now();
-        await this.run(`INSERT INTO sessions (id, mode, state, checkpoints, created_at, last_resumed)
+        this.run(`INSERT INTO sessions (id, mode, state, checkpoints, created_at, last_resumed)
        VALUES (?, ?, ?, ?, ?, ?)`, [
             session.id,
             session.mode,
@@ -1430,11 +1472,11 @@ class SwarmMemoryManager {
             null
         ]);
     }
-    async getSession(id) {
+    getSession(id) {
         if (!this.db) {
             throw new Error('Memory manager not initialized');
         }
-        const row = await this.queryOne(`SELECT id, mode, state, checkpoints, created_at, last_resumed
+        const row = this.queryOne(`SELECT id, mode, state, checkpoints, created_at, last_resumed
        FROM sessions
        WHERE id = ?`, [id]);
         if (!row) {
@@ -1449,40 +1491,40 @@ class SwarmMemoryManager {
             lastResumed: row.last_resumed
         };
     }
-    async addSessionCheckpoint(sessionId, checkpoint) {
+    addSessionCheckpoint(sessionId, checkpoint) {
         if (!this.db) {
             throw new Error('Memory manager not initialized');
         }
-        const session = await this.getSession(sessionId);
+        const session = this.getSession(sessionId);
         session.checkpoints.push(checkpoint);
-        await this.run(`UPDATE sessions
+        this.run(`UPDATE sessions
        SET checkpoints = ?
        WHERE id = ?`, [JSON.stringify(session.checkpoints), sessionId]);
     }
-    async getLatestCheckpoint(sessionId) {
-        const session = await this.getSession(sessionId);
+    getLatestCheckpoint(sessionId) {
+        const session = this.getSession(sessionId);
         return session.checkpoints.length > 0
             ? session.checkpoints[session.checkpoints.length - 1]
             : undefined;
     }
-    async markSessionResumed(sessionId) {
+    markSessionResumed(sessionId) {
         if (!this.db) {
             throw new Error('Memory manager not initialized');
         }
         const now = Date.now();
-        await this.run(`UPDATE sessions
+        this.run(`UPDATE sessions
        SET last_resumed = ?
        WHERE id = ?`, [now, sessionId]);
     }
     // ============================================================================
     // Table 10: Agent Registry
     // ============================================================================
-    async registerAgent(agent) {
+    registerAgent(agent) {
         if (!this.db) {
             throw new Error('Memory manager not initialized');
         }
         const now = Date.now();
-        await this.run(`INSERT INTO agent_registry (id, type, capabilities, status, performance, created_at, updated_at)
+        this.run(`INSERT INTO agent_registry (id, type, capabilities, status, performance, created_at, updated_at)
        VALUES (?, ?, ?, ?, ?, ?, ?)`, [
             agent.id,
             agent.type,
@@ -1493,11 +1535,11 @@ class SwarmMemoryManager {
             now
         ]);
     }
-    async getAgent(id) {
+    getAgent(id) {
         if (!this.db) {
             throw new Error('Memory manager not initialized');
         }
-        const row = await this.queryOne(`SELECT id, type, capabilities, status, performance, created_at, updated_at
+        const row = this.queryOne(`SELECT id, type, capabilities, status, performance, created_at, updated_at
        FROM agent_registry
        WHERE id = ?`, [id]);
         if (!row) {
@@ -1513,20 +1555,20 @@ class SwarmMemoryManager {
             updatedAt: row.updated_at
         };
     }
-    async updateAgentStatus(agentId, status) {
+    updateAgentStatus(agentId, status) {
         if (!this.db) {
             throw new Error('Memory manager not initialized');
         }
         const now = Date.now();
-        await this.run(`UPDATE agent_registry
+        this.run(`UPDATE agent_registry
        SET status = ?, updated_at = ?
        WHERE id = ?`, [status, now, agentId]);
     }
-    async queryAgentsByStatus(status) {
+    queryAgentsByStatus(status) {
         if (!this.db) {
             throw new Error('Memory manager not initialized');
         }
-        const rows = await this.queryAll(`SELECT id, type, capabilities, status, performance, created_at, updated_at
+        const rows = this.queryAll(`SELECT id, type, capabilities, status, performance, created_at, updated_at
        FROM agent_registry
        WHERE status = ?`, [status]);
         return rows.map((row) => ({
@@ -1539,31 +1581,31 @@ class SwarmMemoryManager {
             updatedAt: row.updated_at
         }));
     }
-    async updateAgentPerformance(agentId, performance) {
+    updateAgentPerformance(agentId, performance) {
         if (!this.db) {
             throw new Error('Memory manager not initialized');
         }
         const now = Date.now();
-        await this.run(`UPDATE agent_registry
+        this.run(`UPDATE agent_registry
        SET performance = ?, updated_at = ?
        WHERE id = ?`, [JSON.stringify(performance), now, agentId]);
     }
     // ============================================================================
     // Table 11: GOAP State
     // ============================================================================
-    async storeGOAPGoal(goal) {
+    storeGOAPGoal(goal) {
         if (!this.db) {
             throw new Error('Memory manager not initialized');
         }
         const now = Date.now();
-        await this.run(`INSERT INTO goap_goals (id, conditions, cost, priority, created_at)
+        this.run(`INSERT INTO goap_goals (id, conditions, cost, priority, created_at)
        VALUES (?, ?, ?, ?, ?)`, [goal.id, JSON.stringify(goal.conditions), goal.cost, goal.priority || null, now]);
     }
-    async getGOAPGoal(id) {
+    getGOAPGoal(id) {
         if (!this.db) {
             throw new Error('Memory manager not initialized');
         }
-        const row = await this.queryOne(`SELECT id, conditions, cost, priority, created_at
+        const row = this.queryOne(`SELECT id, conditions, cost, priority, created_at
        FROM goap_goals
        WHERE id = ?`, [id]);
         if (!row) {
@@ -1577,12 +1619,12 @@ class SwarmMemoryManager {
             createdAt: row.created_at
         };
     }
-    async storeGOAPAction(action) {
+    storeGOAPAction(action) {
         if (!this.db) {
             throw new Error('Memory manager not initialized');
         }
         const now = Date.now();
-        await this.run(`INSERT INTO goap_actions (id, preconditions, effects, cost, agent_type, created_at)
+        this.run(`INSERT INTO goap_actions (id, preconditions, effects, cost, agent_type, created_at)
        VALUES (?, ?, ?, ?, ?, ?)`, [
             action.id,
             JSON.stringify(action.preconditions),
@@ -1592,11 +1634,11 @@ class SwarmMemoryManager {
             now
         ]);
     }
-    async getGOAPAction(id) {
+    getGOAPAction(id) {
         if (!this.db) {
             throw new Error('Memory manager not initialized');
         }
-        const row = await this.queryOne(`SELECT id, preconditions, effects, cost, agent_type, created_at
+        const row = this.queryOne(`SELECT id, preconditions, effects, cost, agent_type, created_at
        FROM goap_actions
        WHERE id = ?`, [id]);
         if (!row) {
@@ -1611,19 +1653,19 @@ class SwarmMemoryManager {
             createdAt: row.created_at
         };
     }
-    async storeGOAPPlan(plan) {
+    storeGOAPPlan(plan) {
         if (!this.db) {
             throw new Error('Memory manager not initialized');
         }
         const now = Date.now();
-        await this.run(`INSERT INTO goap_plans (id, goal_id, sequence, total_cost, created_at)
+        this.run(`INSERT INTO goap_plans (id, goal_id, sequence, total_cost, created_at)
        VALUES (?, ?, ?, ?, ?)`, [plan.id, plan.goalId, JSON.stringify(plan.sequence), plan.totalCost, now]);
     }
-    async getGOAPPlan(id) {
+    getGOAPPlan(id) {
         if (!this.db) {
             throw new Error('Memory manager not initialized');
         }
-        const row = await this.queryOne(`SELECT id, goal_id, sequence, total_cost, created_at
+        const row = this.queryOne(`SELECT id, goal_id, sequence, total_cost, created_at
        FROM goap_plans
        WHERE id = ?`, [id]);
         if (!row) {
@@ -1640,11 +1682,11 @@ class SwarmMemoryManager {
     // ============================================================================
     // Table 12: OODA Cycles
     // ============================================================================
-    async storeOODACycle(cycle) {
+    storeOODACycle(cycle) {
         if (!this.db) {
             throw new Error('Memory manager not initialized');
         }
-        await this.run(`INSERT INTO ooda_cycles (id, phase, observations, orientation, decision, action, timestamp, completed, result)
+        this.run(`INSERT INTO ooda_cycles (id, phase, observations, orientation, decision, action, timestamp, completed, result)
        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
             cycle.id,
             cycle.phase,
@@ -1657,11 +1699,11 @@ class SwarmMemoryManager {
             cycle.result ? JSON.stringify(cycle.result) : null
         ]);
     }
-    async getOODACycle(id) {
+    getOODACycle(id) {
         if (!this.db) {
             throw new Error('Memory manager not initialized');
         }
-        const row = await this.queryOne(`SELECT id, phase, observations, orientation, decision, action, timestamp, completed, result
+        const row = this.queryOne(`SELECT id, phase, observations, orientation, decision, action, timestamp, completed, result
        FROM ooda_cycles
        WHERE id = ?`, [id]);
         if (!row) {
@@ -1679,7 +1721,7 @@ class SwarmMemoryManager {
             result: row.result ? JSON.parse(row.result) : undefined
         };
     }
-    async updateOODAPhase(cycleId, phase, data) {
+    updateOODAPhase(cycleId, phase, data) {
         if (!this.db) {
             throw new Error('Memory manager not initialized');
         }
@@ -1690,23 +1732,23 @@ class SwarmMemoryManager {
             act: 'action'
         };
         const field = fieldMap[phase];
-        await this.run(`UPDATE ooda_cycles
+        this.run(`UPDATE ooda_cycles
        SET phase = ?, ${field} = ?
        WHERE id = ?`, [phase, JSON.stringify(data), cycleId]);
     }
-    async completeOODACycle(cycleId, result) {
+    completeOODACycle(cycleId, result) {
         if (!this.db) {
             throw new Error('Memory manager not initialized');
         }
-        await this.run(`UPDATE ooda_cycles
+        this.run(`UPDATE ooda_cycles
        SET completed = 1, result = ?
        WHERE id = ?`, [JSON.stringify(result), cycleId]);
     }
-    async queryOODACyclesByPhase(phase) {
+    queryOODACyclesByPhase(phase) {
         if (!this.db) {
             throw new Error('Memory manager not initialized');
         }
-        const rows = await this.queryAll(`SELECT id, phase, observations, orientation, decision, action, timestamp, completed, result
+        const rows = this.queryAll(`SELECT id, phase, observations, orientation, decision, action, timestamp, completed, result
        FROM ooda_cycles
        WHERE phase = ?`, [phase]);
         return rows.map((row) => ({
@@ -1725,13 +1767,13 @@ class SwarmMemoryManager {
     /**
      * Store ACL for a memory entry
      */
-    async storeACL(acl) {
+    storeACL(acl) {
         if (!this.db) {
             throw new Error('Memory manager not initialized');
         }
         const grantedPerms = acl.grantedPermissions ? JSON.stringify(acl.grantedPermissions) : null;
         const blockedAgents = acl.blockedAgents ? JSON.stringify(acl.blockedAgents) : null;
-        await this.run(`INSERT OR REPLACE INTO memory_acl
+        this.run(`INSERT OR REPLACE INTO memory_acl
        (resource_id, owner, access_level, team_id, swarm_id, granted_permissions, blocked_agents, created_at, updated_at)
        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
             acl.resourceId,
@@ -1749,7 +1791,7 @@ class SwarmMemoryManager {
     /**
      * Retrieve ACL for a memory entry
      */
-    async getACL(resourceId) {
+    getACL(resourceId) {
         if (!this.db) {
             throw new Error('Memory manager not initialized');
         }
@@ -1757,7 +1799,7 @@ class SwarmMemoryManager {
         if (this.aclCache.has(resourceId)) {
             return this.aclCache.get(resourceId);
         }
-        const row = await this.queryOne(`SELECT * FROM memory_acl WHERE resource_id = ?`, [resourceId]);
+        const row = this.queryOne(`SELECT * FROM memory_acl WHERE resource_id = ?`, [resourceId]);
         if (!row) {
             return null;
         }
@@ -1778,57 +1820,57 @@ class SwarmMemoryManager {
     /**
      * Update ACL for a memory entry
      */
-    async updateACL(resourceId, updates) {
-        const existing = await this.getACL(resourceId);
+    updateACL(resourceId, updates) {
+        const existing = this.getACL(resourceId);
         if (!existing) {
             throw new Error(`ACL not found for resource: ${resourceId}`);
         }
         const updated = this.accessControl.updateACL(existing, updates);
-        await this.storeACL(updated);
+        this.storeACL(updated);
     }
     /**
      * Grant permission to an agent
      */
-    async grantPermission(resourceId, agentId, permissions) {
-        const existing = await this.getACL(resourceId);
+    grantPermission(resourceId, agentId, permissions) {
+        const existing = this.getACL(resourceId);
         if (!existing) {
             throw new Error(`ACL not found for resource: ${resourceId}`);
         }
         const updated = this.accessControl.grantPermission(existing, agentId, permissions);
-        await this.storeACL(updated);
+        this.storeACL(updated);
     }
     /**
      * Revoke permission from an agent
      */
-    async revokePermission(resourceId, agentId, permissions) {
-        const existing = await this.getACL(resourceId);
+    revokePermission(resourceId, agentId, permissions) {
+        const existing = this.getACL(resourceId);
         if (!existing) {
             throw new Error(`ACL not found for resource: ${resourceId}`);
         }
         const updated = this.accessControl.revokePermission(existing, agentId, permissions);
-        await this.storeACL(updated);
+        this.storeACL(updated);
     }
     /**
      * Block an agent from accessing a resource
      */
-    async blockAgent(resourceId, agentId) {
-        const existing = await this.getACL(resourceId);
+    blockAgent(resourceId, agentId) {
+        const existing = this.getACL(resourceId);
         if (!existing) {
             throw new Error(`ACL not found for resource: ${resourceId}`);
         }
         const updated = this.accessControl.blockAgent(existing, agentId);
-        await this.storeACL(updated);
+        this.storeACL(updated);
     }
     /**
      * Unblock an agent
      */
-    async unblockAgent(resourceId, agentId) {
-        const existing = await this.getACL(resourceId);
+    unblockAgent(resourceId, agentId) {
+        const existing = this.getACL(resourceId);
         if (!existing) {
             throw new Error(`ACL not found for resource: ${resourceId}`);
         }
         const updated = this.accessControl.unblockAgent(existing, agentId);
-        await this.storeACL(updated);
+        this.storeACL(updated);
     }
     /**
      * Get access control instance for direct usage
@@ -1881,7 +1923,7 @@ class SwarmMemoryManager {
      * @param port - Peer port number
      * @returns Peer ID
      */
-    async addQUICPeer(address, port) {
+    addQUICPeer(address, port) {
         if (!this.agentDBManager) {
             throw new Error('AgentDB not enabled. Call enableAgentDB() first.');
         }
@@ -1894,7 +1936,7 @@ class SwarmMemoryManager {
      *
      * @param peerId - Peer ID to remove
      */
-    async removeQUICPeer(peerId) {
+    removeQUICPeer(peerId) {
         if (!this.agentDBManager) {
             throw new Error('AgentDB not enabled');
         }
@@ -1939,7 +1981,7 @@ class SwarmMemoryManager {
      * @param partition - Optional partition filter
      * @returns Array of modified entries with metadata
      */
-    async getModifiedEntries(since, partition) {
+    getModifiedEntries(since, partition) {
         if (!this.db) {
             throw new Error('Memory manager not initialized');
         }
@@ -1954,7 +1996,7 @@ class SwarmMemoryManager {
             params.push(partition);
         }
         query += ` ORDER BY created_at ASC`;
-        const rows = await this.queryAll(query, params);
+        const rows = this.queryAll(query, params);
         return rows.map((row) => ({
             key: row.key,
             value: JSON.parse(row.value),
@@ -1993,7 +2035,7 @@ class SwarmMemoryManager {
      * Store a learning experience for Q-learning
      * Delegates to the underlying Database instance
      */
-    async storeLearningExperience(experience) {
+    storeLearningExperience(experience) {
         if (!this.db) {
             throw new Error('Memory manager not initialized');
         }
@@ -2017,7 +2059,7 @@ class SwarmMemoryManager {
      * Upsert a Q-value for a state-action pair
      * Delegates to the underlying Database instance
      */
-    async upsertQValue(agentId, stateKey, actionKey, qValue) {
+    upsertQValue(agentId, stateKey, actionKey, qValue) {
         if (!this.db) {
             throw new Error('Memory manager not initialized');
         }
@@ -2034,7 +2076,7 @@ class SwarmMemoryManager {
     /**
      * Get all Q-values for an agent
      */
-    async getAllQValues(agentId) {
+    getAllQValues(agentId) {
         if (!this.db) {
             throw new Error('Memory manager not initialized');
         }
@@ -2044,12 +2086,12 @@ class SwarmMemoryManager {
       WHERE agent_id = ?
       ORDER BY last_updated DESC
     `;
-        return await this.queryAll(sql, [agentId]);
+        return this.queryAll(sql, [agentId]);
     }
     /**
      * Get Q-value for a specific state-action pair
      */
-    async getQValue(agentId, stateKey, actionKey) {
+    getQValue(agentId, stateKey, actionKey) {
         if (!this.db) {
             throw new Error('Memory manager not initialized');
         }
@@ -2057,14 +2099,14 @@ class SwarmMemoryManager {
       SELECT q_value FROM q_values
       WHERE agent_id = ? AND state_key = ? AND action_key = ?
     `;
-        const row = await this.queryOne(sql, [agentId, stateKey, actionKey]);
+        const row = this.queryOne(sql, [agentId, stateKey, actionKey]);
         return row ? row.q_value : null;
     }
     /**
      * Get the best action for a given state based on Q-values
      * Returns the action with the highest Q-value for the specified state
      */
-    async getBestAction(agentId, stateKey) {
+    getBestAction(agentId, stateKey) {
         if (!this.db) {
             throw new Error('Memory manager not initialized');
         }
@@ -2075,14 +2117,14 @@ class SwarmMemoryManager {
       ORDER BY q_value DESC
       LIMIT 1
     `;
-        const result = await this.queryOne(sql, [agentId, stateKey]);
+        const result = this.queryOne(sql, [agentId, stateKey]);
         return result || null;
     }
     /**
      * Get recent learning experiences for an agent
      * Returns experiences ordered by most recent first
      */
-    async getRecentLearningExperiences(agentId, limit = 10) {
+    getRecentLearningExperiences(agentId, limit = 10) {
         if (!this.db) {
             throw new Error('Memory manager not initialized');
         }
@@ -2093,12 +2135,12 @@ class SwarmMemoryManager {
       ORDER BY created_at DESC
       LIMIT ?
     `;
-        return await this.queryAll(sql, [agentId, limit]);
+        return this.queryAll(sql, [agentId, limit]);
     }
     /**
      * Get learning experiences by task type
      */
-    async getLearningExperiencesByTaskType(agentId, taskType, limit = 50) {
+    getLearningExperiencesByTaskType(agentId, taskType, limit = 50) {
         if (!this.db) {
             throw new Error('Memory manager not initialized');
         }
@@ -2109,13 +2151,13 @@ class SwarmMemoryManager {
       ORDER BY created_at DESC
       LIMIT ?
     `;
-        return await this.queryAll(sql, [agentId, taskType, limit]);
+        return this.queryAll(sql, [agentId, taskType, limit]);
     }
     /**
      * Get high-reward learning experiences for pattern extraction
      * Useful for identifying successful strategies to replicate
      */
-    async getHighRewardExperiences(agentId, minReward = 0.8, limit = 20) {
+    getHighRewardExperiences(agentId, minReward = 0.8, limit = 20) {
         if (!this.db) {
             throw new Error('Memory manager not initialized');
         }
@@ -2126,13 +2168,13 @@ class SwarmMemoryManager {
       ORDER BY reward DESC, created_at DESC
       LIMIT ?
     `;
-        return await this.queryAll(sql, [agentId, minReward, limit]);
+        return this.queryAll(sql, [agentId, minReward, limit]);
     }
     /**
      * Get learning statistics for an agent
      * Useful for tracking learning progress over time
      */
-    async getLearningStats(agentId) {
+    getLearningStats(agentId) {
         if (!this.db) {
             throw new Error('Memory manager not initialized');
         }
@@ -2147,7 +2189,7 @@ class SwarmMemoryManager {
       FROM learning_experiences
       WHERE agent_id = ?
     `;
-        const row = await this.queryOne(sql, [agentId]);
+        const row = this.queryOne(sql, [agentId]);
         return {
             totalExperiences: row?.total_experiences || 0,
             averageReward: row?.avg_reward || 0,
@@ -2160,7 +2202,7 @@ class SwarmMemoryManager {
     /**
      * Store a learning performance snapshot
      */
-    async storeLearningSnapshot(snapshot) {
+    storeLearningSnapshot(snapshot) {
         if (!this.db) {
             throw new Error('Memory manager not initialized');
         }
@@ -2184,7 +2226,7 @@ class SwarmMemoryManager {
     /**
      * Get learning history for an agent
      */
-    async getLearningHistory(agentId, limit = 100) {
+    getLearningHistory(agentId, limit = 100) {
         if (!this.db) {
             throw new Error('Memory manager not initialized');
         }
@@ -2196,7 +2238,7 @@ class SwarmMemoryManager {
       ORDER BY timestamp DESC
       LIMIT ?
     `;
-        return await this.queryAll(sql, [agentId, limit]);
+        return this.queryAll(sql, [agentId, limit]);
     }
 }
 exports.SwarmMemoryManager = SwarmMemoryManager;