agentic-qe 3.9.30 → 3.9.32

package/dist/workers/workers/learning-consolidation.js

@@ -14,11 +14,14 @@
  */
 import { BaseWorker } from '../base-worker';
 import { ALL_DOMAINS } from '../../shared/types';
+import { TimeRange } from '../../shared/value-objects/index.js';
 import { DreamEngine } from '../../learning/dream/index.js';
 import { createPatternLifecycleManager, } from '../../learning/pattern-lifecycle.js';
 import { getUnifiedMemory } from '../../kernel/unified-memory.js';
 import { toErrorMessage } from '../../shared/error-utils.js';
 import { ExperienceConsolidator } from '../../learning/experience-consolidation.js';
+import { recordLoopHealth } from '../../learning/loop-health.js';
+import { pruneStaleDreamInsights } from '../../learning/dream/dream-insights-pruner.js';
 const CONFIG = {
     id: 'learning-consolidation',
     name: 'Learning Consolidation',
@@ -31,6 +34,19 @@ const CONFIG = {
     retryCount: 2,
     retryDelayMs: 30000,
 };
+/**
+ * #486 Gap A: per-domain watermark for the mineExperiences sweep.
+ * Stored at `learning:consolidation-cursor:{domain}` as an ISO timestamp.
+ * Advances only on successful mining with non-zero experiences — failures
+ * leave the cursor untouched so the next tick retries the same window.
+ */
+const CONSOLIDATION_CURSOR_PREFIX = 'learning:consolidation-cursor:';
+const DEFAULT_LOOKBACK_DAYS = 1;
+/**
+ * #488 C.2: retention window for `applied = 0` dream insights. Matches the
+ * `staleDaysThreshold` used by `pattern-lifecycle.ts` for consistency.
+ */
+const DREAM_INSIGHTS_RETENTION_DAYS = 30;
 export class LearningConsolidationWorker extends BaseWorker {
     lifecycleManager = null;
     lastRunTimestamp = 0;
@@ -69,79 +85,124 @@ export class LearningConsolidationWorker extends BaseWorker {
         context.logger.info('Starting learning consolidation (Phase 7: Continuous Learning Loop)');
         const findings = [];
         const recommendations = [];
-        // Initialize Phase 7 metrics
-        let experiencesProcessed = 0;
-        let patternCandidatesFound = 0;
-        let patternsPromoted = 0;
-        let patternsDeprecated = 0;
-        let confidenceDecayApplied = 0;
-        // Phase 7: Run continuous learning loop
-        const lifecycleManager = await this.getLifecycleManager();
-        if (lifecycleManager) {
-            const lifecycleResult = await this.runContinuousLearningLoop(context, lifecycleManager, findings, recommendations);
-            experiencesProcessed = lifecycleResult.experiencesProcessed;
-            patternCandidatesFound = lifecycleResult.patternCandidatesFound;
-            patternsPromoted = lifecycleResult.patternsPromoted;
-            patternsDeprecated = lifecycleResult.patternsDeprecated;
-            confidenceDecayApplied = lifecycleResult.confidenceDecayApplied;
-        }
-        // Collect patterns from all domains
-        const patterns = await this.collectPatterns(context);
-        // Consolidate and analyze
-        const result = await this.consolidatePatterns(context, patterns);
-        // Add Phase 7 metrics to result
-        result.experiencesProcessed = experiencesProcessed;
-        result.patternCandidatesFound = patternCandidatesFound;
-        result.patternsPromoted = patternsPromoted;
-        result.patternsDeprecated = patternsDeprecated;
-        result.confidenceDecayApplied = confidenceDecayApplied;
-        // Identify cross-domain patterns
-        this.identifyCrossDomainPatterns(patterns, findings, recommendations);
-        // Prune ineffective patterns
-        this.pruneIneffectivePatterns(patterns, findings, recommendations);
-        // Generate optimization recommendations
-        this.generateOptimizations(patterns, findings, recommendations);
-        // ADR-046: Run dream cycle for pattern discovery
-        const dreamResult = await this.runDreamCycle(context, patterns, findings, recommendations);
-        result.dreamInsights = dreamResult.insights;
-        result.dreamPatternsCreated = dreamResult.patternsCreated;
-        // Store consolidated results
-        await context.memory.set('learning:lastConsolidation', result);
-        await context.memory.set('learning:consolidatedPatterns', patterns);
-        // Update last run timestamp for decay calculation
-        this.lastRunTimestamp = Date.now();
-        const healthScore = this.calculateHealthScore(result, patterns);
-        context.logger.info('Learning consolidation complete', {
-            healthScore,
-            patternsAnalyzed: result.patternsAnalyzed,
-            newInsights: result.newInsights,
-            // Phase 7 metrics
-            experiencesProcessed,
-            patternsPromoted,
-            patternsDeprecated,
-        });
-        return this.createResult(Date.now() - startTime, {
-            itemsAnalyzed: result.patternsAnalyzed,
-            issuesFound: result.patternsPruned + result.patternsDeprecated,
-            healthScore,
-            trend: this.determineTrend(result),
-            domainMetrics: {
+        // #491 Bug 4a: liveness must be reported on every tick, including the
+        // failure path. Before this fix, `recordLoopHealth(success:true)` sat
+        // *after* `collectPatterns()`, which throws on installs with nothing
+        // to consolidate — so loop-health permanently showed `never-ran`
+        // even when the worker executed every cycle. Track success in a flag
+        // and emit the ping in `finally` (matches the
+        // CapturedExperienceBridge.drainSafe pattern that ships correctly).
+        let liveness = { success: false };
+        try {
+            // Initialize Phase 7 metrics
+            let experiencesProcessed = 0;
+            let patternCandidatesFound = 0;
+            let patternsPromoted = 0;
+            let patternsDeprecated = 0;
+            let confidenceDecayApplied = 0;
+            let patternsMined = 0;
+            let domainsMined = 0;
+            let dreamInsightsPruned = 0;
+            // Phase 7: Run continuous learning loop
+            const lifecycleManager = await this.getLifecycleManager();
+            if (lifecycleManager) {
+                const lifecycleResult = await this.runContinuousLearningLoop(context, lifecycleManager, findings, recommendations);
+                experiencesProcessed = lifecycleResult.experiencesProcessed;
+                patternCandidatesFound = lifecycleResult.patternCandidatesFound;
+                patternsPromoted = lifecycleResult.patternsPromoted;
+                patternsDeprecated = lifecycleResult.patternsDeprecated;
+                confidenceDecayApplied = lifecycleResult.confidenceDecayApplied;
+                patternsMined = lifecycleResult.patternsMined;
+                domainsMined = lifecycleResult.domainsMined;
+                dreamInsightsPruned = lifecycleResult.dreamInsightsPruned;
+            }
+            // Collect patterns from all domains
+            const patterns = await this.collectPatterns(context);
+            // Consolidate and analyze
+            const result = await this.consolidatePatterns(context, patterns);
+            // Add Phase 7 metrics to result
+            result.experiencesProcessed = experiencesProcessed;
+            result.patternCandidatesFound = patternCandidatesFound;
+            result.patternsPromoted = patternsPromoted;
+            result.patternsDeprecated = patternsDeprecated;
+            result.confidenceDecayApplied = confidenceDecayApplied;
+            result.patternsMined = patternsMined;
+            result.domainsMined = domainsMined;
+            result.dreamInsightsPruned = dreamInsightsPruned;
+            // Identify cross-domain patterns
+            this.identifyCrossDomainPatterns(patterns, findings, recommendations);
+            // Prune ineffective patterns
+            this.pruneIneffectivePatterns(patterns, findings, recommendations);
+            // Generate optimization recommendations
+            this.generateOptimizations(patterns, findings, recommendations);
+            // ADR-046: Run dream cycle for pattern discovery
+            const dreamResult = await this.runDreamCycle(context, patterns, findings, recommendations);
+            result.dreamInsights = dreamResult.insights;
+            result.dreamPatternsCreated = dreamResult.patternsCreated;
+            // Store consolidated results
+            await context.memory.set('learning:lastConsolidation', result);
+            await context.memory.set('learning:consolidatedPatterns', patterns);
+            // Reached the end without throwing — this tick is a real success.
+            liveness = { success: true };
+            // Update last run timestamp for decay calculation
+            this.lastRunTimestamp = Date.now();
+            const healthScore = this.calculateHealthScore(result, patterns);
+            context.logger.info('Learning consolidation complete', {
+                healthScore,
                 patternsAnalyzed: result.patternsAnalyzed,
-                patternsPruned: result.patternsPruned,
-                patternsConsolidated: result.patternsConsolidated,
                 newInsights: result.newInsights,
-                crossDomainPatterns: result.crossDomainPatterns,
-                // ADR-046: Dream cycle metrics
-                dreamInsights: result.dreamInsights,
-                dreamPatternsCreated: result.dreamPatternsCreated,
-                // Phase 7: Continuous Learning Loop metrics
-                experiencesProcessed: result.experiencesProcessed,
-                patternCandidatesFound: result.patternCandidatesFound,
-                patternsPromoted: result.patternsPromoted,
-                patternsDeprecated: result.patternsDeprecated,
-                confidenceDecayApplied: result.confidenceDecayApplied,
-            },
-        }, findings, recommendations);
+                // Phase 7 metrics
+                experiencesProcessed,
+                patternsPromoted,
+                patternsDeprecated,
+            });
+            return this.createResult(Date.now() - startTime, {
+                itemsAnalyzed: result.patternsAnalyzed,
+                issuesFound: result.patternsPruned + result.patternsDeprecated,
+                healthScore,
+                trend: this.determineTrend(result),
+                domainMetrics: {
+                    patternsAnalyzed: result.patternsAnalyzed,
+                    patternsPruned: result.patternsPruned,
+                    patternsConsolidated: result.patternsConsolidated,
+                    newInsights: result.newInsights,
+                    crossDomainPatterns: result.crossDomainPatterns,
+                    // ADR-046: Dream cycle metrics
+                    dreamInsights: result.dreamInsights,
+                    dreamPatternsCreated: result.dreamPatternsCreated,
+                    // Phase 7: Continuous Learning Loop metrics
+                    experiencesProcessed: result.experiencesProcessed,
+                    patternCandidatesFound: result.patternCandidatesFound,
+                    patternsPromoted: result.patternsPromoted,
+                    patternsDeprecated: result.patternsDeprecated,
+                    confidenceDecayApplied: result.confidenceDecayApplied,
+                    // #486 Gap A: mineExperiences auto-trigger
+                    patternsMined: result.patternsMined,
+                    domainsMined: result.domainsMined,
+                    // #488 C.2: dream_insights retention pruning
+                    dreamInsightsPruned: result.dreamInsightsPruned,
+                },
+            }, findings, recommendations);
+        }
+        catch (error) {
+            // Record the failure shape and rethrow — BaseWorker handles
+            // worker-level retry/error tracking via this throw.
+            liveness = { success: false, error: error instanceof Error ? error.message : String(error) };
+            throw error;
+        }
+        finally {
+            // #491 Bug 4a: liveness must always reach the dashboard, even when
+            // collectPatterns throws on empty installs. Best-effort — must not
+            // throw or it would shadow the original error.
+            try {
+                await recordLoopHealth(context.memory, 'learningWorker', liveness);
+            }
+            catch (recordErr) {
+                context.logger.warn('recordLoopHealth failed (non-fatal)', {
+                    error: recordErr instanceof Error ? recordErr.message : String(recordErr),
+                });
+            }
+        }
     }
     /**
      * Phase 7: Run the continuous learning loop
@@ -156,6 +217,9 @@ export class LearningConsolidationWorker extends BaseWorker {
         let patternsPromoted = 0;
         let patternsDeprecated = 0;
         let confidenceDecayApplied = 0;
+        let patternsMined = 0;
+        let domainsMined = 0;
+        let dreamInsightsPruned = 0;
         try {
             // Step 1: Extract patterns from recent experiences
             const experiences = lifecycleManager.getRecentExperiences({
@@ -266,12 +330,58 @@ export class LearningConsolidationWorker extends BaseWorker {
             // Step 6: Generate lifecycle statistics finding
             const stats = lifecycleManager.getStats();
             this.addLifecycleStatsFinding(stats, findings, recommendations);
+            // Step 7 (#486 Gap A): mine experiences per domain so `learning:pattern:*`
+            // kv stays current. Without this, the kv stays empty even after the
+            // bridge has populated `learning:experience:*` — no other code path
+            // auto-fires `mineExperiences` in default deployments.
+            try {
+                const miningResult = await this.mineExperiencesPerDomain(context, findings);
+                patternsMined = miningResult.patternsMined;
+                domainsMined = miningResult.domainsMined;
+            }
+            catch (miningError) {
+                context.logger.warn('Pattern mining sweep failed', {
+                    error: toErrorMessage(miningError),
+                });
+            }
+            // Step 8 (#488 C.2): prune stale unapplied dream_insights so the
+            // table doesn't grow unbounded. Applied insights are part of the
+            // pattern-change audit trail and stay forever.
+            try {
+                const unifiedMemory = getUnifiedMemory();
+                const db = unifiedMemory.getDatabase();
+                const pruneResult = pruneStaleDreamInsights(db, {
+                    retentionDays: DREAM_INSIGHTS_RETENTION_DAYS,
+                });
+                dreamInsightsPruned = pruneResult.pruned;
+                if (dreamInsightsPruned > 0) {
+                    findings.push({
+                        type: 'dream-insights-pruned',
+                        severity: 'info',
+                        domain: 'learning-optimization',
+                        title: 'Stale Dream Insights Pruned',
+                        description: `${dreamInsightsPruned} unapplied dream insights older than ${DREAM_INSIGHTS_RETENTION_DAYS} days deleted`,
+                        context: {
+                            pruned: dreamInsightsPruned,
+                            retentionDays: DREAM_INSIGHTS_RETENTION_DAYS,
+                        },
+                    });
+                }
+            }
+            catch (pruneError) {
+                context.logger.warn('Dream insights pruning failed', {
+                    error: toErrorMessage(pruneError),
+                });
+            }
             context.logger.info('Continuous learning loop complete', {
                 experiencesProcessed,
                 patternCandidatesFound,
                 patternsPromoted,
                 patternsDeprecated,
                 confidenceDecayApplied,
+                patternsMined,
+                domainsMined,
+                dreamInsightsPruned,
             });
         }
         catch (error) {
@@ -285,8 +395,124 @@ export class LearningConsolidationWorker extends BaseWorker {
             patternsPromoted,
             patternsDeprecated,
             confidenceDecayApplied,
+            patternsMined,
+            domainsMined,
+            dreamInsightsPruned,
         };
     }
+    /**
+     * #486 Gap A: mine experiences into `learning:pattern:*` kv per domain.
+     *
+     * The producer side of the learning-optimization domain pipeline:
+     *
+     *   captured_experiences (SQLite)
+     *     → bridge drain → learning.ExperienceCaptured event
+     *       → handleExperienceCaptured → recordExperience
+     *         → learning:experience:* kv (✓ working post-v3.9.29)
+     *           → mineExperiences (THIS STEP)
+     *             → extractPatternsFromExperiences → learnPattern → storePattern
+     *               → learning:pattern:* kv
+     *
+     * Without this step the chain ends at the experience kv, so `getPatternStats`
+     * reports zero patterns and the `LearningConsolidationWorker.collectPatterns`
+     * step a few lines above throws "No learning patterns to consolidate yet".
+     *
+     * Per-domain cursor avoids re-processing the same experiences (which would
+     * duplicate-write since `learnPattern` uses uuidv4 for pattern IDs). Cursor
+     * is stored in WorkerMemory under `learning:consolidation-cursor:{domain}`
+     * as an ISO timestamp. On first run, the cursor defaults to `now - 1 day`
+     * to match the lookback used elsewhere by `runLearningCycle`.
+     *
+     * Failures are isolated per domain — one bad domain doesn't block others.
+     * On failure or empty mining the cursor stays put so the next tick retries
+     * the same window with new experiences.
+     */
+    async mineExperiencesPerDomain(context, findings) {
+        const learningAPI = context.domains.getDomainAPI('learning-optimization');
+        if (!learningAPI || typeof learningAPI.getLearningService !== 'function') {
+            // The learning-optimization domain isn't available in this fleet config;
+            // the worker still has lifecycle work to do, so this is non-fatal.
+            context.logger.debug('mineExperiencesPerDomain: learning-optimization API unavailable');
+            return { patternsMined: 0, domainsMined: 0 };
+        }
+        const learningService = learningAPI.getLearningService();
+        if (!learningService) {
+            context.logger.debug('mineExperiencesPerDomain: learning service not initialized');
+            return { patternsMined: 0, domainsMined: 0 };
+        }
+        const now = new Date();
+        let patternsMined = 0;
+        let domainsMined = 0;
+        for (const domain of ALL_DOMAINS) {
+            const cursorKey = `${CONSOLIDATION_CURSOR_PREFIX}${domain}`;
+            let start;
+            try {
+                const cursorIso = await context.memory.get(cursorKey);
+                if (cursorIso) {
+                    const parsed = new Date(cursorIso);
+                    // Guard against corrupted cursor or clock skew: never look back further
+                    // than DEFAULT_LOOKBACK_DAYS, never look ahead.
+                    if (!isNaN(parsed.getTime()) && parsed < now) {
+                        const earliest = new Date(now.getTime() - DEFAULT_LOOKBACK_DAYS * 24 * 60 * 60 * 1000);
+                        start = parsed > earliest ? parsed : earliest;
+                    }
+                    else {
+                        start = new Date(now.getTime() - DEFAULT_LOOKBACK_DAYS * 24 * 60 * 60 * 1000);
+                    }
+                }
+                else {
+                    start = new Date(now.getTime() - DEFAULT_LOOKBACK_DAYS * 24 * 60 * 60 * 1000);
+                }
+            }
+            catch {
+                // Cursor read failure is non-fatal — fall back to the default window.
+                start = new Date(now.getTime() - DEFAULT_LOOKBACK_DAYS * 24 * 60 * 60 * 1000);
+            }
+            try {
+                const timeRange = TimeRange.create(start, now);
+                const result = await learningService.mineExperiences(domain, timeRange);
+                if (!result.success) {
+                    context.logger.debug(`mineExperiences failed for ${domain}`, {
+                        error: toErrorMessage(result.error),
+                    });
+                    continue;
+                }
+                const { experienceCount, patterns } = result.value;
+                if (experienceCount > 0) {
+                    patternsMined += patterns.length;
+                    domainsMined++;
+                    // Only advance the cursor when we actually processed experiences —
+                    // otherwise an empty window would falsely consume a fresh experience
+                    // arriving milliseconds later. Cursor advances to `now`, not to
+                    // `last experience timestamp`, because the kv index uses
+                    // `learning:experience:index:domain:{d}:*` keys without a per-key
+                    // timestamp we can read here.
+                    await context.memory.set(cursorKey, now.toISOString());
+                }
+            }
+            catch (domainError) {
+                context.logger.debug(`mineExperiences threw for ${domain}`, {
+                    error: toErrorMessage(domainError),
+                });
+                // Cursor untouched on throw — retry next tick.
+            }
+        }
+        if (patternsMined > 0) {
+            findings.push({
+                type: 'pattern-mining',
+                severity: 'info',
+                domain: 'learning-optimization',
+                title: 'Patterns Mined from Experience Replay',
+                description: `${patternsMined} patterns mined into learning:pattern:* kv across ${domainsMined} domain(s) since their last consolidation tick`,
+                context: {
+                    patternsMined,
+                    domainsMined,
+                    lookbackDays: DEFAULT_LOOKBACK_DAYS,
+                },
+            });
+        }
+        return { patternsMined, domainsMined };
+    }
     /**
      * Create patterns from pattern candidates
      */
@@ -509,6 +735,11 @@ export class LearningConsolidationWorker extends BaseWorker {
             // Experience consolidation metrics
             experiencesMerged: 0,
             experiencesArchived: 0,
+            // #486 Gap A: filled in by runContinuousLearningLoop
+            patternsMined: 0,
+            domainsMined: 0,
+            // #488 C.2: filled in by runContinuousLearningLoop
+            dreamInsightsPruned: 0,
         };
     }
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentic-qe",
-  "version": "3.9.30",
+  "version": "3.9.32",
   "description": "Agentic Quality Engineering V3 - Domain-Driven Design Architecture with 13 Bounded Contexts, O(log n) coverage analysis, ReasoningBank learning, 60 specialized QE agents, mathematical Coherence verification, deep Claude Flow integration",
   "type": "module",
   "main": "./dist/index.js",
@@ -62,6 +62,8 @@
     "test:all": "npm test -- --run",
     "test:mcp": "npm run test:unit:mcp",
     "test:mcp:integration": "npm test -- --run tests/integration/mcp/",
+    "test:integration:fast": "NODE_OPTIONS='--max-old-space-size=2048 --expose-gc' vitest run tests/integration/mcp/fleet-init-wires-daemon.test.ts tests/integration/workers/workers-reach-domains.test.ts tests/integration/learning/coordinator-roundtrip.test.ts tests/integration/bridge/bridge-end-to-end.test.ts",
+    "test:integration": "NODE_OPTIONS='--max-old-space-size=4096 --expose-gc' vitest run tests/integration/ --exclude='**/browser/**' --exclude='**/browser-integration/**' --exclude='**/*.e2e.test.ts'",
     "mcp:validate": "echo 'MCP validation: All tools registered in MCP server' && exit 0",
     "mcp:report": "echo 'MCP Report: uses vitest for test reporting' && exit 0",
     "test:code-intelligence": "npm test -- --run tests/unit/domains/code-intelligence/ tests/unit/coordination/mincut/",

package/dist/cli/chunks/adapter-HV42JOZD.js

@@ -1,2 +0,0 @@
-import{createRequire as __cr}from"module";const require=__cr(import.meta.url);if(process.argv.includes('--version')||process.argv.includes('-v')){console.log("3.9.30");process.exit(0)}
-import{a,b,c}from"./chunk-Q26GG6WO.js";import"./chunk-5E3YCZC5.js";import"./chunk-2MKSEL6F.js";import"./chunk-Q4HJRYQB.js";import"./chunk-RNO6CE7I.js";import"./chunk-ITBPDVK5.js";export{a as AgentBoosterAdapter,b as createAgentBoosterAdapter,c as createAgentBoosterAdapterSync};

package/dist/cli/chunks/aqe-learning-engine-GL22PE2V.js

@@ -1,2 +0,0 @@
-import{createRequire as __cr}from"module";const require=__cr(import.meta.url);if(process.argv.includes('--version')||process.argv.includes('-v')){console.log("3.9.30");process.exit(0)}
-import{a,b,c,d,e,f}from"./chunk-DDMFTEJP.js";import"./chunk-HA7N45KB.js";import"./chunk-WVODEWH5.js";import"./chunk-VRP4GB4Y.js";import"./chunk-R5IW5ARI.js";import"./chunk-2GBBZLXT.js";import"./chunk-QHKK2H4H.js";import"./chunk-IOINZWNA.js";import"./chunk-Y57V4FDT.js";import"./chunk-3AICELMQ.js";import"./chunk-QTS2DS42.js";import"./chunk-5DJAJPBG.js";import"./chunk-4UZQSPR4.js";import"./chunk-TYZGEVP6.js";import"./chunk-DJRWVNHK.js";import"./chunk-7Z3GBQNV.js";import"./chunk-3WIU2E2Y.js";import"./chunk-Q4HJRYQB.js";import"./chunk-LDGNVPBZ.js";import"./chunk-RNO6CE7I.js";import"./chunk-GY4EGQO3.js";import"./chunk-CNNVL5W4.js";import"./chunk-TULNR2AH.js";import"./chunk-7D2DM23U.js";import"./chunk-37I6K7QO.js";import"./chunk-XVTZXCHI.js";import"./chunk-KR2PGNXX.js";import"./chunk-GEXVUFK4.js";import"./chunk-QNSUPXUU.js";import"./chunk-UYLHIGNC.js";import"./chunk-ITBPDVK5.js";export{b as AQELearningEngine,a as DEFAULT_ENGINE_CONFIG,c as DEFAULT_META_LEARNING_CONFIG,d as MetaLearningEngine,e as createAQELearningEngine,f as createDefaultLearningEngine};

package/dist/cli/chunks/base-4KQ2FGUX.js

@@ -1,2 +0,0 @@
-import{createRequire as __cr}from"module";const require=__cr(import.meta.url);if(process.argv.includes('--version')||process.argv.includes('-v')){console.log("3.9.30");process.exit(0)}
-import{a,b,c,d,e,f}from"./chunk-OEGFOMXP.js";import"./chunk-XK6YXCS7.js";import"./chunk-TYZGEVP6.js";import"./chunk-DJRWVNHK.js";import"./chunk-7Z3GBQNV.js";import"./chunk-3WIU2E2Y.js";import"./chunk-Q4HJRYQB.js";import"./chunk-RNO6CE7I.js";import"./chunk-GY4EGQO3.js";import"./chunk-CNNVL5W4.js";import"./chunk-TULNR2AH.js";import"./chunk-7D2DM23U.js";import"./chunk-37I6K7QO.js";import"./chunk-XVTZXCHI.js";import"./chunk-KR2PGNXX.js";import"./chunk-GEXVUFK4.js";import"./chunk-QNSUPXUU.js";import"./chunk-UYLHIGNC.js";import"./chunk-ITBPDVK5.js";export{f as MCPToolBase,e as defaultToolLogger,d as getMemoryBackend,b as getSharedMemoryBackend,a as registerRvfResetFn,c as resetSharedMemoryBackend};

package/dist/cli/chunks/browser-workflow-CTE7BDM4.js

@@ -1,2 +0,0 @@
-import{createRequire as __cr}from"module";const require=__cr(import.meta.url);if(process.argv.includes('--version')||process.argv.includes('-v')){console.log("3.9.30");process.exit(0)}
-import{a}from"./chunk-IWC6GR24.js";import"./chunk-OEGFOMXP.js";import"./chunk-XK6YXCS7.js";import"./chunk-TYZGEVP6.js";import"./chunk-DJRWVNHK.js";import"./chunk-7Z3GBQNV.js";import"./chunk-3WIU2E2Y.js";import"./chunk-Q4HJRYQB.js";import"./chunk-RNO6CE7I.js";import"./chunk-GY4EGQO3.js";import"./chunk-CNNVL5W4.js";import"./chunk-TULNR2AH.js";import"./chunk-7D2DM23U.js";import"./chunk-37I6K7QO.js";import"./chunk-XVTZXCHI.js";import"./chunk-KR2PGNXX.js";import"./chunk-GEXVUFK4.js";import"./chunk-QNSUPXUU.js";import"./chunk-UYLHIGNC.js";import"./chunk-ITBPDVK5.js";export{a as BrowserWorkflowTool};

package/dist/cli/chunks/chunk-3NGNSKL3.js

@@ -1,14 +0,0 @@
-import{createRequire as __cr}from"module";const require=__cr(import.meta.url);if(process.argv.includes('--version')||process.argv.includes('-v')){console.log("3.9.30");process.exit(0)}
-import{c as D}from"./chunk-52TRKIAQ.js";import{a as _}from"./chunk-SAVITYEX.js";import{k as w,o as U}from"./chunk-TYZGEVP6.js";import{b as f,d as q}from"./chunk-Q4HJRYQB.js";import{a as g,c as P}from"./chunk-RNO6CE7I.js";import{a as v}from"./chunk-ITBPDVK5.js";import{randomUUID as L}from"crypto";U();q();P();var x={alpha:.1,minOutcomes:10,weightFloor:.2,weightCeiling:2},p=class{records=new Map;config;constructor(e){this.config={...x,...e}}recordOutcome(e,t,o){let{alpha:i,minOutcomes:r,weightFloor:s,weightCeiling:n}=this.config,c=this.records.get(e),d=t?1:0,a=Math.max(0,Math.min(1,o)),l,u;c?(l=i*d+(1-i)*c.emaAccuracy,u=i*a+(1-i)*c.emaQuality):(l=d,u=a);let h=(c?.totalOutcomes??0)+1,R;h>=r?R=Math.max(s,Math.min(n,l*2)):R=1;let k={agentId:e,emaAccuracy:l,emaQuality:u,calibratedWeight:R,totalOutcomes:h,lastUpdated:new Date};return this.records.set(e,k),k}getCalibration(e){return this.records.get(e)??null}getCalibratedWeight(e){let t=this.records.get(e);return!t||t.totalOutcomes<this.config.minOutcomes?1:t.calibratedWeight}getAllCalibrations(){return Array.from(this.records.values())}reset(e){e!==void 0?this.records.delete(e):this.records.clear()}serialize(){let e={};for(let[t,o]of this.records)e[t]={...o};return e}deserialize(e){this.records.clear();for(let[t,o]of Object.entries(e))this.records.set(t,{...o,lastUpdated:new Date(o.lastUpdated)})}};var F={escalateAfterFailures:2,deEscalateAfterSuccesses:5,maxTier:"opus",minTier:"haiku"},A=["booster","haiku","sonnet","opus"];function y(m){return A.indexOf(m)}var b=class{config;states=new Map;constructor(e){this.config={...F,...e}}recordOutcome(e,t,o){let i=this.states.get(e);i||(i={agentId:e,currentTier:o,baseTier:o,consecutiveFailures:0,consecutiveSuccesses:0,escalationCount:0,deEscalationCount:0,lastAction:"none",lastActionTimestamp:new Date},this.states.set(e,i));let r=i.currentTier;if(t){if(i.consecutiveSuccesses++,i.consecutiveFailures=0,i.consecutiveSuccesses>=this.config.deEscalateAfterSuccesses){let s=y(i.currentTier),n=y(this.config.minTier);if(s>n)return i.currentTier=A[s-1],i.deEscalationCount++,i.consecutiveSuccesses=0,i.lastAction="de-escalate",i.lastActionTimestamp=new Date,{action:"de-escalate",previousTier:r,newTier:i.currentTier}}}else if(i.consecutiveFailures++,i.consecutiveSuccesses=0,i.consecutiveFailures>=this.config.escalateAfterFailures){let s=y(i.currentTier),n=y(this.config.maxTier);if(s<n)return i.currentTier=A[s+1],i.escalationCount++,i.consecutiveFailures=0,i.lastAction="escalate",i.lastActionTimestamp=new Date,{action:"escalate",previousTier:r,newTier:i.currentTier}}return{action:"none",previousTier:r,newTier:i.currentTier}}getCurrentTier(e){return this.states.get(e)?.currentTier??null}getState(e){return this.states.get(e)??null}getAllStates(){return Array.from(this.states.values())}reset(e){e?this.states.delete(e):this.states.clear()}};var T={booster:{avgInputTokens:0,avgOutputTokens:0,costPerTask:0},haiku:{avgInputTokens:2e3,avgOutputTokens:1e3,costPerTask:.0035},sonnet:{avgInputTokens:2e3,avgOutputTokens:1e3,costPerTask:.021},opus:{avgInputTokens:2e3,avgOutputTokens:1e3,costPerTask:.105}},S=["booster","haiku","sonnet","opus"],E=T.opus.costPerTask,I={qualityWeight:.6,costWeight:.4,budgetPerHourUsd:0,budgetPerDayUsd:0,minQualityThreshold:.5,enabled:!0},N=.15,C=class{config;costTracker;tierQualityEstimates=new Map;tierOutcomeCounts=new Map;constructor(e,t){let o={...I,...t};o.qualityWeight=Math.max(0,Math.min(1,o.qualityWeight)),o.costWeight=Math.max(0,Math.min(1,o.costWeight)),o.minQualityThreshold=Math.max(0,Math.min(1,o.minQualityThreshold)),o.budgetPerHourUsd=Math.max(0,o.budgetPerHourUsd),o.budgetPerDayUsd=Math.max(0,o.budgetPerDayUsd);let i=o.qualityWeight+o.costWeight;i>0&&i!==1&&(o.qualityWeight/=i,o.costWeight/=i),this.config=o,this.costTracker=e,this.tierQualityEstimates.set("booster",.3),this.tierQualityEstimates.set("haiku",.55),this.tierQualityEstimates.set("sonnet",.75),this.tierQualityEstimates.set("opus",.9)}scoreTiers(e){let t=S.map(o=>{let i=this.getQualityEstimate(o,e),r=T[o].costPerTask,s=r>0?i/r:i>0?1/0:0,n=E>0?1-r/E:1,c=this.config.qualityWeight*i+this.config.costWeight*n;return{tier:o,qualityScore:i,estimatedCostUsd:r,qualityPerDollar:s,economicScore:c}});return t.sort((o,i)=>i.economicScore-o.economicScore),t}selectTier(e){let t=this.scoreTiers(e);for(let r of t)if(!(r.qualityScore<this.config.minQualityThreshold)&&!this.wouldExceedBudget(r.tier))return{tier:r.tier,reason:`Best economic score (${r.economicScore.toFixed(3)}): quality=${r.qualityScore.toFixed(2)}, cost=$${r.estimatedCostUsd.toFixed(4)}`,scores:t};let o=t.filter(r=>r.qualityScore>=this.config.minQualityThreshold);if(o.length>0){let r=[...o].sort((s,n)=>s.estimatedCostUsd-n.estimatedCostUsd)[0];return{tier:r.tier,reason:`Budget constrained fallback to ${r.tier}`,scores:t}}let i=[...t].sort((r,s)=>s.qualityScore-r.qualityScore)[0];return{tier:i.tier,reason:`No tier meets quality threshold ${this.config.minQualityThreshold}; using best quality: ${i.tier}`,scores:t}}wouldExceedBudget(e){let t=T[e].costPerTask;if(t===0)return!1;let o=this.costTracker.getCurrentCost("hour"),i=this.costTracker.getCurrentCost("day");return this.config.budgetPerHourUsd>0&&o+t>this.config.budgetPerHourUsd||this.config.budgetPerDayUsd>0&&i+t>this.config.budgetPerDayUsd}updateFromOutcome(e,t){let o=e.outcome.qualityScore,i=this.tierQualityEstimates.get(t)??.5,r=this.tierOutcomeCounts.get(t)??0,s=r<5?.4:N,n=i*(1-s)+o*s;this.tierQualityEstimates.set(t,n),this.tierOutcomeCounts.set(t,r+1)}getEconomicReport(){let e=this.scoreTiers(.5),t=this.costTracker.getCurrentCost("hour"),o=this.costTracker.getCurrentCost("day"),i={hourly:this.config.budgetPerHourUsd>0?Math.max(0,this.config.budgetPerHourUsd-t):null,daily:this.config.budgetPerDayUsd>0?Math.max(0,this.config.budgetPerDayUsd-o):null},r=null,s=[...e].sort((a,l)=>l.qualityPerDollar-a.qualityPerDollar),n=s.find(a=>a.estimatedCostUsd>0&&isFinite(a.qualityPerDollar)),c=[...s].reverse().find(a=>a.estimatedCostUsd>0&&isFinite(a.qualityPerDollar));if(n&&c&&n.tier!==c.tier){let a=c.estimatedCostUsd-n.estimatedCostUsd;a>0&&(r={usd:a,description:`Switch from ${c.tier} ($${c.estimatedCostUsd.toFixed(4)}/task) to ${n.tier} ($${n.estimatedCostUsd.toFixed(4)}/task) for comparable tasks to save ~$${a.toFixed(4)}/task`})}let d=this.generateRecommendation(e,i);return{tierEfficiency:e,currentHourlyCostUsd:t,currentDailyCostUsd:o,budgetRemaining:i,recommendation:d,savingsOpportunity:r}}computeCostAdjustedReward(e,t,o){let i=T[t].costPerTask;if(E===0)return e;let r=i/E,s=Math.max(0,o-this.config.minQualityThreshold),n=r*(1-s),c=e-n*this.config.costWeight;return Math.max(-1,Math.min(1,c))}serializeEstimates(){let e={};for(let t of S)e[t]={quality:this.tierQualityEstimates.get(t)??.5,count:this.tierOutcomeCounts.get(t)??0};return e}deserializeEstimates(e){for(let t of S)e[t]&&(this.tierQualityEstimates.set(t,e[t].quality),this.tierOutcomeCounts.set(t,e[t].count))}getConfig(){return{...this.config}}getQualityEstimate(e,t){let o=this.tierQualityEstimates.get(e)??.5,i=e==="booster"?t*.4:e==="haiku"?t*.2:0;return Math.max(0,Math.min(1,o-i))}generateRecommendation(e,t){if(t.hourly!==null&&t.hourly<.01)return"Hourly budget nearly exhausted. Consider increasing budget or routing to cheaper tiers.";if(t.daily!==null&&t.daily<.1)return"Daily budget nearly exhausted. Only critical tasks should use expensive tiers.";let o=e[0];return o?`Most cost-efficient tier: ${o.tier} (score=${o.economicScore.toFixed(3)}, quality=${o.qualityScore.toFixed(2)})`:"No economic data available yet."}};var O=class{outcomes=[];maxOutcomes;constructor(e=1e4){this.maxOutcomes=e}add(e){this.outcomes.push(e),this.outcomes.length>this.maxOutcomes&&(this.outcomes=this.outcomes.slice(-this.maxOutcomes))}getByAgent(e,t=100){return this.outcomes.filter(o=>o.usedAgent===e).slice(-t)}getAll(e=1e3){return this.outcomes.slice(-e)}getRecentOverrides(e=50){return this.outcomes.filter(t=>!t.followedRecommendation).slice(-e)}clear(){this.outcomes=[]}get size(){return this.outcomes.length}},M=class m{static schemaMigrated=!1;outcomeStore;router=null;db=null;calibrator=null;escalationTracker=null;economicModel=null;economicPersistCounter=0;static ECONOMIC_PERSIST_INTERVAL=10;persistCount=0;maxOutcomes;static RETENTION_CLEANUP_INTERVAL=100;constructor(e=1e4,t){this.maxOutcomes=e,this.outcomeStore=new O(e),t?.enableEMACalibration&&this.enableCalibration(),t?.enableAutoEscalation&&this.enableAutoEscalation()}async initialize(){try{this.db=w(),this.db.isInitialized()||await this.db.initialize(),await this.loadFromDb(),this.loadCalibratorState()}catch(e){console.warn("[RoutingFeedbackCollector] DB init failed, using memory-only:",g(e)),this.db=null}}async loadFromDb(){if(!this.db)return;let t=this.db.getDatabase().prepare(`
-      SELECT * FROM routing_outcomes ORDER BY created_at DESC LIMIT ?
-    `).all(this.maxOutcomes);for(let o of t.reverse()){let i={id:o.id,task:f(o.task_json),decision:f(o.decision_json),usedAgent:o.used_agent,followedRecommendation:!!o.followed_recommendation,outcome:{success:!!o.success,qualityScore:o.quality_score,durationMs:o.duration_ms,error:o.error||void 0},timestamp:new Date(o.created_at),advisorConsultation:o.advisor_consultation_json?f(o.advisor_consultation_json):void 0};this.outcomeStore.add(i)}t.length>0&&console.log(`[RoutingFeedbackCollector] Loaded ${t.length} outcomes from DB`)}persistOutcome(e){if(this.db)try{let t=this.db.getDatabase();if(!m.schemaMigrated){for(let r of["ALTER TABLE routing_outcomes ADD COLUMN model_tier TEXT","ALTER TABLE routing_outcomes ADD COLUMN advisor_consultation_json TEXT"])try{t.prepare(r).run()}catch{}m.schemaMigrated=!0}let o=this.inferTier(e.usedAgent),i=e.advisorConsultation?JSON.stringify(e.advisorConsultation):null;t.prepare(`
-        INSERT OR REPLACE INTO routing_outcomes (
-          id, task_json, decision_json, used_agent,
-          followed_recommendation, success, quality_score,
-          duration_ms, error, model_tier, advisor_consultation_json
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-      `).run(e.id,JSON.stringify(e.task),JSON.stringify(e.decision),e.usedAgent,e.followedRecommendation?1:0,e.outcome.success?1:0,e.outcome.qualityScore,e.outcome.durationMs,e.outcome.error||null,o,i),this.persistCount++,this.persistCount%m.RETENTION_CLEANUP_INTERVAL===0&&this.enforceRetention(t)}catch(t){console.warn("[RoutingFeedbackCollector] Failed to persist outcome:",g(t))}}loadAdvisorConsultationSidecar(e){try{let{readdirSync:t,readFileSync:o}=v("fs"),{join:i}=v("path"),{homedir:r}=v("os"),s=i(r(),".agentic-qe","advisor","consultations"),n=t(s).filter(l=>l.endsWith(".json")).sort().reverse();if(n.length===0)return;let c=n[0],d=JSON.parse(o(i(s,c),"utf-8"));return Date.now()-new Date(d.timestamp).getTime()>300*1e3?void 0:d}catch{return}}inferTier(e){let t=e.toLowerCase();return t.includes("booster")||t==="tier-0"?"booster":t==="tier-1"||t.includes("haiku")?"haiku":t==="tier-2"||t.includes("sonnet")?"sonnet":t.includes("opus")?"opus":"sonnet"}enforceRetention(e){try{let t=this.maxOutcomes*2;e.prepare(`
-        DELETE FROM routing_outcomes WHERE id NOT IN (
-          SELECT id FROM routing_outcomes ORDER BY created_at DESC LIMIT ?
-        )
-      `).run(t)}catch(t){console.warn("[RoutingFeedbackCollector] Retention cleanup failed:",g(t))}}loadCalibratorState(){if(!(!this.db||!this.calibrator))try{let t=this.db.getDatabase().prepare("SELECT value FROM kv_store WHERE key = 'routing:ema_calibrator_state'").get();if(t){let o=f(t.value);o&&typeof o=="object"&&(this.calibrator.deserialize(o),console.log("[RoutingFeedbackCollector] Loaded EMA calibrator state from DB"))}}catch(e){console.warn("[RoutingFeedbackCollector] Failed to load calibrator state:",g(e))}}persistCalibratorState(){if(!(!this.db||!this.calibrator))try{let e=this.db.getDatabase(),t=JSON.stringify(this.calibrator.serialize());e.prepare("INSERT OR REPLACE INTO kv_store (key, value, updated_at) VALUES (?, ?, datetime('now'))").run("routing:ema_calibrator_state",t)}catch(e){console.warn("[RoutingFeedbackCollector] Failed to persist calibrator state:",g(e))}}loadEconomicState(){if(!(!this.db||!this.economicModel))try{let t=this.db.getDatabase().prepare("SELECT value FROM kv_store WHERE key = 'routing:economic_quality_estimates'").get();if(t){let o=f(t.value);o&&typeof o=="object"&&(this.economicModel.deserializeEstimates(o),console.log("[RoutingFeedbackCollector] Loaded economic quality estimates from DB"))}}catch(e){console.warn("[RoutingFeedbackCollector] Failed to load economic state:",g(e))}}persistEconomicState(){if(!(!this.db||!this.economicModel))try{let e=this.db.getDatabase(),t=JSON.stringify(this.economicModel.serializeEstimates());e.prepare("INSERT OR REPLACE INTO kv_store (key, value, updated_at) VALUES (?, ?, datetime('now'))").run("routing:economic_quality_estimates",t)}catch(e){console.warn("[RoutingFeedbackCollector] Failed to persist economic state:",g(e))}}connectRouter(e){this.router=e}enableCalibration(e){this.calibrator=new p(e)}getCalibratedWeight(e){return this.calibrator?.getCalibratedWeight(e)??1}enableAutoEscalation(e){this.escalationTracker=new b(e)}getEscalationState(e){return this.escalationTracker?.getState(e)??null}enableEconomicRouting(e,t){let o=t??D();this.economicModel=new C(o,e),this.loadEconomicState()}getEconomicReport(){return this.economicModel?.getEconomicReport()??null}getEconomicScore(e){return this.economicModel?.scoreTiers(e)??null}recordOutcome(e,t,o,i,r){let s=r;s||(s=this.loadAdvisorConsultationSidecar(e));let n={id:`outcome-${Date.now()}-${L().slice(0,8)}`,task:e,decision:t,usedAgent:o,followedRecommendation:o===t.recommended,outcome:i,timestamp:new Date,advisorConsultation:s};if(this.outcomeStore.add(n),this.persistOutcome(n),this.router&&this.router.updateAgentPerformance(o,i.success,i.qualityScore,i.durationMs),this.calibrator&&(this.calibrator.recordOutcome(o,i.success,i.qualityScore),this.persistCount%10===0&&this.persistCalibratorState()),this.escalationTracker){let c=t.recommended===o?"sonnet":"haiku",d=this.escalationTracker.recordOutcome(o,i.success,c);d.action!=="none"&&console.log(`[RoutingFeedbackCollector] Agent "${o}" ${d.action}d: ${d.previousTier} \u2192 ${d.newTier}`)}if(this.economicModel){let c=this.inferTier(o);this.economicModel.updateFromOutcome(n,c),this.economicPersistCounter++,this.economicPersistCounter%m.ECONOMIC_PERSIST_INTERVAL===0&&this.persistEconomicState()}return n}getAgentMetrics(e){let t=this.outcomeStore.getByAgent(e);if(t.length===0)return null;let o=t.filter(u=>u.outcome.success).length,i=t.reduce((u,h)=>u+h.outcome.durationMs,0),r=t.reduce((u,h)=>u+h.outcome.qualityScore,0),s=t.filter(u=>u.decision.recommended!==u.usedAgent&&u.decision.recommended===e).length,n=t.filter(u=>u.decision.recommended!==u.usedAgent&&u.usedAgent===e).length,c=t.slice(-10),d=c.filter(u=>u.outcome.success).length/c.length,a=o/t.length,l;return d>a+.1?l="improving":d<a-.1?l="declining":l="stable",{agentId:e,totalTasks:t.length,successfulTasks:o,successRate:o/t.length,avgQualityScore:r/t.length,avgDurationMs:i/t.length,overriddenCount:s,selectedOverOthersCount:n,trend:l,updatedAt:new Date}}getAllAgentMetrics(){let e=[];for(let t of _){let o=this.getAgentMetrics(t.id);o&&e.push(o)}return e.sort((t,o)=>o.successRate-t.successRate)}analyzeRoutingAccuracy(){let e=this.outcomeStore.getAll();if(e.length===0)return{totalOutcomes:0,followedRecommendations:0,overrideRate:0,recommendationSuccessRate:0,overrideSuccessRate:0,confidenceCorrelation:0};let t=e.filter(n=>n.followedRecommendation),o=e.filter(n=>!n.followedRecommendation),i=t.filter(n=>n.outcome.success).length,r=o.filter(n=>n.outcome.success).length,s=this.calculateConfidenceCorrelation(e);return{totalOutcomes:e.length,followedRecommendations:t.length,overrideRate:o.length/e.length,recommendationSuccessRate:t.length>0?i/t.length:0,overrideSuccessRate:o.length>0?r/o.length:0,confidenceCorrelation:s}}calculateConfidenceCorrelation(e){if(e.length<2)return 0;let t=e.map(a=>a.decision.confidence),o=e.map(a=>a.outcome.success?1:0),i=t.reduce((a,l)=>a+l,0)/t.length,r=o.reduce((a,l)=>a+l,0)/o.length,s=0,n=0,c=0;for(let a=0;a<e.length;a++){let l=t[a]-i,u=o[a]-r;s+=l*u,n+=l*l,c+=u*u}let d=Math.sqrt(n*c);return d===0?0:s/d}getImprovementRecommendations(){let e=[],t=this.analyzeRoutingAccuracy();if(t.totalOutcomes<50)return e.push("Collect more routing outcomes for reliable analysis (at least 50)"),e;t.overrideRate>.3&&t.overrideSuccessRate>t.recommendationSuccessRate&&e.push("Users are frequently overriding recommendations with better results. Consider adjusting routing weights or updating agent capabilities."),t.confidenceCorrelation<.3&&e.push("Low correlation between confidence and success. Consider improving semantic matching or adjusting weight distribution.");let o=this.getAllAgentMetrics(),i=o.filter(s=>s.successRate<.5&&s.totalTasks>=10);i.length>0&&e.push(`Agents with low success rates: ${i.map(s=>s.agentId).join(", ")}. Consider reviewing their capability mappings.`);let r=o.filter(s=>s.trend==="declining"&&s.totalTasks>=10);return r.length>0&&e.push(`Agents with declining performance: ${r.map(s=>s.agentId).join(", ")}. Monitor for potential issues.`),e.length===0&&e.push("Routing performance is healthy. Continue collecting feedback."),e}exportOutcomes(){return this.outcomeStore.getAll()}importOutcomes(e){for(let t of e)this.outcomeStore.add(t)}getStats(){let e=this.outcomeStore.getAll(),t=new Set(e.map(o=>o.usedAgent));return{totalOutcomes:this.outcomeStore.size,uniqueAgentsUsed:t.size,recentOverrides:this.outcomeStore.getRecentOverrides().length}}clear(){this.outcomeStore.clear()}};function re(m=1e4,e){return new M(m,e)}export{M as a,re as b};