agentic-qe 3.14.7 → 3.15.0

package/dist/init/phases/06-code-intelligence.js

@@ -230,12 +230,13 @@ export class CodeIntelligencePhase extends BasePhase {
                 filesToIndex = changedFiles;
             }
             else {
-                const glob = await import('fast-glob');
-                const files = await glob.default([
+                const { glob } = await import('tinyglobby');
+                const files = await glob([
                     '**/*.ts', '**/*.tsx', '**/*.js', '**/*.jsx', '**/*.py'
                 ], {
                     cwd: projectRoot,
                     ignore: SCAN_IGNORE_PATTERNS,
+                    expandDirectories: false,
                 });
                 filesToIndex = files.map(f => join(projectRoot, f));
             }
@@ -439,12 +440,13 @@ export class CodeIntelligencePhase extends BasePhase {
      * Find files modified since the given date
      */
     async findChangedFiles(projectRoot, since) {
-        const glob = await import('fast-glob');
-        const files = await glob.default([
+        const { glob } = await import('tinyglobby');
+        const files = await glob([
             '**/*.ts', '**/*.tsx', '**/*.js', '**/*.jsx', '**/*.py'
         ], {
             cwd: projectRoot,
             ignore: SCAN_IGNORE_PATTERNS,
+            expandDirectories: false,
         });
         const sinceMs = since.getTime();
         const changed = [];

package/dist/integrations/ruvector/sona-persistence.d.ts

@@ -95,6 +95,7 @@ export declare class PersistentSONAEngine {
     private initPromise;
     private pendingSaves;
     private saveTimer;
+    private consecutiveSaveFailures;
     private serverClient;
     constructor(config: PersistentSONAConfig);
     /**

package/dist/integrations/ruvector/sona-persistence.js

@@ -112,6 +112,7 @@ export class PersistentSONAEngine {
     initPromise = null;
     pendingSaves = new Map();
     saveTimer = null;
+    consecutiveSaveFailures = 0;
     serverClient = null;
     constructor(config) {
         this.config = {
@@ -270,8 +271,6 @@ export class PersistentSONAEngine {
         ON CONFLICT(id) DO UPDATE SET
           confidence = excluded.confidence,
           usage_count = excluded.usage_count,
-          success_count = excluded.success_count,
-          failure_count = excluded.failure_count,
           metadata = excluded.metadata,
           updated_at = datetime('now'),
           last_used_at = excluded.last_used_at
@@ -288,6 +287,8 @@ export class PersistentSONAEngine {
         SET confidence = ?,
             success_count = success_count + ?,
             failure_count = failure_count + ?,
+            usage_count = usage_count + 1,
+            last_used_at = datetime('now'),
             updated_at = datetime('now')
         WHERE id = ?
       `));
@@ -432,6 +433,13 @@ export class PersistentSONAEngine {
             // Get updated pattern and persist confidence change
             const pattern = this.getPattern(patternId);
             if (pattern) {
+                // Feedback needs a durable row before incrementing its counters.
+                // Remove the queued snapshot only after its write succeeds.
+                const pending = this.pendingSaves.get(patternId);
+                if (pending) {
+                    this.savePatternToDb(pending);
+                    this.pendingSaves.delete(patternId);
+                }
                 this.persistPatternConfidenceUpdate(patternId, pattern.confidence, success ? 1 : 0, success ? 0 : 1);
             }
         }
@@ -548,19 +556,27 @@ export class PersistentSONAEngine {
         if (!stmt)
             throw new Error('Statement not prepared');
         const result = stmt.run(patternId);
-        return result.changes > 0;
+        // Delete queued writes too: otherwise the next batch or sync restores it.
+        const pending = this.pendingSaves.delete(patternId);
+        const cached = this.baseEngine.deletePattern(patternId);
+        return result.changes > 0 || pending || cached;
     }
     /**
      * Clear all patterns for this domain
      */
     clearDomainPatterns() {
         this.ensureInitialized();
-        // Clear in base engine
-        this.baseEngine.clear();
-        // Clear in SQLite for this domain
+        // Finish the durable delete first so a failed statement preserves memory.
         const stmt = this.prepared.get('deleteByDomain');
-        if (stmt) {
-            stmt.run(this.config.domain);
+        if (!stmt)
+            throw new Error('Statement not prepared');
+        stmt.run(this.config.domain);
+        for (const pattern of this.baseEngine.getPatternsByDomain(this.config.domain)) {
+            this.baseEngine.deletePattern(pattern.id);
+        }
+        for (const [id, pattern] of this.pendingSaves) {
+            if (pattern.domain === this.config.domain)
+                this.pendingSaves.delete(id);
         }
     }
     /**
@@ -791,10 +807,19 @@ export class PersistentSONAEngine {
             this.saveTimer = null;
         }
         if (this.pendingSaves.size > 0) {
+            const failures = [];
             for (const pattern of this.pendingSaves.values()) {
-                this.savePatternToDb(pattern);
+                try {
+                    this.savePatternToDb(pattern);
+                    this.pendingSaves.delete(pattern.id);
+                }
+                catch (error) {
+                    failures.push(new Error(toErrorMessage(error)));
+                }
+            }
+            if (failures.length > 0) {
+                throw new AggregateError(failures, `Deferred SONA saves failed: ${failures.map(error => error.message).join('; ')}`);
             }
-            this.pendingSaves.clear();
         }
         // A10 fix: checkpoint the request counter once per process lifetime
         // (cheap — not on the instantAdapt hot path) so short-lived CLI/MCP
@@ -813,6 +838,8 @@ export class PersistentSONAEngine {
         this.db = null;
         this.persistence = null;
         this.initialized = false;
+        // A completed initialization promise belongs to the closed lifecycle.
+        this.initPromise = null;
         console.log(`[PersistentSONAEngine] Closed: domain=${this.config.domain}`);
     }
     // ==========================================================================
@@ -1018,6 +1045,8 @@ export class PersistentSONAEngine {
         else {
             // Batch saves
             this.pendingSaves.set(pattern.id, pattern);
+            // New explicit work starts a fresh, bounded recovery cycle.
+            this.consecutiveSaveFailures = 0;
             this.scheduleSave();
         }
     }
@@ -1034,11 +1063,12 @@ export class PersistentSONAEngine {
         const actionEmbedding = pattern.action?.value && Array.isArray(pattern.action.value)
             ? this.floatArrayToBuffer(pattern.action.value)
             : null;
-        const actionValue = typeof pattern.action?.value === 'string'
-            ? pattern.action.value
-            : pattern.action?.value !== undefined
-                ? JSON.stringify(pattern.action.value)
-                : null;
+        // Encode strings too: the reader parses JSON, so raw "123"/"false"
+        // would otherwise change the action type after restarting. Legacy raw
+        // non-JSON strings remain readable through rowToPattern's fallback.
+        const actionValue = pattern.action?.value !== undefined
+            ? JSON.stringify(pattern.action.value)
+            : null;
         stmt.run(pattern.id, pattern.type, pattern.domain, stateEmbedding, actionEmbedding, pattern.action?.type ?? 'unknown', actionValue, pattern.outcome?.reward ?? 0, pattern.outcome?.success ? 1 : 0, pattern.outcome?.quality ?? 0, pattern.confidence, pattern.usageCount, 0, // success_count (tracked separately from usageCount)
         0, // failure_count
         pattern.metadata ? JSON.stringify(pattern.metadata) : null, pattern.createdAt?.toISOString() ?? new Date().toISOString(), pattern.lastUsedAt?.toISOString() ?? null);
@@ -1046,17 +1076,41 @@ export class PersistentSONAEngine {
     /**
      * Schedule batched save
      */
-    scheduleSave() {
-        if (this.saveTimer)
+    scheduleSave(delayMs = this.config.autoSaveInterval) {
+        if (this.saveTimer) {
+            // New explicit work must survive natural exit, even during a retry delay.
+            if (this.consecutiveSaveFailures === 0)
+                this.saveTimer.ref();
             return;
+        }
         this.saveTimer = setTimeout(() => {
             this.saveTimer = null;
             const patterns = Array.from(this.pendingSaves.values());
-            this.pendingSaves.clear();
             for (const pattern of patterns) {
-                this.savePatternToDb(pattern);
+                try {
+                    this.savePatternToDb(pattern);
+                    this.pendingSaves.delete(pattern.id);
+                }
+                catch (error) {
+                    logger.warn('Deferred SONA save failed; retaining pending pattern', {
+                        patternId: pattern.id, error: toErrorMessage(error),
+                    });
+                }
+            }
+            if (this.pendingSaves.size > 0) {
+                this.consecutiveSaveFailures++;
+                // Stop after five failed batches; close() can still flush retained rows.
+                if (this.consecutiveSaveFailures < 5 && this.db?.open) {
+                    this.scheduleSave(Math.min(60000, Math.max(1000, this.config.autoSaveInterval) * 2 ** (this.consecutiveSaveFailures - 1)));
+                }
+            }
+            else {
+                this.consecutiveSaveFailures = 0;
             }
-        }, this.config.autoSaveInterval);
+        }, delayMs);
+        // The initial batch must flush on natural exit; only failure retries are optional.
+        if (this.consecutiveSaveFailures > 0)
+            this.saveTimer.unref();
     }
     /**
      * Update pattern usage in SQLite

package/dist/integrations/ruvector/sona-wrapper.d.ts

@@ -199,6 +199,8 @@ export declare class QESONA {
      * Get statistics
      */
     getStats(): QESONAStats;
+    /** Stop recalling a pattern without resetting learned model weights. */
+    deletePattern(patternId: string): boolean;
     /**
      * Clear all patterns
      */

package/dist/integrations/ruvector/sona-wrapper.js

@@ -108,6 +108,15 @@ class QESONAPatternRegistry {
     getByDomain(domain) {
         return Array.from(this.patterns.values()).filter(p => p.domain === domain);
     }
+    /** Remove a pattern and its trajectory associations from the registry. */
+    delete(id) {
+        const removed = this.patterns.delete(id);
+        for (const [trajectoryId, patternId] of this.trajectoryMap) {
+            if (patternId === id)
+                this.trajectoryMap.delete(trajectoryId);
+        }
+        return removed;
+    }
     /**
      * Clear all patterns
      */
@@ -380,6 +389,10 @@ export class QESONA {
             engineStats,
         };
     }
+    /** Stop recalling a pattern without resetting learned model weights. */
+    deletePattern(patternId) {
+        return this.registry.delete(patternId);
+    }
     /**
      * Clear all patterns
      */

package/dist/kernel/memory-backend.js

@@ -56,9 +56,9 @@ export class InMemoryBackend {
         return value !== undefined;
     }
     async search(pattern, limit = MEMORY_CONSTANTS.DEFAULT_SEARCH_LIMIT, options) {
-        // Escape regex-special chars first, then convert glob wildcards to regex
-        const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, '\\$&');
-        const regex = new RegExp(escaped.replace(/\*/g, '.*'));
+        // Match the same whole-key glob contract as persistent memory.
+        const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, '\\$&');
+        const regex = new RegExp(`^${escaped.replace(/\*/g, '.*').replace(/\?/g, '.')}$`, 'su');
         const results = [];
         // When a namespace is supplied, scope the scan to that prefix. Matches
         // HybridBackend's namespace-aware search and lets LearningCoordinator's
@@ -68,7 +68,8 @@ export class InMemoryBackend {
         for (const key of this.store.keys()) {
             if (nsPrefix && !key.startsWith(nsPrefix))
                 continue;
-            if (regex.test(key)) {
+            const searchableKey = nsPrefix ? key.slice(nsPrefix.length) : key;
+            if (regex.test(searchableKey)) {
                 results.push(key);
                 if (results.length >= limit)
                     break;

package/dist/kernel/unified-memory.js

@@ -582,10 +582,11 @@ export class UnifiedMemoryManager {
     }
     async kvSearch(pattern, namespace = 'default', limit = 100) {
         this.ensureInitialized();
-        const sqlPattern = pattern.replace(/\*/g, '%').replace(/\?/g, '_');
+        // Only glob wildcards are special; SQL LIKE's own wildcard/escape bytes are literal.
+        const sqlPattern = pattern.replace(/[!%_]/g, '!$&').replace(/\*/g, '%').replace(/\?/g, '_');
         const rows = this.db.prepare(`
       SELECT key FROM kv_store
-      WHERE namespace = ? AND key LIKE ?
+      WHERE namespace = ? AND key LIKE ? ESCAPE '!'
         AND (expires_at IS NULL OR expires_at > ?)
       LIMIT ?
     `).all(namespace, sqlPattern, Date.now(), limit);

package/dist/learning/aqe-learning-engine.js

@@ -752,7 +752,7 @@ export class AQELearningEngine {
      */
     async localAnalyze(targetPath, depth) {
         try {
-            const glob = await import('fast-glob');
+            const { glob } = await import('tinyglobby');
             const { existsSync, readFileSync } = await import('fs');
             const { join } = await import('path');
             // Scan patterns based on depth
@@ -762,9 +762,10 @@ export class AQELearningEngine {
                     ? ['**/*.ts', '**/*.js', '**/*.json', '**/*.py']
                     : ['**/*'];
             const ignore = ['node_modules/**', 'dist/**', 'coverage/**', '.git/**'];
-            const files = await glob.default(patterns, {
+            const files = await glob(patterns, {
                 cwd: targetPath,
                 ignore,
+                expandDirectories: false,
                 onlyFiles: true,
             });
             // Detect languages and frameworks