agentic-qe 3.3.1 → 3.3.2

package/v3/dist/cli/bundle.js

@@ -9372,7 +9372,11 @@ var HybridMemoryBackend = class {
 import * as path9 from "path";
 import * as fs8 from "fs";
 
+// src/domains/test-generation/plugin.ts
+init_types();
+
 // src/domains/domain-interface.ts
+init_types();
 var BaseDomainPlugin = class {
   constructor(eventBus, memory) {
     this.eventBus = eventBus;
@@ -9428,6 +9432,95 @@ var BaseDomainPlugin = class {
   updateHealth(updates) {
     this._health = { ...this._health, ...updates };
   }
+  // ============================================================================
+  // Task Execution (Queen-Domain Integration)
+  // ============================================================================
+  /**
+   * Get task type to handler mapping
+   * Override in subclasses to register domain-specific task handlers
+   *
+   * @example
+   * protected override getTaskHandlers(): Map<string, TaskHandler> {
+   *   return new Map([
+   *     ['execute-tests', async (payload) => this.coordinator.execute(payload)],
+   *     ['detect-flaky', async (payload) => this.coordinator.detectFlaky(payload)],
+   *   ]);
+   * }
+   */
+  getTaskHandlers() {
+    return /* @__PURE__ */ new Map();
+  }
+  /**
+   * Check if domain can handle a task type
+   * Based on registered task handlers
+   */
+  canHandleTask(taskType) {
+    return this.getTaskHandlers().has(taskType);
+  }
+  /**
+   * Execute a task assigned by Queen Coordinator
+   * Routes to the appropriate handler based on task type
+   *
+   * @param request - Task execution request from Queen
+   * @param onComplete - Callback to report task completion
+   * @returns Success if task was accepted, Error if no handler exists
+   */
+  async executeTask(request, onComplete) {
+    const handlers = this.getTaskHandlers();
+    const handler = handlers.get(request.taskType);
+    if (!handler) {
+      return err(
+        new Error(`Domain ${this.name} has no handler for task type: ${request.taskType}`)
+      );
+    }
+    this.runTaskAsync(request, handler, onComplete);
+    return ok(void 0);
+  }
+  /**
+   * Run task asynchronously and report completion via callback
+   * Handles timing, success/failure, and error capture
+   */
+  async runTaskAsync(request, handler, onComplete) {
+    const startTime = Date.now();
+    try {
+      const result = await handler(request.payload);
+      const duration = Date.now() - startTime;
+      const taskResult = {
+        taskId: request.taskId,
+        success: result.success,
+        data: result.success ? result.value : void 0,
+        error: !result.success ? result.error?.message : void 0,
+        duration
+      };
+      await onComplete(taskResult);
+      this.updateHealth({
+        lastActivity: /* @__PURE__ */ new Date(),
+        agents: {
+          ...this._health.agents,
+          active: Math.max(0, this._health.agents.active - 1),
+          idle: this._health.agents.idle + 1
+        }
+      });
+    } catch (error) {
+      const duration = Date.now() - startTime;
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      await onComplete({
+        taskId: request.taskId,
+        success: false,
+        error: errorMessage,
+        duration
+      });
+      this.updateHealth({
+        lastActivity: /* @__PURE__ */ new Date(),
+        errors: [...this._health.errors.slice(-9), errorMessage],
+        agents: {
+          ...this._health.agents,
+          active: Math.max(0, this._health.agents.active - 1),
+          failed: this._health.agents.failed + 1
+        }
+      });
+    }
+  }
 };
 
 // src/domains/test-generation/coordinator.ts
@@ -9487,7 +9580,8 @@ var SecurityComplianceEvents = {
 var LearningOptimizationEvents = {
   PatternConsolidated: "learning-optimization.PatternConsolidated",
   TransferCompleted: "learning-optimization.TransferCompleted",
-  OptimizationApplied: "learning-optimization.OptimizationApplied"
+  OptimizationApplied: "learning-optimization.OptimizationApplied",
+  DreamCycleCompleted: "learning-optimization.dream.completed"
 };
 var AllDomainEvents = {
   ...TestGenerationEvents,
@@ -15573,6 +15667,10 @@ var TestGenerationCoordinator = class {
   flashAttention = null;
   decisionTransformer = null;
   testEmbeddings = /* @__PURE__ */ new Map();
+  // Domain identifier for dream insight filtering
+  domainName = "test-generation";
+  // Cache of recent dream insights for test enhancement
+  recentDreamInsights = [];
   // Coherence gate (ADR-052)
   coherenceGate = null;
   /**
@@ -16006,6 +16104,181 @@ var TestGenerationCoordinator = class {
       "test-execution.TestRunCompleted",
       this.handleTestRunCompleted.bind(this)
     );
+    this.subscribeToDreamEvents();
+  }
+  // ============================================================================
+  // Dream Event Handling (ADR-021 Integration)
+  // ============================================================================
+  /**
+   * Subscribe to dream cycle completion events from learning-optimization domain.
+   * Dream insights can suggest edge cases, novel test patterns, and optimization opportunities.
+   */
+  subscribeToDreamEvents() {
+    this.eventBus.subscribe(
+      LearningOptimizationEvents.DreamCycleCompleted,
+      this.handleDreamCycleCompleted.bind(this)
+    );
+  }
+  /**
+   * Handle dream cycle completion event.
+   * Filters insights relevant to test generation and applies actionable ones.
+   */
+  async handleDreamCycleCompleted(event) {
+    const { insights, cycleId } = event.payload;
+    if (!insights || insights.length === 0) {
+      return;
+    }
+    const relevantInsights = insights.filter((insight) => {
+      const actionRelevant = insight.suggestedAction?.toLowerCase().includes(this.domainName) || insight.suggestedAction?.toLowerCase().includes("test") || insight.suggestedAction?.toLowerCase().includes("coverage");
+      const conceptsRelevant = insight.sourceConcepts.some(
+        (c) => c.toLowerCase().includes("test") || c.toLowerCase().includes(this.domainName) || c.toLowerCase().includes("coverage") || c.toLowerCase().includes("edge-case")
+      );
+      const typeRelevant = insight.type === "optimization" || insight.type === "gap_detection" || insight.type === "novel_association";
+      return actionRelevant || conceptsRelevant || typeRelevant && insight.actionable;
+    });
+    if (relevantInsights.length === 0) {
+      return;
+    }
+    console.log(
+      `[${this.domainName}] Received ${relevantInsights.length} relevant dream insights from cycle ${cycleId}`
+    );
+    for (const insight of relevantInsights) {
+      if (insight.confidenceScore > 0.7 && insight.actionable) {
+        await this.applyDreamInsight(insight, cycleId);
+      }
+      this.recentDreamInsights.push({
+        ...insight,
+        receivedAt: /* @__PURE__ */ new Date()
+      });
+    }
+    if (this.recentDreamInsights.length > 50) {
+      this.recentDreamInsights = this.recentDreamInsights.slice(-50);
+    }
+  }
+  /**
+   * Apply a dream insight by storing it as a learned pattern via SONA.
+   * This allows the insight to influence future test generation decisions.
+   *
+   * @param insight - The dream insight to apply
+   * @param cycleId - The dream cycle ID for tracking
+   */
+  async applyDreamInsight(insight, cycleId) {
+    console.log(
+      `[${this.domainName}] Applying dream insight: ${insight.description.slice(0, 100)}...`
+    );
+    if (this.qesona) {
+      try {
+        const state2 = {
+          id: `dream-insight-${insight.id}`,
+          features: this.encodeInsightAsFeatures(insight),
+          metadata: {
+            insightType: insight.type,
+            cycleId,
+            sourceConcepts: insight.sourceConcepts
+          }
+        };
+        const action = {
+          type: "dream-insight",
+          value: insight.suggestedAction || insight.description
+        };
+        const pattern = this.qesona.createPattern(
+          state2,
+          action,
+          {
+            reward: insight.confidenceScore,
+            success: true,
+            quality: insight.noveltyScore
+          },
+          "dream-derived",
+          this.domainName,
+          {
+            insightId: insight.id,
+            cycleId,
+            description: insight.description,
+            suggestedAction: insight.suggestedAction
+          }
+        );
+        console.log(
+          `[${this.domainName}] Created SONA pattern ${pattern.id} from dream insight`
+        );
+      } catch (error) {
+        console.error(
+          `[${this.domainName}] Failed to store dream insight pattern:`,
+          error
+        );
+      }
+    }
+    await this.memory.set(
+      `${this.domainName}:dream-insight:${insight.id}`,
+      {
+        insight,
+        cycleId,
+        appliedAt: (/* @__PURE__ */ new Date()).toISOString()
+      },
+      { namespace: this.domainName, ttl: 86400 * 7 }
+      // 7 days
+    );
+  }
+  /**
+   * Get recent dream insights filtered by type.
+   * Used by test generation methods to enhance test case discovery.
+   *
+   * @param insightType - Optional type filter (e.g., 'novel_association', 'gap_detection')
+   * @returns Array of recent dream insights
+   */
+  getRecentDreamInsights(insightType) {
+    const cutoffTime = Date.now() - 24 * 60 * 60 * 1e3;
+    return this.recentDreamInsights.filter((insight) => {
+      const isRecent = insight.receivedAt.getTime() > cutoffTime;
+      const matchesType = !insightType || insight.type === insightType;
+      return isRecent && matchesType;
+    });
+  }
+  /**
+   * Enhance test generation request with dream insights for edge case discovery.
+   * Queries recent dream insights to suggest additional test scenarios.
+   *
+   * @param request - The original test generation request
+   * @returns Array of suggested edge case descriptions from dream insights
+   */
+  async enhanceWithDreamInsights(request) {
+    const suggestions = [];
+    const insights = this.getRecentDreamInsights();
+    const edgeCaseInsights = insights.filter(
+      (i) => (i.type === "novel_association" || i.type === "gap_detection") && i.actionable && i.confidenceScore > 0.6
+    );
+    for (const insight of edgeCaseInsights) {
+      if (insight.suggestedAction) {
+        const isRelevant = request.sourceFiles.some(
+          (f) => insight.sourceConcepts.some((c) => f.toLowerCase().includes(c.toLowerCase()))
+        ) || insight.suggestedAction.toLowerCase().includes(request.testType);
+        if (isRelevant) {
+          suggestions.push(insight.suggestedAction);
+        }
+      }
+    }
+    return suggestions.slice(0, 5);
+  }
+  /**
+   * Encode a dream insight as feature vector for SONA pattern creation.
+   */
+  encodeInsightAsFeatures(insight) {
+    const features = [];
+    const typeMap = {
+      pattern_merge: 0.2,
+      novel_association: 0.4,
+      optimization: 0.6,
+      gap_detection: 0.8
+    };
+    features.push(typeMap[insight.type] || 0.5);
+    features.push(insight.confidenceScore);
+    features.push(insight.noveltyScore);
+    features.push(insight.actionable ? 1 : 0);
+    features.push(Math.min(1, insight.sourceConcepts.length / 10));
+    while (features.length < 384) {
+      features.push(0);
+    }
+    return features.slice(0, 384);
   }
   async handleCoverageGapDetected(event) {
     const payload = event.payload;
@@ -16407,6 +16680,89 @@ var TestGenerationPlugin = class extends BaseDomainPlugin {
     return api;
   }
   // ============================================================================
+  // Task Handlers (Queen-Domain Integration)
+  // ============================================================================
+  /**
+   * Get task handlers for direct Queen-Domain integration
+   * Maps task types to coordinator methods
+   */
+  getTaskHandlers() {
+    return /* @__PURE__ */ new Map([
+      // Generate tests task - main task type for this domain
+      ["generate-tests", async (payload) => {
+        if (!this.coordinator) {
+          return err(new Error("Coordinator not initialized"));
+        }
+        const sourceFiles = payload.sourceFiles;
+        const testType = payload.testType;
+        const framework = payload.framework;
+        if (!sourceFiles || sourceFiles.length === 0) {
+          return err(new Error("Invalid generate-tests payload: missing sourceFiles"));
+        }
+        const request = {
+          sourceFiles,
+          testType: testType ?? "unit",
+          framework: framework ?? "vitest",
+          coverageTarget: payload.coverageTarget,
+          patterns: payload.patterns
+        };
+        return this.coordinator.generateTests(request);
+      }],
+      // TDD tests generation task
+      ["generate-tdd-tests", async (payload) => {
+        if (!this.coordinator) {
+          return err(new Error("Coordinator not initialized"));
+        }
+        const feature = payload.feature;
+        const behavior = payload.behavior;
+        const framework = payload.framework;
+        const phase = payload.phase;
+        if (!feature || !behavior) {
+          return err(new Error("Invalid generate-tdd-tests payload: missing feature or behavior"));
+        }
+        return this.coordinator.generateTDDTests({
+          feature,
+          behavior,
+          framework: framework ?? "vitest",
+          phase: phase ?? "red"
+        });
+      }],
+      // Property-based tests generation task
+      ["generate-property-tests", async (payload) => {
+        if (!this.coordinator) {
+          return err(new Error("Coordinator not initialized"));
+        }
+        const fn = payload.function;
+        const properties = payload.properties;
+        if (!fn || !properties || properties.length === 0) {
+          return err(new Error("Invalid generate-property-tests payload: missing function or properties"));
+        }
+        return this.coordinator.generatePropertyTests({
+          function: fn,
+          properties,
+          constraints: payload.constraints
+        });
+      }],
+      // Test data generation task
+      ["generate-test-data", async (payload) => {
+        if (!this.coordinator) {
+          return err(new Error("Coordinator not initialized"));
+        }
+        const schema = payload.schema;
+        const count = payload.count;
+        if (!schema) {
+          return err(new Error("Invalid generate-test-data payload: missing schema"));
+        }
+        return this.coordinator.generateTestData({
+          schema,
+          count: count ?? 10,
+          locale: payload.locale,
+          preserveRelationships: payload.preserveRelationships
+        });
+      }]
+    ]);
+  }
+  // ============================================================================
   // Lifecycle Methods
   // ============================================================================
   async onInitialize() {
@@ -16592,6 +16948,9 @@ function createTestGenerationPlugin(eventBus, memory, agentCoordinator, config)
   return new TestGenerationPlugin(eventBus, memory, agentCoordinator, config);
 }
 
+// src/domains/test-execution/plugin.ts
+init_types();
+
 // src/domains/test-execution/coordinator.ts
 init_types();
 import { v4 as uuidv410 } from "uuid";
@@ -20270,7 +20629,7 @@ function resolveTarget(target) {
       return target.value;
   }
 }
-function ok2(value) {
+function ok3(value) {
   return { success: true, value };
 }
 function err2(error) {
@@ -20355,7 +20714,7 @@ var AgentBrowserClient = class {
           if (options?.viewport) {
             await this.setViewport(options.viewport.width, options.viewport.height);
           }
-          return ok2(toSessionInfo(existingSession));
+          return ok3(toSessionInfo(existingSession));
         }
       }
       const available = await this.isAvailable();
@@ -20382,7 +20741,7 @@ var AgentBrowserClient = class {
       if (options?.deviceName) {
         await this.setDevice(options.deviceName);
       }
-      return ok2(toSessionInfo(session));
+      return ok3(toSessionInfo(session));
     } catch (error) {
       const browserError = new BrowserError(
         error instanceof Error ? error.message : String(error),
@@ -20415,7 +20774,7 @@ var AgentBrowserClient = class {
       }
       this.isLaunched = false;
       this.currentSessionId = null;
-      return ok2(void 0);
+      return ok3(void 0);
     } catch (error) {
       this.isLaunched = false;
       this.currentSessionId = null;
@@ -20463,7 +20822,7 @@ var AgentBrowserClient = class {
         "JSON.stringify({ title: document.title, url: window.location.href })"
       );
       const pageInfo = evalResult.success && evalResult.data ? typeof evalResult.data === "string" ? JSON.parse(evalResult.data) : evalResult.data : { title: "", url };
-      return ok2({
+      return ok3({
         url: pageInfo.url || url,
         title: pageInfo.title || "",
         success: true,
@@ -20489,7 +20848,7 @@ var AgentBrowserClient = class {
       if (!result.success) {
         return err2(new BrowserError(result.error ?? "Reload failed", "RELOAD_FAILED", "agent-browser"));
       }
-      return ok2(void 0);
+      return ok3(void 0);
     } catch (error) {
       return err2(
         new BrowserError(
@@ -20510,7 +20869,7 @@ var AgentBrowserClient = class {
       if (!result.success) {
         return err2(new BrowserError(result.error ?? "Go back failed", "HISTORY_FAILED", "agent-browser"));
       }
-      return ok2(void 0);
+      return ok3(void 0);
     } catch (error) {
       return err2(
         new BrowserError(
@@ -20531,7 +20890,7 @@ var AgentBrowserClient = class {
       if (!result.success) {
         return err2(new BrowserError(result.error ?? "Go forward failed", "HISTORY_FAILED", "agent-browser"));
       }
-      return ok2(void 0);
+      return ok3(void 0);
     } catch (error) {
       return err2(
         new BrowserError(
@@ -20556,7 +20915,7 @@ var AgentBrowserClient = class {
       if (!result.success) {
         return err2(new BrowserElementNotFoundError("agent-browser", target, new Error(result.error)));
       }
-      return ok2(void 0);
+      return ok3(void 0);
     } catch (error) {
       return err2(
         new BrowserError(
@@ -20578,7 +20937,7 @@ var AgentBrowserClient = class {
       if (!result.success) {
         return err2(new BrowserElementNotFoundError("agent-browser", target, new Error(result.error)));
       }
-      return ok2(void 0);
+      return ok3(void 0);
     } catch (error) {
       return err2(
         new BrowserError(
@@ -20616,7 +20975,7 @@ var AgentBrowserClient = class {
           text = obj.result;
         }
       }
-      return ok2(String(text ?? ""));
+      return ok3(String(text ?? ""));
     } catch (error) {
       return err2(
         new BrowserError(
@@ -20636,9 +20995,9 @@ var AgentBrowserClient = class {
       const resolvedTarget = resolveTarget(target);
       const result = this.executor.isVisible(resolvedTarget);
       if (!result.success) {
-        return ok2(false);
+        return ok3(false);
       }
-      return ok2(Boolean(result.data));
+      return ok3(Boolean(result.data));
     } catch (error) {
       return err2(
         new BrowserError(
@@ -20670,7 +21029,7 @@ var AgentBrowserClient = class {
         const parsed = typeof dimensionsResult.data === "string" ? JSON.parse(dimensionsResult.data) : dimensionsResult.data;
         dimensions = { width: parsed.width || 1280, height: parsed.height || 720 };
       }
-      return ok2({
+      return ok3({
         base64: options?.path ? void 0 : String(result.data ?? ""),
         path: options?.path,
         format: "png",
@@ -20711,7 +21070,7 @@ var AgentBrowserClient = class {
           value = obj.result;
         }
       }
-      return ok2(value);
+      return ok3(value);
     } catch (error) {
       return err2(
         new BrowserError(
@@ -20752,7 +21111,7 @@ var AgentBrowserClient = class {
       if (titleResult.success) {
         parsed.title = String(titleResult.data);
       }
-      return ok2(toTypedSnapshot(parsed));
+      return ok3(toTypedSnapshot(parsed));
     } catch (error) {
       return err2(
         new BrowserError(
@@ -20773,7 +21132,7 @@ var AgentBrowserClient = class {
   async createSession(name) {
     try {
       const session = await this.sessionManager.createSession({ name });
-      return ok2(toSessionInfo(session));
+      return ok3(toSessionInfo(session));
     } catch (error) {
       return err2(
         new BrowserError(
@@ -20798,7 +21157,7 @@ var AgentBrowserClient = class {
         headed: this.config.headed,
         debug: this.config.debug
       });
-      return ok2(void 0);
+      return ok3(void 0);
     } catch (error) {
       return err2(
         new BrowserError(
@@ -20816,7 +21175,7 @@ var AgentBrowserClient = class {
   async listSessions() {
     try {
       const sessions = this.sessionManager.listSessions();
-      return ok2(sessions.map(toSessionInfo));
+      return ok3(sessions.map(toSessionInfo));
     } catch (error) {
       return err2(
         new BrowserError(
@@ -20845,7 +21204,7 @@ var AgentBrowserClient = class {
       if (!result.success) {
         return err2(new BrowserError(result.error ?? "Mock route failed", "MOCK_ROUTE_FAILED", "agent-browser"));
       }
-      return ok2(void 0);
+      return ok3(void 0);
     } catch (error) {
       return err2(
         new BrowserError(
@@ -20866,7 +21225,7 @@ var AgentBrowserClient = class {
       if (!result.success) {
         return err2(new BrowserError(result.error ?? "Abort route failed", "ABORT_ROUTE_FAILED", "agent-browser"));
       }
-      return ok2(void 0);
+      return ok3(void 0);
     } catch (error) {
       return err2(
         new BrowserError(
@@ -20887,7 +21246,7 @@ var AgentBrowserClient = class {
       if (!result.success) {
         return err2(new BrowserError(result.error ?? "Clear routes failed", "CLEAR_ROUTES_FAILED", "agent-browser"));
       }
-      return ok2(void 0);
+      return ok3(void 0);
     } catch (error) {
       return err2(
         new BrowserError(
@@ -20911,7 +21270,7 @@ var AgentBrowserClient = class {
       if (!result.success) {
         return err2(new BrowserError(result.error ?? "Set device failed", "SET_DEVICE_FAILED", "agent-browser"));
       }
-      return ok2(void 0);
+      return ok3(void 0);
     } catch (error) {
       return err2(
         new BrowserError(
@@ -20932,7 +21291,7 @@ var AgentBrowserClient = class {
       if (!result.success) {
         return err2(new BrowserError(result.error ?? "Set viewport failed", "SET_VIEWPORT_FAILED", "agent-browser"));
       }
-      return ok2(void 0);
+      return ok3(void 0);
     } catch (error) {
       return err2(
         new BrowserError(
@@ -20956,7 +21315,7 @@ var AgentBrowserClient = class {
       if (!result.success) {
         return err2(new BrowserError(result.error ?? "Save state failed", "SAVE_STATE_FAILED", "agent-browser"));
       }
-      return ok2(void 0);
+      return ok3(void 0);
     } catch (error) {
       return err2(
         new BrowserError(
@@ -20977,7 +21336,7 @@ var AgentBrowserClient = class {
       if (!result.success) {
         return err2(new BrowserError(result.error ?? "Load state failed", "LOAD_STATE_FAILED", "agent-browser"));
       }
-      return ok2(void 0);
+      return ok3(void 0);
     } catch (error) {
       return err2(
         new BrowserError(
@@ -21004,7 +21363,7 @@ var AgentBrowserClient = class {
           new BrowserTimeoutError("agent-browser", `waitForElement(${resolvedTarget})`, new Error(result.error))
         );
       }
-      return ok2(void 0);
+      return ok3(void 0);
     } catch (error) {
       return err2(
         new BrowserError(
@@ -21026,7 +21385,7 @@ var AgentBrowserClient = class {
       if (!result.success) {
         return err2(new BrowserTimeoutError("agent-browser", `waitForText("${text}")`, new Error(result.error)));
       }
-      return ok2(void 0);
+      return ok3(void 0);
     } catch (error) {
       return err2(
         new BrowserError(
@@ -21048,7 +21407,7 @@ var AgentBrowserClient = class {
       if (!result.success) {
         return err2(new BrowserTimeoutError("agent-browser", `waitForUrl("${pattern}")`, new Error(result.error)));
       }
-      return ok2(void 0);
+      return ok3(void 0);
     } catch (error) {
       return err2(
         new BrowserError(
@@ -21070,7 +21429,7 @@ var AgentBrowserClient = class {
       if (!result.success) {
         return err2(new BrowserTimeoutError("agent-browser", "waitForNetworkIdle", new Error(result.error)));
       }
-      return ok2(void 0);
+      return ok3(void 0);
     } catch (error) {
       return err2(
         new BrowserError(
@@ -21097,7 +21456,7 @@ var AgentBrowserClient = class {
       if (!result.success) {
         return err2(new BrowserError(result.error ?? "Start trace failed", "START_TRACE_FAILED", "agent-browser"));
       }
-      return ok2(void 0);
+      return ok3(void 0);
     } catch (error) {
       return err2(
         new BrowserError(
@@ -21121,7 +21480,7 @@ var AgentBrowserClient = class {
       if (!result.success) {
         return err2(new BrowserError(result.error ?? "Stop trace failed", "STOP_TRACE_FAILED", "agent-browser"));
       }
-      return ok2(result.data ?? outputPath);
+      return ok3(result.data ?? outputPath);
     } catch (error) {
       return err2(
         new BrowserError(
@@ -23446,6 +23805,78 @@ var TestExecutionPlugin = class extends BaseDomainPlugin {
     return api;
   }
   // ============================================================================
+  // Task Handlers (Queen-Domain Integration)
+  // ============================================================================
+  /**
+   * Get task handlers for direct Queen-Domain integration
+   * Maps task types to coordinator methods
+   */
+  getTaskHandlers() {
+    return /* @__PURE__ */ new Map([
+      // Execute tests task - main task type for this domain
+      ["execute-tests", async (payload) => {
+        if (!this.coordinator) {
+          return err(new Error("Coordinator not initialized"));
+        }
+        if (payload.testFiles && Array.isArray(payload.testFiles)) {
+          const request = {
+            testFiles: payload.testFiles,
+            parallel: payload.parallel,
+            retryCount: payload.retryCount,
+            timeout: payload.timeout,
+            workers: payload.workers
+          };
+          return this.coordinator.runTests(request);
+        } else if (payload.framework) {
+          const request = {
+            testFiles: payload.testFiles || [],
+            framework: payload.framework,
+            timeout: payload.timeout,
+            env: payload.env,
+            reporters: payload.reporters
+          };
+          return this.coordinator.execute(request);
+        }
+        return err(new Error("Invalid execute-tests payload: missing testFiles or framework"));
+      }],
+      // Detect flaky tests task
+      ["detect-flaky", async (payload) => {
+        if (!this.coordinator) {
+          return err(new Error("Coordinator not initialized"));
+        }
+        const testFiles = payload.testFiles;
+        const runs = payload.runs;
+        const threshold = payload.threshold;
+        if (!testFiles) {
+          return err(new Error("Invalid detect-flaky payload: missing testFiles"));
+        }
+        return this.coordinator.detectFlaky({
+          testFiles,
+          runs: runs ?? 5,
+          threshold: threshold ?? 0.1
+        });
+      }],
+      // Retry failed tests task
+      ["retry-tests", async (payload) => {
+        if (!this.coordinator) {
+          return err(new Error("Coordinator not initialized"));
+        }
+        const runId = payload.runId;
+        const failedTests = payload.failedTests;
+        const maxRetries = payload.maxRetries;
+        if (!runId || !failedTests) {
+          return err(new Error("Invalid retry-tests payload: missing runId or failedTests"));
+        }
+        return this.coordinator.retry({
+          runId,
+          failedTests,
+          maxRetries: maxRetries ?? 3,
+          backoff: payload.backoff
+        });
+      }]
+    ]);
+  }
+  // ============================================================================
   // Lifecycle Hooks
   // ============================================================================
   async onInitialize() {
@@ -23553,6 +23984,9 @@ function createTestExecutionPlugin(eventBus, memory) {
   return new TestExecutionPlugin(eventBus, memory);
 }
 
+// src/domains/coverage-analysis/plugin.ts
+init_types();
+
 // src/domains/coverage-analysis/coordinator.ts
 init_types();
 
@@ -26003,6 +26437,75 @@ var CoverageAnalysisPlugin = class _CoverageAnalysisPlugin extends BaseDomainPlu
     return this.coordinator;
   }
   // ============================================================================
+  // Task Handlers (Queen-Domain Integration)
+  // ============================================================================
+  /**
+   * Get task handlers for direct Queen-Domain integration
+   * Maps task types to coordinator methods
+   */
+  getTaskHandlers() {
+    return /* @__PURE__ */ new Map([
+      // Analyze coverage task - main task type for this domain
+      ["analyze-coverage", async (payload) => {
+        const coverageData = payload.coverageData;
+        if (!coverageData) {
+          return err(new Error("Invalid analyze-coverage payload: missing coverageData"));
+        }
+        this._activeAnalyses++;
+        this.updateAgentMetrics();
+        try {
+          return await this.coordinator.analyze({
+            coverageData,
+            threshold: payload.threshold,
+            includeFileDetails: payload.includeFileDetails
+          });
+        } finally {
+          this._activeAnalyses--;
+          this.updateAgentMetrics();
+        }
+      }],
+      // Detect gaps task
+      ["detect-gaps", async (payload) => {
+        const coverageData = payload.coverageData;
+        if (!coverageData) {
+          return err(new Error("Invalid detect-gaps payload: missing coverageData"));
+        }
+        this._activeAnalyses++;
+        this.updateAgentMetrics();
+        try {
+          return await this.coordinator.detectGaps({
+            coverageData,
+            minCoverage: payload.minCoverage,
+            prioritize: payload.prioritize
+          });
+        } finally {
+          this._activeAnalyses--;
+          this.updateAgentMetrics();
+        }
+      }],
+      // Calculate risk task
+      ["calculate-risk", async (payload) => {
+        const file = payload.file;
+        const uncoveredLines = payload.uncoveredLines;
+        if (!file || !uncoveredLines) {
+          return err(new Error("Invalid calculate-risk payload: missing file or uncoveredLines"));
+        }
+        this._activeAnalyses++;
+        this.updateAgentMetrics();
+        try {
+          return await this.coordinator.calculateRisk({
+            file,
+            uncoveredLines,
+            factors: payload.factors
+          });
+        } finally {
+          this._activeAnalyses--;
+          this.updateAgentMetrics();
+        }
+      }]
+    ]);
+  }
+  // ============================================================================
   // Lifecycle Hooks
   // ============================================================================
   async onInitialize() {
@@ -26086,6 +26589,9 @@ function createCoverageAnalysisPlugin(eventBus, memory) {
   return new CoverageAnalysisPlugin(eventBus, memory);
 }
 
+// src/domains/quality-assessment/plugin.ts
+init_types();
+
 // src/domains/quality-assessment/coordinator.ts
 init_types();
 import { v4 as uuidv414 } from "uuid";
@@ -29461,6 +29967,8 @@ var QualityAssessmentCoordinator = class {
   claimVerifier;
   // Quality domain name for SONA
   domain = "quality-assessment";
+  // Cache of recent dream insights for quality assessment enhancement
+  recentDreamInsights = [];
   /**
    * Initialize the coordinator
    * Sets up Ruvector integrations: ActorCritic, QESONA, QEFlashAttention
@@ -29820,6 +30328,142 @@ var QualityAssessmentCoordinator = class {
       "security-compliance.SecurityAuditCompleted",
       this.handleSecurityAuditCompleted.bind(this)
     );
+    this.subscribeToDreamEvents();
+  }
+  // ============================================================================
+  // Dream Event Handling (ADR-021 Integration)
+  // ============================================================================
+  /**
+   * Subscribe to dream cycle completion events from learning-optimization domain.
+   * Dream insights can suggest quality improvements, threshold adjustments, and risk patterns.
+   */
+  subscribeToDreamEvents() {
+    this.eventBus.subscribe(
+      LearningOptimizationEvents.DreamCycleCompleted,
+      this.handleDreamCycleCompleted.bind(this)
+    );
+  }
+  /**
+   * Handle dream cycle completion event.
+   * Filters insights relevant to quality assessment and applies actionable ones.
+   */
+  async handleDreamCycleCompleted(event) {
+    const { insights, cycleId } = event.payload;
+    if (!insights || insights.length === 0) {
+      return;
+    }
+    const relevantInsights = insights.filter((insight) => {
+      const actionRelevant = insight.suggestedAction?.toLowerCase().includes(this.domain) || insight.suggestedAction?.toLowerCase().includes("quality") || insight.suggestedAction?.toLowerCase().includes("gate") || insight.suggestedAction?.toLowerCase().includes("threshold");
+      const conceptsRelevant = insight.sourceConcepts.some(
+        (c) => c.toLowerCase().includes("quality") || c.toLowerCase().includes(this.domain) || c.toLowerCase().includes("metric") || c.toLowerCase().includes("gate")
+      );
+      const typeRelevant = insight.type === "optimization" || insight.type === "pattern_merge";
+      return actionRelevant || conceptsRelevant || typeRelevant && insight.actionable;
+    });
+    if (relevantInsights.length === 0) {
+      return;
+    }
+    console.log(
+      `[${this.domain}] Received ${relevantInsights.length} relevant dream insights from cycle ${cycleId}`
+    );
+    for (const insight of relevantInsights) {
+      if (insight.confidenceScore > 0.7 && insight.actionable) {
+        await this.applyDreamInsight(insight, cycleId);
+      }
+      this.recentDreamInsights.push({
+        ...insight,
+        receivedAt: /* @__PURE__ */ new Date()
+      });
+    }
+    if (this.recentDreamInsights.length > 50) {
+      this.recentDreamInsights = this.recentDreamInsights.slice(-50);
+    }
+  }
+  /**
+   * Apply a dream insight by storing it as a learned pattern via SONA.
+   * This allows the insight to influence future quality assessment decisions.
+   *
+   * @param insight - The dream insight to apply
+   * @param cycleId - The dream cycle ID for tracking
+   */
+  async applyDreamInsight(insight, cycleId) {
+    console.log(
+      `[${this.domain}] Applying dream insight: ${insight.description.slice(0, 100)}...`
+    );
+    if (this.qesona) {
+      try {
+        const state2 = {
+          id: `dream-insight-${insight.id}`,
+          features: this.encodeInsightAsFeatures(insight),
+          metadata: {
+            insightType: insight.type,
+            cycleId,
+            sourceConcepts: insight.sourceConcepts
+          }
+        };
+        const action = {
+          type: "dream-insight",
+          value: insight.suggestedAction || insight.description
+        };
+        this.qesona.createPattern(
+          state2,
+          action,
+          {
+            reward: insight.confidenceScore,
+            success: true,
+            quality: insight.noveltyScore
+          },
+          "quality-assessment",
+          this.domain,
+          {
+            insightId: insight.id,
+            cycleId,
+            description: insight.description,
+            suggestedAction: insight.suggestedAction,
+            dreamDerived: true
+          }
+        );
+        console.log(
+          `[${this.domain}] Created SONA pattern from dream insight ${insight.id}`
+        );
+      } catch (error) {
+        console.error(
+          `[${this.domain}] Failed to store dream insight pattern:`,
+          error
+        );
+      }
+    }
+    await this.memory.set(
+      `${this.domain}:dream-insight:${insight.id}`,
+      {
+        insight,
+        cycleId,
+        appliedAt: (/* @__PURE__ */ new Date()).toISOString()
+      },
+      { namespace: this.domain, ttl: 86400 * 7 }
+      // 7 days
+    );
+  }
+  /**
+   * Encode a dream insight as feature vector for SONA pattern creation.
+   */
+  encodeInsightAsFeatures(insight) {
+    const features = [];
+    const typeMap = {
+      pattern_merge: 0.2,
+      novel_association: 0.4,
+      optimization: 0.6,
+      gap_detection: 0.8
+    };
+    features.push(typeMap[insight.type] || 0.5);
+    features.push(insight.confidenceScore);
+    features.push(insight.noveltyScore);
+    features.push(insight.actionable ? 1 : 0);
+    features.push(Math.min(1, insight.sourceConcepts.length / 10));
+    while (features.length < 384) {
+      features.push(0);
+    }
+    return features.slice(0, 384);
   }
   async handleTestRunCompleted(event) {
     if (!this.config.enableAutoGating) return;
@@ -30392,6 +31036,72 @@ var QualityAssessmentPlugin = class extends BaseDomainPlugin {
     return api;
   }
   // ============================================================================
+  // Task Handlers (Queen-Domain Integration)
+  // ============================================================================
+  /**
+   * Get task handlers for direct Queen-Domain integration
+   * Maps task types to coordinator methods
+   */
+  getTaskHandlers() {
+    return /* @__PURE__ */ new Map([
+      // Evaluate quality gate task - main task type for this domain
+      ["evaluate-gate", async (payload) => {
+        const gateName = payload.gateName;
+        const metrics = payload.metrics;
+        const thresholds = payload.thresholds;
+        if (!gateName || !metrics || !thresholds) {
+          return err(new Error("Invalid evaluate-gate payload: missing gateName, metrics, or thresholds"));
+        }
+        const request = {
+          gateName,
+          metrics,
+          thresholds
+        };
+        return this.evaluateGate(request);
+      }],
+      // Analyze quality task
+      ["analyze-quality", async (payload) => {
+        const sourceFiles = payload.sourceFiles;
+        if (!sourceFiles || sourceFiles.length === 0) {
+          return err(new Error("Invalid analyze-quality payload: missing sourceFiles"));
+        }
+        const request = {
+          sourceFiles,
+          includeMetrics: payload.includeMetrics ?? ["coverage", "complexity", "maintainability"],
+          compareBaseline: payload.compareBaseline
+        };
+        return this.analyzeQuality(request);
+      }],
+      // Get deployment advice task
+      ["deployment-advice", async (payload) => {
+        const releaseCandidate = payload.releaseCandidate;
+        const metrics = payload.metrics;
+        const riskTolerance = payload.riskTolerance;
+        if (!releaseCandidate || !metrics) {
+          return err(new Error("Invalid deployment-advice payload: missing releaseCandidate or metrics"));
+        }
+        const request = {
+          releaseCandidate,
+          metrics,
+          riskTolerance: riskTolerance ?? "medium"
+        };
+        return this.getDeploymentAdvice(request);
+      }],
+      // Analyze complexity task
+      ["analyze-complexity", async (payload) => {
+        const sourceFiles = payload.sourceFiles;
+        if (!sourceFiles || sourceFiles.length === 0) {
+          return err(new Error("Invalid analyze-complexity payload: missing sourceFiles"));
+        }
+        const request = {
+          sourceFiles,
+          metrics: payload.metrics ?? ["cyclomatic", "cognitive"]
+        };
+        return this.analyzeComplexity(request);
+      }]
+    ]);
+  }
+  // ============================================================================
   // Lifecycle Methods
   // ============================================================================
   async onInitialize() {
@@ -62074,7 +62784,7 @@ init_types();
 
 // src/domains/learning-optimization/coordinator.ts
 init_types();
-import { v4 as uuidv442 } from "uuid";
+import { v4 as uuidv445 } from "uuid";
 
 // src/domains/learning-optimization/services/learning-coordinator.ts
 init_types();
@@ -64403,316 +65113,2689 @@ var ProductionIntelService = class {
         "Multiple critical incidents detected. Consider system-wide review."
       );
     }
-    if (recommendations.length === 0) {
-      recommendations.push("All systems operating within normal parameters.");
-    }
-    return recommendations;
+    if (recommendations.length === 0) {
+      recommendations.push("All systems operating within normal parameters.");
+    }
+    return recommendations;
+  }
+  // ============================================================================
+  // Intelligence Extraction
+  // ============================================================================
+  /**
+   * Extract insights from production data
+   */
+  async extractInsights(timeRange, domain) {
+    try {
+      const metricsResult = await this.getMetricsHistory("*", timeRange, domain);
+      const metrics = metricsResult.success ? metricsResult.value : [];
+      const incidentsResult = await this.getRecentIncidents(50, domain);
+      const incidents = incidentsResult.success ? incidentsResult.value : [];
+      const experienceCount = metrics.length;
+      const resolvedIncidents = incidents.filter((i) => i.resolvedAt);
+      const successRate = incidents.length > 0 ? resolvedIncidents.length / incidents.length : 1;
+      const avgReward = this.calculateRewardFromIncidents(incidents);
+      const recommendations = this.generateInsightRecommendations(
+        metrics,
+        incidents
+      );
+      const anomalies = this.detectMetricAnomalies(metrics);
+      return ok({
+        experienceCount,
+        successRate,
+        avgReward,
+        patterns: [],
+        anomalies,
+        recommendations
+      });
+    } catch (error) {
+      return err(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+  /**
+   * Record production milestone
+   */
+  async recordMilestone(name, domain, metrics) {
+    try {
+      const milestone = {
+        name,
+        achievedAt: /* @__PURE__ */ new Date(),
+        domain
+      };
+      await this.memory.set(
+        `production:milestone:${uuidv441()}`,
+        { ...milestone, metrics },
+        { namespace: "learning-optimization", persist: true }
+      );
+      return ok(milestone);
+    } catch (error) {
+      return err(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+  /**
+   * Get recent milestones
+   */
+  async getRecentMilestones(limit = 10) {
+    try {
+      const keys = await this.memory.search("production:milestone:*", limit);
+      const milestones = [];
+      for (const key of keys) {
+        const milestone = await this.memory.get(key);
+        if (milestone) {
+          milestones.push(milestone);
+        }
+      }
+      milestones.sort((a, b) => b.achievedAt.getTime() - a.achievedAt.getTime());
+      return ok(milestones.slice(0, limit));
+    } catch (error) {
+      return err(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+  // ============================================================================
+  // Private Helper Methods
+  // ============================================================================
+  async indexMetric(metric) {
+    await this.memory.set(
+      `production:metric:index:${metric.name}:${metric.domain}:${metric.id}`,
+      metric.id,
+      {
+        namespace: "learning-optimization",
+        ttl: this.config.metricsRetentionDays * 86400
+      }
+    );
+  }
+  async indexIncident(incident) {
+    await this.memory.set(
+      `production:incident:index:domain:${incident.domain}:${incident.id}`,
+      incident.id,
+      { namespace: "learning-optimization", persist: true }
+    );
+    await this.memory.set(
+      `production:incident:index:severity:${incident.severity}:${incident.id}`,
+      incident.id,
+      { namespace: "learning-optimization", persist: true }
+    );
+  }
+  async checkForAnomalies(metric) {
+    const timeRange = TimeRange.lastNDays(7);
+    const historyResult = await this.getMetricsHistory(
+      metric.name,
+      timeRange,
+      metric.domain
+    );
+    if (!historyResult.success || historyResult.value.length < 10) {
+      return;
+    }
+    const values = historyResult.value.map((m) => m.value);
+    const mean = values.reduce((a, b) => a + b, 0) / values.length;
+    const stdDev = Math.sqrt(
+      values.reduce((sum, v) => sum + Math.pow(v - mean, 2), 0) / values.length
+    );
+    const deviation = Math.abs(metric.value - mean) / (stdDev || 1);
+    if (deviation > this.config.anomalyThreshold) {
+      await this.memory.set(
+        `production:anomaly:${uuidv441()}`,
+        {
+          metricId: metric.id,
+          metricName: metric.name,
+          value: metric.value,
+          mean,
+          stdDev,
+          deviation,
+          timestamp: /* @__PURE__ */ new Date()
+        },
+        { namespace: "learning-optimization", ttl: 86400 * 7 }
+      );
+    }
+  }
+  async createExperienceFromIncident(incident) {
+    const state2 = {
+      context: {
+        incidentId: incident.id,
+        severity: incident.severity,
+        domain: incident.domain
+      },
+      metrics: incident.metrics
+    };
+    const result = {
+      success: false,
+      outcome: incident.metrics,
+      duration: 0
+    };
+    const experience = {
+      id: uuidv441(),
+      agentId: {
+        value: "production-intel",
+        domain: "learning-optimization",
+        type: "analyzer"
+      },
+      domain: incident.domain,
+      action: `incident-${incident.severity}`,
+      state: state2,
+      result,
+      reward: this.calculateIncidentReward(incident),
+      timestamp: incident.startedAt
+    };
+    await this.memory.set(
+      `learning:experience:${experience.id}`,
+      experience,
+      { namespace: "learning-optimization", ttl: 86400 * 30 }
+    );
+  }
+  async updateExperienceWithResolution(incident) {
+    if (!incident.resolvedAt) return;
+    const state2 = {
+      context: {
+        incidentId: incident.id,
+        rootCause: incident.rootCause,
+        resolution: incident.resolution
+      },
+      metrics: incident.metrics
+    };
+    const duration = incident.resolvedAt.getTime() - incident.startedAt.getTime();
+    const result = {
+      success: true,
+      outcome: {
+        ...incident.metrics,
+        resolution_time_ms: duration
+      },
+      duration
+    };
+    const experience = {
+      id: uuidv441(),
+      agentId: {
+        value: "production-intel",
+        domain: "learning-optimization",
+        type: "analyzer"
+      },
+      domain: incident.domain,
+      action: `resolution-${incident.severity}`,
+      state: state2,
+      result,
+      reward: 1 - this.calculateIncidentReward(incident),
+      // Inverse - resolution is good
+      timestamp: incident.resolvedAt
+    };
+    await this.memory.set(
+      `learning:experience:${experience.id}`,
+      experience,
+      { namespace: "learning-optimization", ttl: 86400 * 30 }
+    );
+  }
+  calculateIncidentReward(incident) {
+    const severityScores = {
+      critical: 0.9,
+      high: 0.7,
+      medium: 0.4,
+      low: 0.2
+    };
+    return -(severityScores[incident.severity] || 0.5);
+  }
+  calculateRewardFromIncidents(incidents) {
+    if (incidents.length === 0) return 0.8;
+    const severityWeights = {
+      critical: 0.1,
+      high: 0.3,
+      medium: 0.6,
+      low: 0.8
+    };
+    let totalReward = 0;
+    let count = 0;
+    for (const incident of incidents) {
+      const base = severityWeights[incident.severity] || 0.5;
+      const resolved = incident.resolvedAt ? 0.2 : 0;
+      totalReward += base + resolved;
+      count++;
+    }
+    return count > 0 ? totalReward / count : 0.8;
+  }
+  generateInsightRecommendations(metrics, incidents) {
+    const recommendations = [];
+    const metricGroups = /* @__PURE__ */ new Map();
+    for (const metric of metrics) {
+      const existing = metricGroups.get(metric.name) || [];
+      existing.push(metric.value);
+      metricGroups.set(metric.name, existing);
+    }
+    for (const [name, values] of metricGroups) {
+      const trend = this.calculateTrendDirection(values);
+      if (trend === "increasing" && name.includes("error")) {
+        recommendations.push(`${name} is trending upward. Investigate root causes.`);
+      } else if (trend === "decreasing" && name.includes("success")) {
+        recommendations.push(`${name} is declining. Review recent changes.`);
+      }
+    }
+    if (incidents.length > 0) {
+      const domainIncidents = /* @__PURE__ */ new Map();
+      for (const incident of incidents) {
+        domainIncidents.set(
+          incident.domain,
+          (domainIncidents.get(incident.domain) || 0) + 1
+        );
+      }
+      for (const [domain, count] of domainIncidents) {
+        if (count > 3) {
+          recommendations.push(
+            `Domain ${domain} has ${count} incidents. Consider preventive measures.`
+          );
+        }
+      }
+    }
+    return recommendations;
+  }
+  detectMetricAnomalies(metrics) {
+    const anomalies = [];
+    const groups = /* @__PURE__ */ new Map();
+    for (const metric of metrics) {
+      const existing = groups.get(metric.name) || [];
+      existing.push(metric);
+      groups.set(metric.name, existing);
+    }
+    for (const [name, groupMetrics] of groups) {
+      if (groupMetrics.length < 5) continue;
+      const values = groupMetrics.map((m) => m.value);
+      const mean = values.reduce((a, b) => a + b, 0) / values.length;
+      const stdDev = Math.sqrt(
+        values.reduce((sum, v) => sum + Math.pow(v - mean, 2), 0) / values.length
+      );
+      for (const metric of groupMetrics) {
+        const deviation = Math.abs(metric.value - mean) / (stdDev || 1);
+        if (deviation > this.config.anomalyThreshold) {
+          anomalies.push({
+            experienceId: metric.id,
+            type: "outlier-reward",
+            description: `${name} value ${metric.value.toFixed(2)} is ${deviation.toFixed(1)} std deviations from mean`,
+            deviation
+          });
+        }
+      }
+    }
+    return anomalies;
+  }
+  calculateTrendDirection(values) {
+    if (values.length < 3) return "stable";
+    const firstHalf = values.slice(0, Math.floor(values.length / 2));
+    const secondHalf = values.slice(Math.floor(values.length / 2));
+    const firstAvg = firstHalf.reduce((a, b) => a + b, 0) / firstHalf.length;
+    const secondAvg = secondHalf.reduce((a, b) => a + b, 0) / secondHalf.length;
+    const change = (secondAvg - firstAvg) / (firstAvg || 1);
+    if (change > 0.1) return "increasing";
+    if (change < -0.1) return "decreasing";
+    return "stable";
+  }
+};
+
+// src/learning/dream/types.ts
+var DEFAULT_CONCEPT_GRAPH_CONFIG = {
+  // IGNORED: ConceptGraph uses getUnifiedPersistence() which uses memory.db (ADR-046)
+  dbPath: ".aqe/dream.db",
+  similarityThreshold: 0.5,
+  maxEdgesPerNode: 20,
+  walMode: true,
+  debug: false
+};
+
+// src/learning/dream/concept-graph.ts
+import { v4 as uuidv442 } from "uuid";
+var ConceptGraph = class {
+  config;
+  db = null;
+  persistence = null;
+  prepared = /* @__PURE__ */ new Map();
+  initialized = false;
+  constructor(config) {
+    this.config = { ...DEFAULT_CONCEPT_GRAPH_CONFIG, ...config };
+  }
+  // ==========================================================================
+  // Initialization
+  // ==========================================================================
+  /**
+   * Initialize using unified persistence
+   */
+  async initialize() {
+    if (this.initialized) return;
+    try {
+      this.persistence = getUnifiedPersistence();
+      if (!this.persistence.isInitialized()) {
+        await this.persistence.initialize();
+      }
+      this.db = this.persistence.getDatabase();
+      this.prepareStatements();
+      this.initialized = true;
+      if (this.config.debug) {
+        const stats = await this.getStats();
+        console.log(`[ConceptGraph] Initialized: ${this.persistence.getDbPath()}`, stats);
+      }
+    } catch (error) {
+      throw new Error(
+        `Failed to initialize ConceptGraph: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  /**
+   * Prepare commonly used SQL statements
+   */
+  prepareStatements() {
+    if (!this.db) throw new Error("Database not initialized");
+    this.prepared.set(
+      "insertNode",
+      this.db.prepare(`
+      INSERT INTO concept_nodes
+      (id, concept_type, content, embedding, activation_level, last_activated, pattern_id, metadata)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `)
+    );
+    this.prepared.set(
+      "getNode",
+      this.db.prepare(`
+      SELECT * FROM concept_nodes WHERE id = ?
+    `)
+    );
+    this.prepared.set(
+      "updateActivation",
+      this.db.prepare(`
+      UPDATE concept_nodes
+      SET activation_level = ?, last_activated = datetime('now')
+      WHERE id = ?
+    `)
+    );
+    this.prepared.set(
+      "getActiveNodes",
+      this.db.prepare(`
+      SELECT * FROM concept_nodes
+      WHERE activation_level >= ?
+      ORDER BY activation_level DESC
+    `)
+    );
+    this.prepared.set(
+      "getNodesByType",
+      this.db.prepare(`
+      SELECT * FROM concept_nodes WHERE concept_type = ?
+    `)
+    );
+    this.prepared.set(
+      "getAllNodes",
+      this.db.prepare(`
+      SELECT * FROM concept_nodes
+    `)
+    );
+    this.prepared.set(
+      "insertEdge",
+      this.db.prepare(`
+      INSERT INTO concept_edges
+      (id, source, target, edge_type, weight, evidence)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `)
+    );
+    this.prepared.set(
+      "getEdge",
+      this.db.prepare(`
+      SELECT * FROM concept_edges WHERE source = ? AND target = ?
+    `)
+    );
+    this.prepared.set(
+      "updateEdge",
+      this.db.prepare(`
+      UPDATE concept_edges
+      SET weight = ?, evidence = evidence + 1, updated_at = datetime('now')
+      WHERE source = ? AND target = ?
+    `)
+    );
+    this.prepared.set(
+      "getOutgoingEdges",
+      this.db.prepare(`
+      SELECT * FROM concept_edges WHERE source = ?
+    `)
+    );
+    this.prepared.set(
+      "getIncomingEdges",
+      this.db.prepare(`
+      SELECT * FROM concept_edges WHERE target = ?
+    `)
+    );
+    this.prepared.set(
+      "countNodes",
+      this.db.prepare(`
+      SELECT COUNT(*) as count FROM concept_nodes
+    `)
+    );
+    this.prepared.set(
+      "countEdges",
+      this.db.prepare(`
+      SELECT COUNT(*) as count FROM concept_edges
+    `)
+    );
+    this.prepared.set(
+      "countByType",
+      this.db.prepare(`
+      SELECT concept_type, COUNT(*) as count FROM concept_nodes GROUP BY concept_type
+    `)
+    );
+  }
+  // ==========================================================================
+  // Node Operations
+  // ==========================================================================
+  /**
+   * Add a new concept node to the graph
+   * @returns The ID of the created node
+   */
+  async addNode(node) {
+    this.ensureInitialized();
+    const id = uuidv442();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const stmt = this.prepared.get("insertNode");
+    if (!stmt) throw new Error("Prepared statement not found: insertNode");
+    const embeddingBlob = node.embedding ? Buffer.from(new Float32Array(node.embedding).buffer) : null;
+    stmt.run(
+      id,
+      node.conceptType,
+      node.content,
+      embeddingBlob,
+      0,
+      // Initial activation level
+      now,
+      node.patternId || null,
+      node.metadata ? JSON.stringify(node.metadata) : null
+    );
+    if (this.config.debug) {
+      console.log(`[ConceptGraph] Added node: ${id} (${node.conceptType})`);
+    }
+    return id;
+  }
+  /**
+   * Get a concept node by ID
+   */
+  async getNode(id) {
+    this.ensureInitialized();
+    const stmt = this.prepared.get("getNode");
+    if (!stmt) throw new Error("Prepared statement not found: getNode");
+    const row = stmt.get(id);
+    if (!row) return null;
+    return this.rowToNode(row);
+  }
+  /**
+   * Update the activation level of a node
+   */
+  async updateActivation(id, level) {
+    this.ensureInitialized();
+    const stmt = this.prepared.get("updateActivation");
+    if (!stmt) throw new Error("Prepared statement not found: updateActivation");
+    const clampedLevel = Math.max(0, Math.min(1, level));
+    stmt.run(clampedLevel, id);
+  }
+  /**
+   * Get all nodes with activation level at or above threshold
+   */
+  async getActiveNodes(minActivation = 0.1) {
+    this.ensureInitialized();
+    const stmt = this.prepared.get("getActiveNodes");
+    if (!stmt) throw new Error("Prepared statement not found: getActiveNodes");
+    const rows = stmt.all(minActivation);
+    return rows.map((row) => this.rowToNode(row));
+  }
+  /**
+   * Get all nodes of a specific type
+   */
+  async getNodesByType(type) {
+    this.ensureInitialized();
+    const stmt = this.prepared.get("getNodesByType");
+    if (!stmt) throw new Error("Prepared statement not found: getNodesByType");
+    const rows = stmt.all(type);
+    return rows.map((row) => this.rowToNode(row));
+  }
+  // ==========================================================================
+  // Edge Operations
+  // ==========================================================================
+  /**
+   * Add an edge between two nodes
+   * @returns The ID of the created edge
+   */
+  async addEdge(source, target, type, weight = 1) {
+    this.ensureInitialized();
+    const existing = await this.getEdgeBetween(source, target);
+    if (existing) {
+      await this.strengthenEdge(source, target, 0.1);
+      return existing.id;
+    }
+    const id = uuidv442();
+    const stmt = this.prepared.get("insertEdge");
+    if (!stmt) throw new Error("Prepared statement not found: insertEdge");
+    stmt.run(id, source, target, type, Math.max(0, Math.min(1, weight)), 1);
+    if (this.config.debug) {
+      console.log(`[ConceptGraph] Added edge: ${source} -> ${target} (${type})`);
+    }
+    return id;
+  }
+  /**
+   * Strengthen an existing edge between two nodes
+   */
+  async strengthenEdge(source, target, delta = 0.1) {
+    this.ensureInitialized();
+    const existing = await this.getEdgeBetween(source, target);
+    if (!existing) return;
+    const newWeight = Math.min(1, existing.weight + delta);
+    const stmt = this.prepared.get("updateEdge");
+    if (!stmt) throw new Error("Prepared statement not found: updateEdge");
+    stmt.run(newWeight, source, target);
+  }
+  /**
+   * Get neighbors of a node (both outgoing and incoming edges)
+   */
+  async getNeighbors(nodeId) {
+    this.ensureInitialized();
+    const results = [];
+    const outStmt = this.prepared.get("getOutgoingEdges");
+    if (!outStmt) throw new Error("Prepared statement not found: getOutgoingEdges");
+    const outEdges = outStmt.all(nodeId);
+    for (const edgeRow of outEdges) {
+      const node = await this.getNode(edgeRow.target);
+      if (node) {
+        results.push({
+          node,
+          edge: this.rowToEdge(edgeRow)
+        });
+      }
+    }
+    const inStmt = this.prepared.get("getIncomingEdges");
+    if (!inStmt) throw new Error("Prepared statement not found: getIncomingEdges");
+    const inEdges = inStmt.all(nodeId);
+    for (const edgeRow of inEdges) {
+      const node = await this.getNode(edgeRow.source);
+      if (node) {
+        results.push({
+          node,
+          edge: this.rowToEdge(edgeRow)
+        });
+      }
+    }
+    return results;
+  }
+  // ==========================================================================
+  // Graph Queries
+  // ==========================================================================
+  /**
+   * Find a path between two nodes using BFS
+   * @param maxHops Maximum number of hops (default: 5)
+   */
+  async findPath(from, to, maxHops = 5) {
+    this.ensureInitialized();
+    const visited = /* @__PURE__ */ new Set();
+    const queue = [{ nodeId: from, path: [from] }];
+    while (queue.length > 0) {
+      const current = queue.shift();
+      if (current.nodeId === to) {
+        const nodes = [];
+        for (const nodeId of current.path) {
+          const node = await this.getNode(nodeId);
+          if (node) nodes.push(node);
+        }
+        return nodes;
+      }
+      if (current.path.length > maxHops) continue;
+      if (visited.has(current.nodeId)) continue;
+      visited.add(current.nodeId);
+      const neighbors = await this.getNeighbors(current.nodeId);
+      for (const { node } of neighbors) {
+        if (!visited.has(node.id)) {
+          queue.push({
+            nodeId: node.id,
+            path: [...current.path, node.id]
+          });
+        }
+      }
+    }
+    return [];
+  }
+  /**
+   * Get a cluster of nodes around a central node
+   * @param depth How many hops to traverse (default: 2)
+   */
+  async getCluster(nodeId, depth = 2) {
+    this.ensureInitialized();
+    const visited = /* @__PURE__ */ new Set();
+    const result = [];
+    const traverse = async (id, currentDepth) => {
+      if (visited.has(id) || currentDepth > depth) return;
+      visited.add(id);
+      const node = await this.getNode(id);
+      if (node) {
+        result.push(node);
+        if (currentDepth < depth) {
+          const neighbors = await this.getNeighbors(id);
+          for (const { node: neighbor } of neighbors) {
+            await traverse(neighbor.id, currentDepth + 1);
+          }
+        }
+      }
+    };
+    await traverse(nodeId, 0);
+    return result;
+  }
+  // ==========================================================================
+  // Pattern Import
+  // ==========================================================================
+  /**
+   * Load patterns into the concept graph as nodes
+   * @returns Number of patterns loaded
+   */
+  async loadFromPatterns(patterns) {
+    this.ensureInitialized();
+    let loaded = 0;
+    for (const pattern of patterns) {
+      try {
+        await this.addNode({
+          conceptType: "pattern",
+          content: `${pattern.name}: ${pattern.description}`,
+          patternId: pattern.id,
+          metadata: {
+            domain: pattern.domain,
+            patternType: pattern.patternType,
+            confidence: pattern.confidence,
+            successRate: pattern.successRate
+          }
+        });
+        loaded++;
+        const domainNode = await this.findDomainNode(pattern.domain);
+        if (!domainNode) {
+          await this.addNode({
+            conceptType: "domain",
+            content: pattern.domain,
+            metadata: { patternCount: 1 }
+          });
+        }
+      } catch (error) {
+        if (this.config.debug) {
+          console.error(`[ConceptGraph] Failed to load pattern: ${pattern.id}`, error);
+        }
+      }
+    }
+    if (this.config.debug) {
+      console.log(`[ConceptGraph] Loaded ${loaded} patterns`);
+    }
+    return loaded;
+  }
+  // ==========================================================================
+  // Statistics
+  // ==========================================================================
+  /**
+   * Get graph statistics
+   */
+  async getStats() {
+    this.ensureInitialized();
+    const countNodesStmt = this.prepared.get("countNodes");
+    const countEdgesStmt = this.prepared.get("countEdges");
+    const countByTypeStmt = this.prepared.get("countByType");
+    if (!countNodesStmt || !countEdgesStmt || !countByTypeStmt) {
+      throw new Error("Prepared statements not found");
+    }
+    const nodeCount = countNodesStmt.get().count;
+    const edgeCount = countEdgesStmt.get().count;
+    const byType = {
+      pattern: 0,
+      technique: 0,
+      domain: 0,
+      outcome: 0,
+      error: 0
+    };
+    const typeRows = countByTypeStmt.all();
+    for (const row of typeRows) {
+      byType[row.concept_type] = row.count;
+    }
+    let avgActivation = 0;
+    if (nodeCount > 0) {
+      const avgStmt = this.db.prepare(
+        "SELECT AVG(activation_level) as avg FROM concept_nodes"
+      );
+      const result = avgStmt.get();
+      avgActivation = result.avg || 0;
+    }
+    return {
+      nodeCount,
+      edgeCount,
+      byType,
+      avgEdgesPerNode: nodeCount > 0 ? edgeCount / nodeCount : 0,
+      avgActivation
+    };
+  }
+  // ==========================================================================
+  // Cleanup
+  // ==========================================================================
+  /**
+   * Release resources (does NOT close the shared database)
+   */
+  async close() {
+    this.prepared.clear();
+    this.db = null;
+    this.persistence = null;
+    this.initialized = false;
+  }
+  // ==========================================================================
+  // Private Helpers
+  // ==========================================================================
+  ensureInitialized() {
+    if (!this.initialized || !this.db) {
+      throw new Error("ConceptGraph not initialized. Call initialize() first.");
+    }
+  }
+  async getEdgeBetween(source, target) {
+    const stmt = this.prepared.get("getEdge");
+    if (!stmt) throw new Error("Prepared statement not found: getEdge");
+    const row = stmt.get(source, target);
+    if (!row) return null;
+    return this.rowToEdge(row);
+  }
+  async findDomainNode(domain) {
+    if (!this.db) return null;
+    const stmt = this.db.prepare(
+      "SELECT * FROM concept_nodes WHERE concept_type = 'domain' AND content = ?"
+    );
+    const row = stmt.get(domain);
+    if (!row) return null;
+    return this.rowToNode(row);
+  }
+  rowToNode(row) {
+    let embedding;
+    if (row.embedding) {
+      const buffer = row.embedding;
+      const float32 = new Float32Array(
+        buffer.buffer,
+        buffer.byteOffset,
+        buffer.byteLength / 4
+      );
+      embedding = Array.from(float32);
+    }
+    return {
+      id: row.id,
+      conceptType: row.concept_type,
+      content: row.content,
+      embedding,
+      activationLevel: row.activation_level || 0,
+      lastActivated: row.last_activated ? new Date(row.last_activated) : void 0,
+      patternId: row.pattern_id || void 0,
+      metadata: row.metadata ? JSON.parse(row.metadata) : void 0,
+      createdAt: row.created_at ? new Date(row.created_at) : void 0
+    };
+  }
+  rowToEdge(row) {
+    return {
+      id: row.id,
+      source: row.source,
+      target: row.target,
+      weight: row.weight,
+      edgeType: row.edge_type,
+      evidence: row.evidence,
+      createdAt: row.created_at ? new Date(row.created_at) : void 0,
+      updatedAt: row.updated_at ? new Date(row.updated_at) : void 0
+    };
+  }
+};
+
+// src/learning/dream/spreading-activation.ts
+var DEFAULT_ACTIVATION_CONFIG = {
+  decayRate: 0.1,
+  spreadFactor: 0.5,
+  threshold: 0.1,
+  maxIterations: 20,
+  noiseLevel: 0.05
+};
+var SpreadingActivation = class {
+  graph;
+  config;
+  activationHistory = /* @__PURE__ */ new Map();
+  coActivationCounts = /* @__PURE__ */ new Map();
+  constructor(graph, config = {}) {
+    this.graph = graph;
+    this.config = { ...DEFAULT_ACTIVATION_CONFIG, ...config };
+  }
+  // ==========================================================================
+  // Core Spreading
+  // ==========================================================================
+  /**
+   * Spread activation from seed nodes through the concept graph.
+   *
+   * Algorithm:
+   * 1. Initialize seed nodes with activation
+   * 2. For each iteration:
+   *    a. For each active node, spread activation to neighbors (weighted by edge weight)
+   *    b. Apply decay to all nodes
+   *    c. Inject small random noise for exploration
+   * 3. Track co-activated nodes for novel association detection
+   * 4. Stop when stable or max iterations reached
+   *
+   * @param seedNodes - Array of node IDs to seed with initial activation
+   * @param seedActivation - Initial activation level for seed nodes. Default: 1.0
+   * @returns Activation result with statistics and discovered associations
+   */
+  async spread(seedNodes, seedActivation = 1) {
+    const validSeeds = seedNodes.filter((id) => this.graph.getConcept(id) !== void 0);
+    if (validSeeds.length === 0) {
+      return {
+        iterations: 0,
+        nodesActivated: 0,
+        peakActivation: 0,
+        activatedNodes: [],
+        novelAssociations: []
+      };
+    }
+    for (const nodeId of validSeeds) {
+      this.graph.setActivation(nodeId, seedActivation);
+      this.recordActivation(nodeId, seedActivation);
+    }
+    let iterations = 0;
+    let peakActivation = seedActivation;
+    let previousActiveCount = 0;
+    let stableIterations = 0;
+    while (iterations < this.config.maxIterations) {
+      const nodesUpdated = await this.spreadIteration();
+      const activeNodes = this.graph.getActiveNodes(this.config.threshold);
+      for (const node of activeNodes) {
+        if (node.activationLevel > peakActivation) {
+          peakActivation = node.activationLevel;
+        }
+      }
+      if (activeNodes.length === previousActiveCount && nodesUpdated === 0) {
+        stableIterations++;
+        if (stableIterations >= 3) {
+          break;
+        }
+      } else {
+        stableIterations = 0;
+      }
+      previousActiveCount = activeNodes.length;
+      iterations++;
+    }
+    const activatedNodes = this.graph.getActiveNodes(this.config.threshold).map((node) => ({
+      nodeId: node.id,
+      activation: node.activationLevel
+    })).sort((a, b) => b.activation - a.activation);
+    const novelAssociations = await this.findNovelAssociations(this.config.threshold);
+    return {
+      iterations,
+      nodesActivated: activatedNodes.length,
+      peakActivation,
+      activatedNodes,
+      novelAssociations: novelAssociations.map((a) => ({
+        source: a.source.id,
+        target: a.target.id,
+        strength: a.coActivation
+      }))
+    };
+  }
+  // ==========================================================================
+  // Dream Mode
+  // ==========================================================================
+  /**
+   * Dream mode: Random activation with increased noise.
+   * Simulates the "reduced logical filtering" of REM sleep.
+   *
+   * During dreaming:
+   * - Random nodes are periodically activated
+   * - Activation spreads with higher noise
+   * - Novel associations are discovered from unexpected co-activations
+   *
+   * @param durationMs - How long to dream in milliseconds
+   * @returns Activation result from the dream cycle
+   */
+  async dream(durationMs) {
+    const startTime = Date.now();
+    const allNovelAssociations = [];
+    let totalIterations = 0;
+    let maxPeakActivation = 0;
+    const activatedNodeSet = /* @__PURE__ */ new Set();
+    const allConcepts = this.graph.getAllConcepts(0);
+    if (allConcepts.length === 0) {
+      return {
+        iterations: 0,
+        nodesActivated: 0,
+        peakActivation: 0,
+        activatedNodes: [],
+        novelAssociations: []
+      };
+    }
+    while (Date.now() - startTime < durationMs) {
+      const randomIndex = Math.floor(Math.random() * allConcepts.length);
+      const randomNode = allConcepts[randomIndex];
+      if (randomNode) {
+        const noiseBoost = this.config.noiseLevel + Math.random() * this.config.noiseLevel * 2;
+        const currentActivation = randomNode.activationLevel;
+        const newActivation = Math.min(1, currentActivation + noiseBoost + 0.3);
+        this.graph.setActivation(randomNode.id, newActivation);
+        const result = await this.spread([randomNode.id], newActivation);
+        totalIterations += result.iterations;
+        if (result.peakActivation > maxPeakActivation) {
+          maxPeakActivation = result.peakActivation;
+        }
+        for (const activated of result.activatedNodes) {
+          activatedNodeSet.add(activated.nodeId);
+        }
+        for (const assoc of result.novelAssociations) {
+          allNovelAssociations.push(assoc);
+        }
+      }
+      await this.sleep(50 + Math.random() * 50);
+    }
+    const uniqueAssociations = this.deduplicateAssociations(allNovelAssociations);
+    const activatedNodes = Array.from(activatedNodeSet).map((id) => {
+      const node = this.graph.getConcept(id);
+      return {
+        nodeId: id,
+        activation: node?.activationLevel ?? 0
+      };
+    }).filter((n) => n.activation > 0).sort((a, b) => b.activation - a.activation);
+    return {
+      iterations: totalIterations,
+      nodesActivated: activatedNodes.length,
+      peakActivation: maxPeakActivation,
+      activatedNodes,
+      novelAssociations: uniqueAssociations.slice(0, 20)
+      // Top 20
+    };
+  }
+  // ==========================================================================
+  // Novel Association Detection
+  // ==========================================================================
+  /**
+   * Find novel associations from co-activated nodes.
+   *
+   * Novel associations are pairs of nodes that:
+   * 1. Are both highly activated (above minActivation)
+   * 2. Either have no existing edge, or have a weak edge
+   * 3. Haven't been frequently co-activated before
+   *
+   * @param minActivation - Minimum activation level to consider. Default: threshold
+   * @returns Array of novel associations with source, target, and co-activation strength
+   */
+  async findNovelAssociations(minActivation) {
+    const threshold = minActivation ?? this.config.threshold;
+    const activeNodes = this.graph.getActiveNodes(threshold);
+    if (activeNodes.length < 2) {
+      return [];
+    }
+    const associations = [];
+    for (let i = 0; i < activeNodes.length; i++) {
+      for (let j = i + 1; j < activeNodes.length; j++) {
+        const nodeA = activeNodes[i];
+        const nodeB = activeNodes[j];
+        const coActivation = Math.sqrt(
+          nodeA.activationLevel * nodeB.activationLevel
+        );
+        const existingEdge = this.graph.getEdge(nodeA.id, nodeB.id);
+        const reverseEdge = this.graph.getEdge(nodeB.id, nodeA.id);
+        const hasEdge = existingEdge !== void 0 || reverseEdge !== void 0;
+        const edgeWeight = existingEdge?.weight ?? reverseEdge?.weight ?? 0;
+        const isNovel = !hasEdge || edgeWeight < 0.3;
+        if (coActivation > 0.3) {
+          associations.push({
+            source: nodeA,
+            target: nodeB,
+            coActivation,
+            isNovel
+          });
+          this.trackCoActivation(nodeA.id, nodeB.id);
+        }
+      }
+    }
+    return associations.sort((a, b) => {
+      if (a.isNovel !== b.isNovel) {
+        return a.isNovel ? -1 : 1;
+      }
+      return b.coActivation - a.coActivation;
+    }).slice(0, 10);
+  }
+  // ==========================================================================
+  // State Management
+  // ==========================================================================
+  /**
+   * Reset all activations to zero and clear history
+   */
+  async reset() {
+    const allNodes = this.graph.getAllConcepts(0);
+    for (const node of allNodes) {
+      this.graph.setActivation(node.id, 0);
+    }
+    this.activationHistory.clear();
+    this.coActivationCounts.clear();
+  }
+  /**
+   * Get current configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  // ==========================================================================
+  // Private Methods
+  // ==========================================================================
+  /**
+   * Perform one iteration of activation spreading
+   * @returns Number of nodes that had their activation updated
+   */
+  async spreadIteration() {
+    const activeNodes = this.graph.getActiveNodes(this.config.threshold);
+    let nodesUpdated = 0;
+    const updates = [];
+    for (const activeNode of activeNodes) {
+      const edges = this.graph.getEdges(activeNode.id);
+      for (const edge of edges) {
+        const targetNode = this.graph.getConcept(edge.target);
+        if (!targetNode) continue;
+        const spreadAmount = activeNode.activationLevel * edge.weight * this.config.spreadFactor;
+        if (spreadAmount > 0.01) {
+          const currentActivation = targetNode.activationLevel;
+          const newActivation = Math.min(1, currentActivation + spreadAmount);
+          updates.push({ nodeId: edge.target, newActivation });
+        }
+      }
+    }
+    for (const update of updates) {
+      const currentNode = this.graph.getConcept(update.nodeId);
+      if (currentNode && update.newActivation > currentNode.activationLevel) {
+        this.graph.setActivation(update.nodeId, update.newActivation);
+        this.recordActivation(update.nodeId, update.newActivation);
+        nodesUpdated++;
+      }
+    }
+    this.applyDecay();
+    this.injectNoise();
+    return nodesUpdated;
+  }
+  /**
+   * Apply decay to all activation levels
+   */
+  applyDecay() {
+    const decayFactor = 1 - this.config.decayRate;
+    this.graph.decayActivations(decayFactor);
+  }
+  /**
+   * Inject small random noise to activations for exploration
+   */
+  injectNoise() {
+    if (this.config.noiseLevel <= 0) return;
+    const allNodes = this.graph.getAllConcepts(0);
+    for (const node of allNodes) {
+      if (node.activationLevel > 0) {
+        const noise = (Math.random() - 0.5) * 2 * this.config.noiseLevel;
+        const newActivation = Math.max(0, Math.min(1, node.activationLevel + noise));
+        this.graph.setActivation(node.id, newActivation);
+      }
+    }
+  }
+  /**
+   * Record activation level for history tracking
+   */
+  recordActivation(nodeId, level) {
+    const history = this.activationHistory.get(nodeId) || [];
+    history.push(level);
+    if (history.length > 50) {
+      history.shift();
+    }
+    this.activationHistory.set(nodeId, history);
+  }
+  /**
+   * Track co-activation between two nodes
+   */
+  trackCoActivation(nodeA, nodeB) {
+    const key = [nodeA, nodeB].sort().join(":");
+    const count = this.coActivationCounts.get(key) || 0;
+    this.coActivationCounts.set(key, count + 1);
+  }
+  /**
+   * Deduplicate associations by keeping the strongest
+   */
+  deduplicateAssociations(associations) {
+    const unique = /* @__PURE__ */ new Map();
+    for (const assoc of associations) {
+      const key = [assoc.source, assoc.target].sort().join(":");
+      const existing = unique.get(key);
+      if (!existing || assoc.strength > existing.strength) {
+        unique.set(key, assoc);
+      }
+    }
+    return Array.from(unique.values()).sort((a, b) => b.strength - a.strength);
+  }
+  /**
+   * Helper to sleep for a duration
+   */
+  sleep(ms) {
+    return new Promise((resolve8) => setTimeout(resolve8, ms));
+  }
+};
+
+// src/learning/dream/insight-generator.ts
+var DEFAULT_INSIGHT_CONFIG = {
+  minNoveltyScore: 0.3,
+  minConfidence: 0.5,
+  maxInsightsPerCycle: 10
+};
+var InsightGenerator = class {
+  graph;
+  config;
+  constructor(graph, config = {}) {
+    this.graph = graph;
+    this.config = { ...DEFAULT_INSIGHT_CONFIG, ...config };
+  }
+  // ==========================================================================
+  // Main Generation Method
+  // ==========================================================================
+  /**
+   * Generate insights from an activation result.
+   *
+   * Analyzes the activated nodes and novel associations to produce
+   * actionable insights about patterns, optimizations, and gaps.
+   *
+   * @param cycleId - ID of the dream cycle that produced the activation
+   * @param activationResult - Result from SpreadingActivation.spread() or .dream()
+   * @returns Array of generated insights
+   */
+  async generateFromActivation(cycleId, activationResult) {
+    const allInsights = [];
+    const activeNodes = activationResult.activatedNodes.map((n) => this.graph.getConcept(n.nodeId)).filter((n) => n !== void 0);
+    if (activeNodes.length < 2) {
+      return [];
+    }
+    const patternMerges = await this.detectPatternMerges(activeNodes);
+    for (const insight of patternMerges) {
+      insight.cycleId = cycleId;
+      allInsights.push(insight);
+    }
+    const novelAssociations = await this.detectNovelAssociations(
+      activationResult.novelAssociations
+    );
+    for (const insight of novelAssociations) {
+      insight.cycleId = cycleId;
+      allInsights.push(insight);
+    }
+    const optimizations = await this.detectOptimizations(activeNodes);
+    for (const insight of optimizations) {
+      insight.cycleId = cycleId;
+      allInsights.push(insight);
+    }
+    const gaps = await this.detectGaps(activeNodes);
+    for (const insight of gaps) {
+      insight.cycleId = cycleId;
+      allInsights.push(insight);
+    }
+    return allInsights.filter((i) => i.noveltyScore >= this.config.minNoveltyScore).sort((a, b) => b.noveltyScore - a.noveltyScore).slice(0, this.config.maxInsightsPerCycle);
+  }
+  // ==========================================================================
+  // Pattern Merge Detection
+  // ==========================================================================
+  /**
+   * Detect opportunities to merge similar patterns.
+   *
+   * Pattern merges are detected when:
+   * - Multiple pattern-type concepts are co-activated
+   * - They share similar content or metadata
+   * - They have high edge weights between them (similarity)
+   *
+   * @param activeNodes - Currently activated concept nodes
+   * @returns Array of pattern merge insights
+   */
+  async detectPatternMerges(activeNodes) {
+    const insights = [];
+    const patternNodes = activeNodes.filter(
+      (n) => n.conceptType === "pattern" || n.conceptType === "technique"
+    );
+    if (patternNodes.length < 2) {
+      return insights;
+    }
+    for (let i = 0; i < patternNodes.length; i++) {
+      for (let j = i + 1; j < patternNodes.length; j++) {
+        const nodeA = patternNodes[i];
+        const nodeB = patternNodes[j];
+        const edge = this.graph.getEdge(nodeA.id, nodeB.id);
+        const reverseEdge = this.graph.getEdge(nodeB.id, nodeA.id);
+        const edgeWeight = Math.max(edge?.weight ?? 0, reverseEdge?.weight ?? 0);
+        const contentSimilarity = this.calculateContentSimilarity(
+          nodeA.content,
+          nodeB.content
+        );
+        const coActivation = Math.sqrt(
+          nodeA.activationLevel * nodeB.activationLevel
+        );
+        const mergeScore = edgeWeight * 0.4 + contentSimilarity * 0.3 + coActivation * 0.3;
+        if (mergeScore > 0.5) {
+          const novelty = this.calculateNovelty({
+            type: "pattern_merge",
+            sourceConcepts: [nodeA.id, nodeB.id]
+          });
+          const confidence = this.calculateConfidence({
+            type: "pattern_merge",
+            sourceConcepts: [nodeA.id, nodeB.id],
+            edgeWeight,
+            contentSimilarity,
+            coActivation
+          });
+          insights.push({
+            id: this.generateId(),
+            cycleId: "",
+            // Set by caller
+            type: "pattern_merge",
+            sourceConcepts: [nodeA.id, nodeB.id],
+            description: this.generatePatternMergeDescription(nodeA, nodeB, mergeScore),
+            noveltyScore: novelty,
+            confidenceScore: confidence,
+            actionable: confidence >= this.config.minConfidence,
+            applied: false,
+            suggestedAction: confidence >= this.config.minConfidence ? `Merge "${this.truncate(nodeA.content, 30)}" with "${this.truncate(nodeB.content, 30)}" into a unified pattern.` : void 0,
+            createdAt: /* @__PURE__ */ new Date()
+          });
+        }
+      }
+    }
+    return insights;
+  }
+  // ==========================================================================
+  // Novel Association Detection
+  // ==========================================================================
+  /**
+   * Detect insights from novel associations.
+   *
+   * Novel associations are unexpected links between concepts that
+   * may represent new understanding or connection opportunities.
+   *
+   * @param associations - Novel associations from activation result
+   * @returns Array of novel association insights
+   */
+  async detectNovelAssociations(associations) {
+    const insights = [];
+    for (const assoc of associations) {
+      const sourceNode = this.graph.getConcept(assoc.source);
+      const targetNode = this.graph.getConcept(assoc.target);
+      if (!sourceNode || !targetNode) continue;
+      const edge = this.graph.getEdge(assoc.source, assoc.target);
+      if (edge && edge.weight > 0.5) continue;
+      const isCrossDomain = sourceNode.conceptType !== targetNode.conceptType;
+      const novelty = this.calculateNovelty({
+        type: "novel_association",
+        sourceConcepts: [assoc.source, assoc.target],
+        isCrossDomain,
+        strength: assoc.strength
+      });
+      const confidence = this.calculateConfidence({
+        type: "novel_association",
+        sourceConcepts: [assoc.source, assoc.target],
+        coActivation: assoc.strength,
+        isCrossDomain
+      });
+      insights.push({
+        id: this.generateId(),
+        cycleId: "",
+        // Set by caller
+        type: "novel_association",
+        sourceConcepts: [assoc.source, assoc.target],
+        description: this.generateNovelAssociationDescription(
+          sourceNode,
+          targetNode,
+          assoc.strength,
+          isCrossDomain
+        ),
+        noveltyScore: novelty,
+        confidenceScore: confidence,
+        actionable: confidence >= this.config.minConfidence,
+        applied: false,
+        suggestedAction: confidence >= this.config.minConfidence ? `Investigate connection between "${this.truncate(sourceNode.content, 25)}" and "${this.truncate(targetNode.content, 25)}".` : void 0,
+        createdAt: /* @__PURE__ */ new Date()
+      });
+    }
+    return insights;
+  }
+  // ==========================================================================
+  // Optimization Detection
+  // ==========================================================================
+  /**
+   * Detect optimization opportunities from active patterns.
+   *
+   * Optimizations are detected when:
+   * - A pattern has low success rate metadata
+   * - A technique has high execution count but mediocre outcomes
+   * - Multiple related patterns could be consolidated
+   *
+   * @param activeNodes - Currently activated concept nodes
+   * @returns Array of optimization insights
+   */
+  async detectOptimizations(activeNodes) {
+    const insights = [];
+    for (const node of activeNodes) {
+      if (node.conceptType !== "pattern" && node.conceptType !== "technique") {
+        continue;
+      }
+      const metadata = node.metadata ?? {};
+      const successRate = metadata.successRate;
+      const executionCount = metadata.executionCount;
+      const confidence = metadata.confidence;
+      const hasLowSuccess = successRate !== void 0 && successRate < 0.7;
+      const hasHighUsage = executionCount !== void 0 && executionCount > 10;
+      const hasLowConfidence = confidence !== void 0 && confidence < 0.6;
+      if (hasLowSuccess || hasHighUsage && hasLowConfidence) {
+        const novelty = this.calculateNovelty({
+          type: "optimization",
+          sourceConcepts: [node.id],
+          hasLowSuccess,
+          hasHighUsage
+        });
+        const insightConfidence = this.calculateConfidence({
+          type: "optimization",
+          sourceConcepts: [node.id],
+          hasLowSuccess,
+          hasHighUsage,
+          metadata
+        });
+        insights.push({
+          id: this.generateId(),
+          cycleId: "",
+          // Set by caller
+          type: "optimization",
+          sourceConcepts: [node.id],
+          description: this.generateOptimizationDescription(
+            node,
+            successRate,
+            executionCount
+          ),
+          noveltyScore: novelty,
+          confidenceScore: insightConfidence,
+          actionable: insightConfidence >= this.config.minConfidence,
+          applied: false,
+          suggestedAction: insightConfidence >= this.config.minConfidence ? `Review and optimize "${this.truncate(node.content, 40)}" to improve success rate.` : void 0,
+          createdAt: /* @__PURE__ */ new Date()
+        });
+      }
+    }
+    return insights;
+  }
+  // ==========================================================================
+  // Gap Detection
+  // ==========================================================================
+  /**
+   * Detect knowledge gaps from active patterns.
+   *
+   * Gaps are detected when:
+   * - Expected concepts are not activated (missing connections)
+   * - Outcome nodes lack corresponding technique nodes
+   * - Error patterns exist without resolution patterns
+   *
+   * @param activeNodes - Currently activated concept nodes
+   * @returns Array of gap detection insights
+   */
+  async detectGaps(activeNodes) {
+    const insights = [];
+    const byType = {
+      pattern: [],
+      technique: [],
+      domain: [],
+      outcome: [],
+      error: []
+    };
+    for (const node of activeNodes) {
+      const typeKey = node.conceptType ?? "pattern";
+      if (!byType[typeKey]) {
+        byType[typeKey] = [];
+      }
+      byType[typeKey].push(node);
+    }
+    for (const errorNode of byType.error ?? []) {
+      const edges = this.graph.getEdges(errorNode.id);
+      const hasResolution = edges.some((e) => {
+        const target = this.graph.getConcept(e.target);
+        return target && (target.conceptType === "pattern" || target.conceptType === "technique");
+      });
+      if (!hasResolution) {
+        const novelty = this.calculateNovelty({
+          type: "gap_detection",
+          sourceConcepts: [errorNode.id],
+          gapType: "missing_resolution"
+        });
+        const confidence = this.calculateConfidence({
+          type: "gap_detection",
+          sourceConcepts: [errorNode.id],
+          gapType: "missing_resolution"
+        });
+        insights.push({
+          id: this.generateId(),
+          cycleId: "",
+          // Set by caller
+          type: "gap_detection",
+          sourceConcepts: [errorNode.id],
+          description: `No resolution pattern found for error: "${this.truncate(errorNode.content, 50)}". Consider creating a fix pattern.`,
+          noveltyScore: novelty,
+          confidenceScore: confidence,
+          actionable: true,
+          applied: false,
+          suggestedAction: `Create a resolution pattern for: "${this.truncate(errorNode.content, 40)}".`,
+          createdAt: /* @__PURE__ */ new Date()
+        });
+      }
+    }
+    for (const outcomeNode of byType.outcome ?? []) {
+      const edges = this.graph.getEdges(outcomeNode.id);
+      const hasTechnique = edges.some((e) => {
+        const target = this.graph.getConcept(e.target);
+        return target && target.conceptType === "technique";
+      });
+      if (!hasTechnique && (byType.technique?.length ?? 0) === 0) {
+        const novelty = this.calculateNovelty({
+          type: "gap_detection",
+          sourceConcepts: [outcomeNode.id],
+          gapType: "missing_technique"
+        });
+        const confidence = this.calculateConfidence({
+          type: "gap_detection",
+          sourceConcepts: [outcomeNode.id],
+          gapType: "missing_technique"
+        });
+        insights.push({
+          id: this.generateId(),
+          cycleId: "",
+          // Set by caller
+          type: "gap_detection",
+          sourceConcepts: [outcomeNode.id],
+          description: `Outcome "${this.truncate(outcomeNode.content, 40)}" has no associated technique. Document how this outcome is achieved.`,
+          noveltyScore: novelty,
+          confidenceScore: confidence,
+          actionable: true,
+          applied: false,
+          suggestedAction: `Document the technique for achieving: "${this.truncate(outcomeNode.content, 35)}".`,
+          createdAt: /* @__PURE__ */ new Date()
+        });
+      }
+    }
+    return insights;
+  }
+  // ==========================================================================
+  // Scoring Methods
+  // ==========================================================================
+  /**
+   * Calculate novelty score for an insight.
+   *
+   * Novelty is higher when:
+   * - Concepts are from different types/domains
+   * - No existing strong edges between concepts
+   * - Co-activation pattern is unusual
+   */
+  calculateNovelty(context2) {
+    let novelty = 0.5;
+    if (context2.isCrossDomain) {
+      novelty += 0.2;
+    }
+    if (context2.strength !== void 0 && context2.strength > 0.5) {
+      novelty += 0.15;
+    }
+    if (context2.type === "gap_detection") {
+      novelty += 0.2;
+    }
+    if (context2.hasHighUsage && context2.hasLowSuccess) {
+      novelty += 0.15;
+    }
+    if (context2.sourceConcepts.length >= 2) {
+      const edge = this.graph.getEdge(
+        context2.sourceConcepts[0],
+        context2.sourceConcepts[1]
+      );
+      if (!edge) {
+        novelty += 0.1;
+      } else if (edge.weight < 0.3) {
+        novelty += 0.05;
+      }
+    }
+    return Math.min(1, Math.max(0, novelty));
+  }
+  /**
+   * Calculate confidence score for an insight.
+   *
+   * Confidence is higher when:
+   * - High co-activation strength
+   * - Strong evidence (edge weights, execution counts)
+   * - Consistent metadata supports the insight
+   */
+  calculateConfidence(context2) {
+    let confidence = 0.4;
+    if (context2.coActivation !== void 0) {
+      confidence += context2.coActivation * 0.3;
+    }
+    if (context2.edgeWeight !== void 0) {
+      confidence += context2.edgeWeight * 0.2;
+    }
+    if (context2.contentSimilarity !== void 0 && context2.type === "pattern_merge") {
+      confidence += context2.contentSimilarity * 0.2;
+    }
+    if (context2.isCrossDomain) {
+      confidence -= 0.1;
+    }
+    if (context2.hasHighUsage && context2.hasLowSuccess) {
+      confidence += 0.15;
+    }
+    if (context2.metadata) {
+      const metadataQuality = Math.min(Object.keys(context2.metadata).length * 0.05, 0.15);
+      confidence += metadataQuality;
+    }
+    if (context2.gapType) {
+      confidence += 0.1;
+    }
+    return Math.min(1, Math.max(0, confidence));
+  }
+  // ==========================================================================
+  // Pattern Conversion
+  // ==========================================================================
+  /**
+   * Convert an actionable insight into a pattern template.
+   *
+   * @param insight - The insight to convert
+   * @returns Pattern template or null if not convertible
+   */
+  async insightToPattern(insight) {
+    if (!insight.actionable) {
+      return null;
+    }
+    const concepts = insight.sourceConcepts.map((id) => this.graph.getConcept(id)).filter((c) => c !== void 0);
+    if (concepts.length === 0) {
+      return null;
+    }
+    switch (insight.type) {
+      case "pattern_merge": {
+        const [conceptA, conceptB] = concepts;
+        return {
+          name: `Merged: ${this.truncate(conceptA?.content ?? "", 20)} + ${this.truncate(conceptB?.content ?? "", 20)}`,
+          description: insight.description,
+          template: {
+            type: "merged_pattern",
+            sourcePatterns: insight.sourceConcepts,
+            mergedContent: concepts.map((c) => c.content).join(" | "),
+            metadata: {
+              noveltyScore: insight.noveltyScore,
+              confidenceScore: insight.confidenceScore,
+              createdFrom: "dream_insight"
+            }
+          }
+        };
+      }
+      case "novel_association": {
+        const [sourceNode, targetNode] = concepts;
+        return {
+          name: `Association: ${sourceNode?.conceptType} - ${targetNode?.conceptType}`,
+          description: insight.description,
+          template: {
+            type: "association_pattern",
+            source: {
+              id: sourceNode?.id,
+              type: sourceNode?.conceptType,
+              content: sourceNode?.content
+            },
+            target: {
+              id: targetNode?.id,
+              type: targetNode?.conceptType,
+              content: targetNode?.content
+            },
+            metadata: {
+              noveltyScore: insight.noveltyScore,
+              confidenceScore: insight.confidenceScore,
+              createdFrom: "dream_insight"
+            }
+          }
+        };
+      }
+      case "optimization": {
+        const [concept] = concepts;
+        return {
+          name: `Optimized: ${this.truncate(concept?.content ?? "", 30)}`,
+          description: insight.description,
+          template: {
+            type: "optimization_pattern",
+            originalPattern: concept?.id,
+            suggestedAction: insight.suggestedAction,
+            metadata: {
+              noveltyScore: insight.noveltyScore,
+              confidenceScore: insight.confidenceScore,
+              createdFrom: "dream_insight"
+            }
+          }
+        };
+      }
+      case "gap_detection": {
+        const [concept] = concepts;
+        return {
+          name: `Gap Fill: ${this.truncate(concept?.content ?? "", 30)}`,
+          description: insight.description,
+          template: {
+            type: "gap_fill_pattern",
+            relatedConcept: concept?.id,
+            gapType: concept?.conceptType === "error" ? "missing_resolution" : "missing_technique",
+            suggestedAction: insight.suggestedAction,
+            metadata: {
+              noveltyScore: insight.noveltyScore,
+              confidenceScore: insight.confidenceScore,
+              createdFrom: "dream_insight"
+            }
+          }
+        };
+      }
+      default:
+        return null;
+    }
+  }
+  // ==========================================================================
+  // Helper Methods
+  // ==========================================================================
+  /**
+   * Generate a unique ID for an insight
+   */
+  generateId() {
+    const timestamp = Date.now();
+    const random = Math.random().toString(36).substring(2, 10);
+    return `insight-${timestamp}-${random}`;
+  }
+  /**
+   * Calculate content similarity using Jaccard similarity
+   */
+  calculateContentSimilarity(contentA, contentB) {
+    const wordsA = contentA.toLowerCase().split(/\s+/);
+    const wordsB = contentB.toLowerCase().split(/\s+/);
+    const setA = new Set(wordsA);
+    const setB = new Set(wordsB);
+    const intersection = wordsA.filter((w) => setB.has(w));
+    const unionSize = setA.size + setB.size - intersection.length;
+    if (unionSize === 0) return 0;
+    return intersection.length / unionSize;
+  }
+  /**
+   * Truncate string to max length
+   */
+  truncate(str, maxLength) {
+    if (str.length <= maxLength) return str;
+    return str.substring(0, maxLength - 3) + "...";
+  }
+  /**
+   * Generate description for pattern merge insight
+   */
+  generatePatternMergeDescription(nodeA, nodeB, mergeScore) {
+    const scorePercent = Math.round(mergeScore * 100);
+    return `Pattern merge opportunity (${scorePercent}% match): "${this.truncate(nodeA.content, 40)}" and "${this.truncate(nodeB.content, 40)}" share similar structure and could be combined.`;
+  }
+  /**
+   * Generate description for novel association insight
+   */
+  generateNovelAssociationDescription(source, target, strength, isCrossDomain) {
+    const strengthPercent = Math.round(strength * 100);
+    const domainNote = isCrossDomain ? " (cross-domain)" : "";
+    return `Novel association discovered${domainNote}: [${source.conceptType}] "${this.truncate(source.content, 30)}" is connected to [${target.conceptType}] "${this.truncate(target.content, 30)}" with ${strengthPercent}% co-activation strength.`;
+  }
+  /**
+   * Generate description for optimization insight
+   */
+  generateOptimizationDescription(node, successRate, executionCount) {
+    const parts = [
+      `Optimization opportunity for "${this.truncate(node.content, 40)}":`
+    ];
+    if (successRate !== void 0) {
+      parts.push(`Success rate is ${Math.round(successRate * 100)}%.`);
+    }
+    if (executionCount !== void 0) {
+      parts.push(`Used ${executionCount} times.`);
+    }
+    parts.push("Consider reviewing and improving this pattern.");
+    return parts.join(" ");
+  }
+  /**
+   * Get configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+};
+
+// src/learning/dream/dream-engine.ts
+import { v4 as uuidv443 } from "uuid";
+var DEFAULT_DREAM_CONFIG = {
+  maxDurationMs: 3e4,
+  minConceptsRequired: 10,
+  activationConfig: {
+    decayRate: 0.1,
+    spreadFactor: 0.5,
+    threshold: 0.1,
+    maxIterations: 20,
+    noiseLevel: 0.05
+  },
+  insightConfig: {
+    minNoveltyScore: 0.3,
+    minConfidence: 0.5,
+    maxInsightsPerCycle: 10
+  }
+};
+var ConceptGraphAdapter = class {
+  constructor(graph) {
+    this.graph = graph;
+  }
+  nodeCache = /* @__PURE__ */ new Map();
+  edgeCache = /* @__PURE__ */ new Map();
+  activationLevels = /* @__PURE__ */ new Map();
+  /**
+   * Load all nodes and edges into memory for fast access
+   */
+  async loadIntoMemory() {
+    this.nodeCache.clear();
+    this.edgeCache.clear();
+    this.activationLevels.clear();
+    const nodes = await this.graph.getActiveNodes(0);
+    for (const node of nodes) {
+      this.nodeCache.set(node.id, node);
+      this.activationLevels.set(node.id, node.activationLevel);
+    }
+    for (const node of nodes) {
+      const neighbors = await this.graph.getNeighbors(node.id);
+      const edges = neighbors.map((n) => n.edge);
+      this.edgeCache.set(node.id, edges);
+    }
+  }
+  /**
+   * Persist activation levels back to the database
+   */
+  async persistActivations() {
+    const entries = Array.from(this.activationLevels.entries());
+    for (const [nodeId, level] of entries) {
+      await this.graph.updateActivation(nodeId, level);
+    }
+  }
+  // SpreadingConceptGraph interface implementation
+  getConcept(id) {
+    const node = this.nodeCache.get(id);
+    if (node) {
+      return {
+        ...node,
+        activationLevel: this.activationLevels.get(id) ?? node.activationLevel
+      };
+    }
+    return void 0;
+  }
+  getAllConcepts(minActivation) {
+    const threshold = minActivation ?? 0;
+    return Array.from(this.nodeCache.values()).map((node) => ({
+      ...node,
+      activationLevel: this.activationLevels.get(node.id) ?? node.activationLevel
+    })).filter((node) => node.activationLevel >= threshold);
+  }
+  getActiveNodes(threshold) {
+    return this.getAllConcepts(threshold);
+  }
+  getEdges(nodeId) {
+    return this.edgeCache.get(nodeId) ?? [];
+  }
+  getEdge(source, target) {
+    const edges = this.edgeCache.get(source) ?? [];
+    return edges.find((e) => e.target === target);
+  }
+  setActivation(nodeId, level) {
+    this.activationLevels.set(nodeId, Math.max(0, Math.min(1, level)));
+  }
+  decayActivations(factor) {
+    const entries = Array.from(this.activationLevels.entries());
+    for (const [nodeId, level] of entries) {
+      this.activationLevels.set(nodeId, level * factor);
+    }
+  }
+  getStats() {
+    const nodes = Array.from(this.nodeCache.values());
+    const byType = {
+      pattern: 0,
+      technique: 0,
+      domain: 0,
+      outcome: 0,
+      error: 0
+    };
+    let totalActivation = 0;
+    for (const node of nodes) {
+      byType[node.conceptType] = (byType[node.conceptType] ?? 0) + 1;
+      totalActivation += this.activationLevels.get(node.id) ?? node.activationLevel;
+    }
+    let totalEdges = 0;
+    const edgeValues = Array.from(this.edgeCache.values());
+    for (const edges of edgeValues) {
+      totalEdges += edges.length;
+    }
+    return {
+      nodeCount: nodes.length,
+      edgeCount: totalEdges,
+      byType,
+      avgEdgesPerNode: nodes.length > 0 ? totalEdges / nodes.length : 0,
+      avgActivation: nodes.length > 0 ? totalActivation / nodes.length : 0
+    };
+  }
+};
+var DreamEngine = class {
+  config;
+  persistence = null;
+  graph = null;
+  db = null;
+  currentCycle = null;
+  initialized = false;
+  cancelled = false;
+  constructor(config) {
+    this.config = { ...DEFAULT_DREAM_CONFIG, ...config };
+  }
+  // ==========================================================================
+  // Initialization
+  // ==========================================================================
+  /**
+   * Initialize using unified persistence
+   */
+  async initialize() {
+    if (this.initialized) return;
+    try {
+      this.persistence = getUnifiedPersistence();
+      if (!this.persistence.isInitialized()) {
+        await this.persistence.initialize();
+      }
+      this.db = this.persistence.getDatabase();
+      this.graph = new ConceptGraph();
+      await this.graph.initialize();
+      this.initialized = true;
+      console.log(`[DreamEngine] Initialized: ${this.persistence.getDbPath()}`);
+    } catch (error) {
+      throw new Error(
+        `Failed to initialize DreamEngine: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  // ==========================================================================
+  // Main Dream Cycle
+  // ==========================================================================
+  /**
+   * Run a complete dream cycle.
+   *
+   * The dream cycle:
+   * 1. Checks for sufficient concepts
+   * 2. Runs spreading activation (the "dreaming")
+   * 3. Finds novel associations
+   * 4. Generates insights from activation patterns
+   * 5. Persists the cycle and insights
+   *
+   * @param durationMs - Maximum duration in milliseconds (default: config.maxDurationMs)
+   * @returns Dream cycle result with insights and statistics
+   */
+  async dream(durationMs) {
+    this.ensureInitialized();
+    this.cancelled = false;
+    const maxDuration = durationMs ?? this.config.maxDurationMs;
+    const startTime = Date.now();
+    this.currentCycle = {
+      id: uuidv443(),
+      startTime: /* @__PURE__ */ new Date(),
+      conceptsProcessed: 0,
+      associationsFound: 0,
+      insightsGenerated: 0,
+      status: "running"
+    };
+    await this.saveCycle(this.currentCycle);
+    try {
+      const allNodes = await this.graph.getActiveNodes(0);
+      if (allNodes.length < this.config.minConceptsRequired) {
+        throw new Error(
+          `Insufficient concepts: ${allNodes.length} < ${this.config.minConceptsRequired}`
+        );
+      }
+      const adapter = new ConceptGraphAdapter(this.graph);
+      await adapter.loadIntoMemory();
+      const activation = new SpreadingActivation(adapter, this.config.activationConfig);
+      const activationResult = await activation.dream(maxDuration);
+      if (this.cancelled) {
+        this.currentCycle.status = "interrupted";
+        this.currentCycle.endTime = /* @__PURE__ */ new Date();
+        this.currentCycle.durationMs = Date.now() - startTime;
+        await this.updateCycle(this.currentCycle);
+        throw new Error("Dream cycle cancelled");
+      }
+      this.currentCycle.conceptsProcessed = activationResult.nodesActivated;
+      this.currentCycle.associationsFound = activationResult.novelAssociations.length;
+      await adapter.persistActivations();
+      const generator = new InsightGenerator(adapter, this.config.insightConfig);
+      const insights = await generator.generateFromActivation(
+        this.currentCycle.id,
+        activationResult
+      );
+      this.currentCycle.insightsGenerated = insights.length;
+      for (const insight of insights) {
+        await this.saveInsight(insight);
+      }
+      this.currentCycle.endTime = /* @__PURE__ */ new Date();
+      this.currentCycle.durationMs = Date.now() - startTime;
+      this.currentCycle.status = "completed";
+      await this.updateCycle(this.currentCycle);
+      const result = {
+        cycle: { ...this.currentCycle },
+        insights,
+        activationStats: {
+          totalIterations: activationResult.iterations,
+          peakActivation: activationResult.peakActivation,
+          nodesActivated: activationResult.nodesActivated
+        },
+        patternsCreated: 0
+        // Updated when insights are applied
+      };
+      this.currentCycle = null;
+      return result;
+    } catch (error) {
+      if (this.currentCycle) {
+        if (this.currentCycle.status === "running") {
+          this.currentCycle.status = "failed";
+        }
+        this.currentCycle.error = error instanceof Error ? error.message : String(error);
+        this.currentCycle.endTime = /* @__PURE__ */ new Date();
+        this.currentCycle.durationMs = Date.now() - startTime;
+        await this.updateCycle(this.currentCycle);
+      }
+      this.currentCycle = null;
+      throw error;
+    }
+  }
+  // ==========================================================================
+  // Pattern Loading
+  // ==========================================================================
+  /**
+   * Load patterns as concepts for dreaming.
+   *
+   * Converts patterns from the pattern store into concept nodes
+   * that can be activated during dream cycles.
+   *
+   * @param patterns - Array of pattern data to load
+   * @returns Number of patterns successfully loaded
+   */
+  async loadPatternsAsConcepts(patterns) {
+    this.ensureInitialized();
+    return this.graph.loadFromPatterns(patterns);
+  }
+  // ==========================================================================
+  // Insight Management
+  // ==========================================================================
+  /**
+   * Apply an insight by converting it to a pattern.
+   *
+   * @param insightId - ID of the insight to apply
+   * @returns Result with success status and pattern ID
+   */
+  async applyInsight(insightId) {
+    this.ensureInitialized();
+    try {
+      const insightRow = await this.getInsightRowById(insightId);
+      if (!insightRow) {
+        return { success: false, error: `Insight not found: ${insightId}` };
+      }
+      if (insightRow.actionable !== 1) {
+        return { success: false, error: "Insight is not actionable" };
+      }
+      if (insightRow.applied === 1) {
+        return {
+          success: true,
+          patternId: insightRow.pattern_id ?? void 0,
+          error: "Insight already applied"
+        };
+      }
+      const patternId = `dream-pattern-${uuidv443()}`;
+      const stmt = this.db.prepare(`
+        UPDATE dream_insights
+        SET applied = 1, pattern_id = ?
+        WHERE id = ?
+      `);
+      stmt.run(patternId, insightId);
+      return { success: true, patternId };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  /**
+   * Get pending insights that haven't been applied.
+   *
+   * @param limit - Maximum number of insights to return (default: 20)
+   * @returns Array of pending insights
+   */
+  async getPendingInsights(limit) {
+    this.ensureInitialized();
+    const maxResults = limit ?? 20;
+    const stmt = this.db.prepare(`
+      SELECT * FROM dream_insights
+      WHERE applied = 0 AND actionable = 1
+      ORDER BY novelty_score DESC, confidence_score DESC
+      LIMIT ?
+    `);
+    const rows = stmt.all(maxResults);
+    return rows.map((row) => this.rowToInsight(row));
+  }
+  /**
+   * Get dream cycle history.
+   *
+   * @param limit - Maximum number of cycles to return (default: 20)
+   * @returns Array of dream cycles
+   */
+  async getDreamHistory(limit) {
+    this.ensureInitialized();
+    const maxResults = limit ?? 20;
+    const stmt = this.db.prepare(`
+      SELECT * FROM dream_cycles
+      ORDER BY start_time DESC
+      LIMIT ?
+    `);
+    const rows = stmt.all(maxResults);
+    return rows.map((row) => this.rowToCycle(row));
+  }
+  // ==========================================================================
+  // Dream Control
+  // ==========================================================================
+  /**
+   * Cancel the running dream cycle.
+   */
+  async cancelDream() {
+    this.cancelled = true;
+  }
+  /**
+   * Check if a dream is currently running.
+   */
+  isDreaming() {
+    return this.currentCycle !== null && this.currentCycle.status === "running";
+  }
+  /**
+   * Get the current dream cycle status.
+   */
+  getCurrentCycle() {
+    return this.currentCycle ? { ...this.currentCycle } : null;
+  }
+  // ==========================================================================
+  // Persistence
+  // ==========================================================================
+  async saveCycle(cycle) {
+    if (!this.db) return;
+    const stmt = this.db.prepare(`
+      INSERT INTO dream_cycles
+      (id, start_time, end_time, duration_ms, concepts_processed, associations_found,
+       insights_generated, status, error)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    stmt.run(
+      cycle.id,
+      cycle.startTime.toISOString(),
+      cycle.endTime?.toISOString() ?? null,
+      cycle.durationMs ?? null,
+      cycle.conceptsProcessed,
+      cycle.associationsFound,
+      cycle.insightsGenerated,
+      cycle.status,
+      cycle.error ?? null
+    );
+  }
+  async updateCycle(cycle) {
+    if (!this.db) return;
+    const stmt = this.db.prepare(`
+      UPDATE dream_cycles
+      SET end_time = ?, duration_ms = ?, concepts_processed = ?, associations_found = ?,
+          insights_generated = ?, status = ?, error = ?
+      WHERE id = ?
+    `);
+    stmt.run(
+      cycle.endTime?.toISOString() ?? null,
+      cycle.durationMs ?? null,
+      cycle.conceptsProcessed,
+      cycle.associationsFound,
+      cycle.insightsGenerated,
+      cycle.status,
+      cycle.error ?? null,
+      cycle.id
+    );
+  }
+  async saveInsight(insight) {
+    if (!this.db) return;
+    const stmt = this.db.prepare(`
+      INSERT INTO dream_insights
+      (id, cycle_id, insight_type, source_concepts, description, novelty_score,
+       confidence_score, actionable, applied, suggested_action, pattern_id)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    stmt.run(
+      insight.id,
+      insight.cycleId,
+      insight.type,
+      JSON.stringify(insight.sourceConcepts),
+      insight.description,
+      insight.noveltyScore,
+      insight.confidenceScore,
+      insight.actionable ? 1 : 0,
+      0,
+      // Not applied yet
+      insight.suggestedAction ?? null,
+      null
+      // No pattern yet
+    );
+  }
+  async getInsightRowById(id) {
+    if (!this.db) return null;
+    const stmt = this.db.prepare("SELECT * FROM dream_insights WHERE id = ?");
+    const row = stmt.get(id);
+    return row ?? null;
+  }
+  // ==========================================================================
+  // Cleanup
+  // ==========================================================================
+  /**
+   * Release resources (does NOT close the shared database)
+   */
+  async close() {
+    if (this.graph) {
+      await this.graph.close();
+      this.graph = null;
+    }
+    this.db = null;
+    this.persistence = null;
+    this.initialized = false;
+    this.currentCycle = null;
+  }
+  // ==========================================================================
+  // Private Helpers
+  // ==========================================================================
+  ensureInitialized() {
+    if (!this.initialized || !this.graph || !this.db) {
+      throw new Error("DreamEngine not initialized. Call initialize() first.");
+    }
+  }
+  rowToCycle(row) {
+    return {
+      id: row.id,
+      startTime: new Date(row.start_time),
+      endTime: row.end_time ? new Date(row.end_time) : void 0,
+      durationMs: row.duration_ms ?? void 0,
+      conceptsProcessed: row.concepts_processed,
+      associationsFound: row.associations_found,
+      insightsGenerated: row.insights_generated,
+      status: row.status,
+      error: row.error ?? void 0
+    };
+  }
+  rowToInsight(row) {
+    return {
+      id: row.id,
+      cycleId: row.cycle_id,
+      type: row.insight_type,
+      sourceConcepts: JSON.parse(row.source_concepts),
+      description: row.description,
+      noveltyScore: row.novelty_score,
+      confidenceScore: row.confidence_score,
+      actionable: row.actionable === 1,
+      applied: row.applied === 1,
+      patternId: row.pattern_id ?? void 0,
+      suggestedAction: row.suggested_action ?? void 0,
+      createdAt: new Date(row.created_at)
+    };
+  }
+};
+function createDreamEngine(config) {
+  return new DreamEngine(config);
+}
+
+// src/learning/dream/dream-scheduler.ts
+import { v4 as uuidv444 } from "uuid";
+var DEFAULT_DREAM_SCHEDULER_CONFIG = {
+  // Time-based scheduling
+  autoScheduleIntervalMs: 36e5,
+  // 1 hour
+  minTimeBetweenDreamsMs: 3e5,
+  // 5 minutes
+  // Experience-based triggers
+  experienceThreshold: 20,
+  enableExperienceTrigger: true,
+  // Event-based triggers
+  enableQualityGateFailureTrigger: true,
+  enableDomainMilestoneTrigger: false,
+  // Dream configuration
+  defaultDreamDurationMs: 1e4,
+  // 10 seconds
+  quickDreamDurationMs: 5e3,
+  // 5 seconds
+  fullDreamDurationMs: 3e4,
+  // 30 seconds
+  // Insight handling
+  autoApplyHighConfidenceInsights: false,
+  insightConfidenceThreshold: 0.8
+};
+var DreamScheduler = class {
+  config;
+  dreamEngine;
+  eventBus;
+  memoryBackend;
+  // State
+  initialized = false;
+  running = false;
+  dreaming = false;
+  // Experience buffer
+  experienceBuffer = [];
+  // Timing
+  lastDreamTime = null;
+  scheduledDreamTimer = null;
+  totalDreamsCompleted = 0;
+  // Event subscriptions
+  subscriptions = [];
+  // Last result
+  lastDreamResult = null;
+  /**
+   * Create a new DreamScheduler instance.
+   *
+   * @param dependencies - Required dependencies (dreamEngine, eventBus, memoryBackend)
+   * @param config - Optional configuration overrides
+   * @throws {Error} If required dependencies are missing
+   */
+  constructor(dependencies, config) {
+    if (!dependencies.dreamEngine) {
+      throw new Error("DreamScheduler requires dreamEngine dependency");
+    }
+    if (!dependencies.eventBus) {
+      throw new Error("DreamScheduler requires eventBus dependency");
+    }
+    this.dreamEngine = dependencies.dreamEngine;
+    this.eventBus = dependencies.eventBus;
+    this.memoryBackend = dependencies.memoryBackend;
+    this.config = { ...DEFAULT_DREAM_SCHEDULER_CONFIG, ...config };
+  }
+  // ==========================================================================
+  // Lifecycle Methods
+  // ==========================================================================
+  /**
+   * Initialize the scheduler.
+   *
+   * Sets up event subscriptions and restores state from memory if available.
+   */
+  async initialize() {
+    if (this.initialized) return;
+    if (this.config.enableQualityGateFailureTrigger) {
+      const qualitySubscription = this.eventBus.subscribe(
+        "quality-assessment:gate:completed",
+        this.handleQualityGateEvent.bind(this)
+      );
+      this.subscriptions.push(qualitySubscription);
+    }
+    if (this.config.enableDomainMilestoneTrigger) {
+      const milestoneSubscription = this.eventBus.subscribe(
+        "coordination:milestone:reached",
+        this.handleDomainMilestoneEvent.bind(this)
+      );
+      this.subscriptions.push(milestoneSubscription);
+    }
+    await this.restoreState();
+    this.initialized = true;
+    console.log("[DreamScheduler] Initialized");
+  }
+  /**
+   * Start the scheduler.
+   *
+   * Begins automatic dream scheduling based on the configured interval.
+   */
+  start() {
+    this.ensureInitialized();
+    if (this.running) return;
+    this.running = true;
+    this.scheduleNextDream();
+    console.log("[DreamScheduler] Started");
+  }
+  /**
+   * Stop the scheduler.
+   *
+   * Stops automatic scheduling but does not dispose resources.
+   */
+  stop() {
+    if (!this.running) return;
+    this.running = false;
+    this.clearScheduledDream();
+    console.log("[DreamScheduler] Stopped");
+  }
+  /**
+   * Dispose of all resources.
+   *
+   * Stops scheduling, unsubscribes from events, and saves state.
+   */
+  async dispose() {
+    this.stop();
+    for (const subscription of this.subscriptions) {
+      subscription.unsubscribe();
+    }
+    this.subscriptions = [];
+    await this.saveState();
+    this.initialized = false;
+    console.log("[DreamScheduler] Disposed");
+  }
+  // ==========================================================================
+  // Manual Dream Triggers
+  // ==========================================================================
+  /**
+   * Manually trigger a dream cycle.
+   *
+   * @param duration - Optional duration override in ms
+   * @returns Result of the dream cycle
+   */
+  async triggerDream(duration) {
+    this.ensureInitialized();
+    if (!this.canDream()) {
+      const waitTime = this.getTimeUntilCanDream();
+      throw new Error(
+        `Cannot start dream: minimum interval not met. Wait ${Math.ceil(waitTime / 1e3)}s.`
+      );
+    }
+    return this.executeDream(duration ?? this.config.defaultDreamDurationMs);
   }
-  // ============================================================================
-  // Intelligence Extraction
-  // ============================================================================
   /**
-   * Extract insights from production data
+   * Trigger a quick dream (shorter duration).
+   *
+   * @returns Result of the dream cycle
    */
-  async extractInsights(timeRange, domain) {
-    try {
-      const metricsResult = await this.getMetricsHistory("*", timeRange, domain);
-      const metrics = metricsResult.success ? metricsResult.value : [];
-      const incidentsResult = await this.getRecentIncidents(50, domain);
-      const incidents = incidentsResult.success ? incidentsResult.value : [];
-      const experienceCount = metrics.length;
-      const resolvedIncidents = incidents.filter((i) => i.resolvedAt);
-      const successRate = incidents.length > 0 ? resolvedIncidents.length / incidents.length : 1;
-      const avgReward = this.calculateRewardFromIncidents(incidents);
-      const recommendations = this.generateInsightRecommendations(
-        metrics,
-        incidents
+  async triggerQuickDream() {
+    return this.triggerDream(this.config.quickDreamDurationMs);
+  }
+  /**
+   * Trigger a full dream (longer duration).
+   *
+   * @returns Result of the dream cycle
+   */
+  async triggerFullDream() {
+    return this.triggerDream(this.config.fullDreamDurationMs);
+  }
+  // ==========================================================================
+  // Experience Recording
+  // ==========================================================================
+  /**
+   * Record a task experience for future dream processing.
+   *
+   * If experience threshold is reached and enabled, triggers a dream.
+   *
+   * @param experience - The experience to record
+   */
+  recordExperience(experience) {
+    this.experienceBuffer.push(experience);
+    if (this.config.enableExperienceTrigger && this.experienceBuffer.length >= this.config.experienceThreshold && this.canDream() && !this.dreaming) {
+      console.log(
+        `[DreamScheduler] Experience threshold (${this.config.experienceThreshold}) reached, triggering dream`
       );
-      const anomalies = this.detectMetricAnomalies(metrics);
-      return ok({
-        experienceCount,
-        successRate,
-        avgReward,
-        patterns: [],
-        anomalies,
-        recommendations
+      this.executeDream(this.config.defaultDreamDurationMs).catch((err3) => {
+        console.error("[DreamScheduler] Experience-triggered dream failed:", err3);
       });
-    } catch (error) {
-      return err(error instanceof Error ? error : new Error(String(error)));
     }
   }
   /**
-   * Record production milestone
+   * Get the current experience buffer.
+   *
+   * @returns Copy of the experience buffer
    */
-  async recordMilestone(name, domain, metrics) {
+  getExperienceBuffer() {
+    return [...this.experienceBuffer];
+  }
+  /**
+   * Clear the experience buffer.
+   */
+  clearExperienceBuffer() {
+    this.experienceBuffer = [];
+  }
+  // ==========================================================================
+  // Status Methods
+  // ==========================================================================
+  /**
+   * Get the current scheduler status.
+   *
+   * @returns Current status object
+   */
+  getStatus() {
+    const timeUntilNext = this.scheduledDreamTimer ? this.getTimeUntilScheduledDream() : null;
+    return {
+      initialized: this.initialized,
+      running: this.running,
+      dreaming: this.dreaming,
+      experienceCount: this.experienceBuffer.length,
+      experienceThreshold: this.config.experienceThreshold,
+      timeUntilNextDream: timeUntilNext,
+      totalDreamsCompleted: this.totalDreamsCompleted,
+      lastDreamTime: this.lastDreamTime,
+      autoSchedulingEnabled: this.running
+    };
+  }
+  /**
+   * Get the result of the last completed dream.
+   *
+   * @returns Last dream result or null
+   */
+  getLastDreamResult() {
+    return this.lastDreamResult;
+  }
+  // ==========================================================================
+  // Private: Dream Execution
+  // ==========================================================================
+  /**
+   * Execute a dream cycle with the specified duration.
+   */
+  async executeDream(durationMs) {
+    if (this.dreaming) {
+      throw new Error("A dream is already in progress");
+    }
+    this.dreaming = true;
+    console.log(`[DreamScheduler] Starting dream cycle (${durationMs}ms)`);
     try {
-      const milestone = {
-        name,
-        achievedAt: /* @__PURE__ */ new Date(),
-        domain
-      };
-      await this.memory.set(
-        `production:milestone:${uuidv441()}`,
-        { ...milestone, metrics },
-        { namespace: "learning-optimization", persist: true }
+      const result = await this.dreamEngine.dream(durationMs);
+      this.lastDreamTime = /* @__PURE__ */ new Date();
+      this.lastDreamResult = result;
+      this.totalDreamsCompleted++;
+      this.clearExperienceBuffer();
+      if (this.config.autoApplyHighConfidenceInsights) {
+        await this.autoApplyInsights(result);
+      }
+      await this.publishDreamCompletedEvent(result);
+      if (this.running) {
+        this.scheduleNextDream();
+      }
+      console.log(
+        `[DreamScheduler] Dream completed: ${result.insights.length} insights generated`
       );
-      return ok(milestone);
-    } catch (error) {
-      return err(error instanceof Error ? error : new Error(String(error)));
+      return result;
+    } finally {
+      this.dreaming = false;
     }
   }
   /**
-   * Get recent milestones
+   * Auto-apply insights that meet the confidence threshold.
    */
-  async getRecentMilestones(limit = 10) {
-    try {
-      const keys = await this.memory.search("production:milestone:*", limit);
-      const milestones = [];
-      for (const key of keys) {
-        const milestone = await this.memory.get(key);
-        if (milestone) {
-          milestones.push(milestone);
+  async autoApplyInsights(result) {
+    const highConfidenceInsights = result.insights.filter(
+      (insight) => insight.actionable && insight.confidenceScore >= this.config.insightConfidenceThreshold
+    );
+    for (const insight of highConfidenceInsights) {
+      try {
+        const applyResult = await this.dreamEngine.applyInsight(insight.id);
+        if (applyResult.success) {
+          console.log(
+            `[DreamScheduler] Auto-applied insight ${insight.id}: ${applyResult.patternId}`
+          );
         }
+      } catch (err3) {
+        console.error(`[DreamScheduler] Failed to auto-apply insight ${insight.id}:`, err3);
       }
-      milestones.sort((a, b) => b.achievedAt.getTime() - a.achievedAt.getTime());
-      return ok(milestones.slice(0, limit));
-    } catch (error) {
-      return err(error instanceof Error ? error : new Error(String(error)));
     }
   }
-  // ============================================================================
-  // Private Helper Methods
-  // ============================================================================
-  async indexMetric(metric) {
-    await this.memory.set(
-      `production:metric:index:${metric.name}:${metric.domain}:${metric.id}`,
-      metric.id,
-      {
-        namespace: "learning-optimization",
-        ttl: this.config.metricsRetentionDays * 86400
+  // ==========================================================================
+  // Private: Scheduling
+  // ==========================================================================
+  /**
+   * Schedule the next automatic dream.
+   */
+  scheduleNextDream() {
+    this.clearScheduledDream();
+    if (!this.running) return;
+    const nextDreamDelay = this.calculateNextDreamDelay();
+    this.scheduledDreamTimer = setTimeout(async () => {
+      if (!this.running || this.dreaming) return;
+      try {
+        await this.executeDream(this.config.defaultDreamDurationMs);
+      } catch (err3) {
+        console.error("[DreamScheduler] Scheduled dream failed:", err3);
+        if (this.running) {
+          this.scheduleNextDream();
+        }
       }
+    }, nextDreamDelay);
+    console.log(
+      `[DreamScheduler] Next dream scheduled in ${Math.ceil(nextDreamDelay / 1e3)}s`
     );
   }
-  async indexIncident(incident) {
-    await this.memory.set(
-      `production:incident:index:domain:${incident.domain}:${incident.id}`,
-      incident.id,
-      { namespace: "learning-optimization", persist: true }
-    );
-    await this.memory.set(
-      `production:incident:index:severity:${incident.severity}:${incident.id}`,
-      incident.id,
-      { namespace: "learning-optimization", persist: true }
-    );
-  }
-  async checkForAnomalies(metric) {
-    const timeRange = TimeRange.lastNDays(7);
-    const historyResult = await this.getMetricsHistory(
-      metric.name,
-      timeRange,
-      metric.domain
-    );
-    if (!historyResult.success || historyResult.value.length < 10) {
-      return;
+  /**
+   * Clear any scheduled dream timer.
+   */
+  clearScheduledDream() {
+    if (this.scheduledDreamTimer) {
+      clearTimeout(this.scheduledDreamTimer);
+      this.scheduledDreamTimer = null;
     }
-    const values = historyResult.value.map((m) => m.value);
-    const mean = values.reduce((a, b) => a + b, 0) / values.length;
-    const stdDev = Math.sqrt(
-      values.reduce((sum, v) => sum + Math.pow(v - mean, 2), 0) / values.length
-    );
-    const deviation = Math.abs(metric.value - mean) / (stdDev || 1);
-    if (deviation > this.config.anomalyThreshold) {
-      await this.memory.set(
-        `production:anomaly:${uuidv441()}`,
-        {
-          metricId: metric.id,
-          metricName: metric.name,
-          value: metric.value,
-          mean,
-          stdDev,
-          deviation,
-          timestamp: /* @__PURE__ */ new Date()
-        },
-        { namespace: "learning-optimization", ttl: 86400 * 7 }
-      );
+  }
+  /**
+   * Calculate delay until next scheduled dream.
+   */
+  calculateNextDreamDelay() {
+    if (!this.lastDreamTime) {
+      return this.config.autoScheduleIntervalMs;
     }
+    const timeSinceLastDream = Date.now() - this.lastDreamTime.getTime();
+    const remainingTime = this.config.autoScheduleIntervalMs - timeSinceLastDream;
+    return Math.max(remainingTime, this.config.minTimeBetweenDreamsMs);
   }
-  async createExperienceFromIncident(incident) {
-    const state2 = {
-      context: {
-        incidentId: incident.id,
-        severity: incident.severity,
-        domain: incident.domain
-      },
-      metrics: incident.metrics
-    };
-    const result = {
-      success: false,
-      outcome: incident.metrics,
-      duration: 0
-    };
-    const experience = {
-      id: uuidv441(),
-      agentId: {
-        value: "production-intel",
-        domain: "learning-optimization",
-        type: "analyzer"
-      },
-      domain: incident.domain,
-      action: `incident-${incident.severity}`,
-      state: state2,
-      result,
-      reward: this.calculateIncidentReward(incident),
-      timestamp: incident.startedAt
-    };
-    await this.memory.set(
-      `learning:experience:${experience.id}`,
-      experience,
-      { namespace: "learning-optimization", ttl: 86400 * 30 }
-    );
+  /**
+   * Get time until the currently scheduled dream.
+   */
+  getTimeUntilScheduledDream() {
+    return this.calculateNextDreamDelay();
   }
-  async updateExperienceWithResolution(incident) {
-    if (!incident.resolvedAt) return;
-    const state2 = {
-      context: {
-        incidentId: incident.id,
-        rootCause: incident.rootCause,
-        resolution: incident.resolution
-      },
-      metrics: incident.metrics
-    };
-    const duration = incident.resolvedAt.getTime() - incident.startedAt.getTime();
-    const result = {
-      success: true,
-      outcome: {
-        ...incident.metrics,
-        resolution_time_ms: duration
-      },
-      duration
-    };
-    const experience = {
-      id: uuidv441(),
-      agentId: {
-        value: "production-intel",
-        domain: "learning-optimization",
-        type: "analyzer"
-      },
-      domain: incident.domain,
-      action: `resolution-${incident.severity}`,
-      state: state2,
-      result,
-      reward: 1 - this.calculateIncidentReward(incident),
-      // Inverse - resolution is good
-      timestamp: incident.resolvedAt
-    };
-    await this.memory.set(
-      `learning:experience:${experience.id}`,
-      experience,
-      { namespace: "learning-optimization", ttl: 86400 * 30 }
-    );
+  // ==========================================================================
+  // Private: Dream Timing Checks
+  // ==========================================================================
+  /**
+   * Check if enough time has passed since the last dream.
+   */
+  canDream() {
+    if (!this.lastDreamTime) return true;
+    const timeSinceLastDream = Date.now() - this.lastDreamTime.getTime();
+    return timeSinceLastDream >= this.config.minTimeBetweenDreamsMs;
   }
-  calculateIncidentReward(incident) {
-    const severityScores = {
-      critical: 0.9,
-      high: 0.7,
-      medium: 0.4,
-      low: 0.2
-    };
-    return -(severityScores[incident.severity] || 0.5);
+  /**
+   * Get time until we can start a dream.
+   */
+  getTimeUntilCanDream() {
+    if (!this.lastDreamTime) return 0;
+    const timeSinceLastDream = Date.now() - this.lastDreamTime.getTime();
+    return Math.max(0, this.config.minTimeBetweenDreamsMs - timeSinceLastDream);
   }
-  calculateRewardFromIncidents(incidents) {
-    if (incidents.length === 0) return 0.8;
-    const severityWeights = {
-      critical: 0.1,
-      high: 0.3,
-      medium: 0.6,
-      low: 0.8
-    };
-    let totalReward = 0;
-    let count = 0;
-    for (const incident of incidents) {
-      const base = severityWeights[incident.severity] || 0.5;
-      const resolved = incident.resolvedAt ? 0.2 : 0;
-      totalReward += base + resolved;
-      count++;
+  // ==========================================================================
+  // Private: Event Handlers
+  // ==========================================================================
+  /**
+   * Handle quality gate completion events.
+   * Triggers a dream when a gate fails to analyze what went wrong.
+   */
+  async handleQualityGateEvent(event) {
+    if (event.payload.passed) return;
+    if (!this.canDream() || this.dreaming) {
+      console.log(
+        "[DreamScheduler] Quality gate failed but cannot start dream yet"
+      );
+      return;
+    }
+    console.log("[DreamScheduler] Quality gate failed, triggering analysis dream");
+    try {
+      await this.executeDream(this.config.quickDreamDurationMs);
+    } catch (err3) {
+      console.error("[DreamScheduler] Quality gate triggered dream failed:", err3);
     }
-    return count > 0 ? totalReward / count : 0.8;
   }
-  generateInsightRecommendations(metrics, incidents) {
-    const recommendations = [];
-    const metricGroups = /* @__PURE__ */ new Map();
-    for (const metric of metrics) {
-      const existing = metricGroups.get(metric.name) || [];
-      existing.push(metric.value);
-      metricGroups.set(metric.name, existing);
+  /**
+   * Handle domain milestone events.
+   * Triggers a dream to consolidate learnings after significant progress.
+   */
+  async handleDomainMilestoneEvent(event) {
+    if (!this.canDream() || this.dreaming) {
+      console.log("[DreamScheduler] Milestone reached but cannot start dream yet");
+      return;
     }
-    for (const [name, values] of metricGroups) {
-      const trend = this.calculateTrendDirection(values);
-      if (trend === "increasing" && name.includes("error")) {
-        recommendations.push(`${name} is trending upward. Investigate root causes.`);
-      } else if (trend === "decreasing" && name.includes("success")) {
-        recommendations.push(`${name} is declining. Review recent changes.`);
-      }
+    console.log("[DreamScheduler] Domain milestone reached, triggering consolidation dream");
+    try {
+      await this.executeDream(this.config.defaultDreamDurationMs);
+    } catch (err3) {
+      console.error("[DreamScheduler] Milestone triggered dream failed:", err3);
     }
-    if (incidents.length > 0) {
-      const domainIncidents = /* @__PURE__ */ new Map();
-      for (const incident of incidents) {
-        domainIncidents.set(
-          incident.domain,
-          (domainIncidents.get(incident.domain) || 0) + 1
-        );
-      }
-      for (const [domain, count] of domainIncidents) {
-        if (count > 3) {
-          recommendations.push(
-            `Domain ${domain} has ${count} incidents. Consider preventive measures.`
-          );
+  }
+  // ==========================================================================
+  // Private: Event Publishing
+  // ==========================================================================
+  /**
+   * Publish a dream completed event.
+   */
+  async publishDreamCompletedEvent(result) {
+    try {
+      await this.eventBus.publish({
+        id: uuidv444(),
+        type: "learning-optimization:dream:completed",
+        timestamp: /* @__PURE__ */ new Date(),
+        source: "learning-optimization",
+        payload: {
+          cycleId: result.cycle.id,
+          insightsGenerated: result.insights.length,
+          patternsCreated: result.patternsCreated,
+          duration: result.cycle.durationMs
         }
-      }
+      });
+    } catch (err3) {
+      console.error("[DreamScheduler] Failed to publish dream completed event:", err3);
     }
-    return recommendations;
   }
-  detectMetricAnomalies(metrics) {
-    const anomalies = [];
-    const groups = /* @__PURE__ */ new Map();
-    for (const metric of metrics) {
-      const existing = groups.get(metric.name) || [];
-      existing.push(metric);
-      groups.set(metric.name, existing);
-    }
-    for (const [name, groupMetrics] of groups) {
-      if (groupMetrics.length < 5) continue;
-      const values = groupMetrics.map((m) => m.value);
-      const mean = values.reduce((a, b) => a + b, 0) / values.length;
-      const stdDev = Math.sqrt(
-        values.reduce((sum, v) => sum + Math.pow(v - mean, 2), 0) / values.length
+  // ==========================================================================
+  // Private: State Persistence
+  // ==========================================================================
+  /**
+   * Save scheduler state to memory backend.
+   */
+  async saveState() {
+    if (!this.memoryBackend) return;
+    try {
+      await this.memoryBackend.set(
+        "dream-scheduler:state",
+        {
+          lastDreamTime: this.lastDreamTime?.toISOString() ?? null,
+          totalDreamsCompleted: this.totalDreamsCompleted,
+          experienceBuffer: this.experienceBuffer
+        },
+        { namespace: "learning-optimization", persist: true }
       );
-      for (const metric of groupMetrics) {
-        const deviation = Math.abs(metric.value - mean) / (stdDev || 1);
-        if (deviation > this.config.anomalyThreshold) {
-          anomalies.push({
-            experienceId: metric.id,
-            type: "outlier-reward",
-            description: `${name} value ${metric.value.toFixed(2)} is ${deviation.toFixed(1)} std deviations from mean`,
-            deviation
-          });
-        }
+    } catch (err3) {
+      console.error("[DreamScheduler] Failed to save state:", err3);
+    }
+  }
+  /**
+   * Restore scheduler state from memory backend.
+   */
+  async restoreState() {
+    if (!this.memoryBackend) return;
+    try {
+      const state2 = await this.memoryBackend.get("dream-scheduler:state");
+      if (state2) {
+        this.lastDreamTime = state2.lastDreamTime ? new Date(state2.lastDreamTime) : null;
+        this.totalDreamsCompleted = state2.totalDreamsCompleted ?? 0;
+        this.experienceBuffer = state2.experienceBuffer ?? [];
+        console.log(
+          `[DreamScheduler] Restored state: ${this.totalDreamsCompleted} dreams, ${this.experienceBuffer.length} experiences`
+        );
       }
+    } catch (err3) {
+      console.error("[DreamScheduler] Failed to restore state:", err3);
     }
-    return anomalies;
   }
-  calculateTrendDirection(values) {
-    if (values.length < 3) return "stable";
-    const firstHalf = values.slice(0, Math.floor(values.length / 2));
-    const secondHalf = values.slice(Math.floor(values.length / 2));
-    const firstAvg = firstHalf.reduce((a, b) => a + b, 0) / firstHalf.length;
-    const secondAvg = secondHalf.reduce((a, b) => a + b, 0) / secondHalf.length;
-    const change = (secondAvg - firstAvg) / (firstAvg || 1);
-    if (change > 0.1) return "increasing";
-    if (change < -0.1) return "decreasing";
-    return "stable";
+  // ==========================================================================
+  // Private: Validation
+  // ==========================================================================
+  /**
+   * Ensure the scheduler is initialized.
+   */
+  ensureInitialized() {
+    if (!this.initialized) {
+      throw new Error("DreamScheduler not initialized. Call initialize() first.");
+    }
   }
 };
+function createDreamScheduler(dependencies, config) {
+  return new DreamScheduler(dependencies, config);
+}
 
 // src/domains/learning-optimization/coordinator.ts
 var DEFAULT_CONFIG48 = {
@@ -64721,8 +67804,17 @@ var DEFAULT_CONFIG48 = {
   // 2 minutes
   enableAutoOptimization: true,
   publishEvents: true,
-  learningCycleIntervalMs: 36e5
+  learningCycleIntervalMs: 36e5,
+  // 1 hour
+  // Dream Scheduler defaults
+  enableDreamScheduler: true,
+  dreamCycleIntervalMs: 36e5,
   // 1 hour
+  enableExperienceTrigger: true,
+  experienceThreshold: 50,
+  enableQualityGateFailureTrigger: true,
+  autoApplyHighConfidenceInsights: false,
+  autoApplyConfidenceThreshold: 0.8
 };
 var LearningOptimizationCoordinator = class {
   constructor(eventBus, memory, agentCoordinator, config = {}) {
@@ -64748,6 +67840,11 @@ var LearningOptimizationCoordinator = class {
    * Now uses PersistentSONAEngine to survive restarts
    */
   sona;
+  /**
+   * DreamScheduler for offline pattern consolidation and insight generation
+   * Wraps DreamEngine with automatic scheduling and trigger support
+   */
+  dreamScheduler = null;
   /**
    * Initialize the coordinator.
    * Throws if QESONA fails to initialize.
@@ -64767,6 +67864,32 @@ var LearningOptimizationCoordinator = class {
       console.error("[LearningOptimizationCoordinator] Failed to initialize PersistentSONAEngine:", error);
       throw error;
     }
+    if (this.config.enableDreamScheduler) {
+      try {
+        const dreamEngine = await createDreamEngine();
+        await dreamEngine.initialize();
+        this.dreamScheduler = createDreamScheduler(
+          {
+            dreamEngine,
+            eventBus: this.eventBus,
+            memoryBackend: this.memory
+          },
+          {
+            autoScheduleIntervalMs: this.config.dreamCycleIntervalMs,
+            enableExperienceTrigger: this.config.enableExperienceTrigger,
+            experienceThreshold: this.config.experienceThreshold,
+            enableQualityGateFailureTrigger: this.config.enableQualityGateFailureTrigger,
+            autoApplyHighConfidenceInsights: this.config.autoApplyHighConfidenceInsights,
+            insightConfidenceThreshold: this.config.autoApplyConfidenceThreshold
+          }
+        );
+        await this.dreamScheduler.initialize();
+        this.dreamScheduler.start();
+        console.log("[LearningOptimizationCoordinator] DreamScheduler initialized and started");
+      } catch (error) {
+        console.warn("[LearningOptimizationCoordinator] Failed to initialize DreamScheduler:", error);
+      }
+    }
     this.subscribeToEvents();
     await this.loadWorkflowState();
     this.initialized = true;
@@ -64777,6 +67900,15 @@ var LearningOptimizationCoordinator = class {
   async dispose() {
     await this.saveWorkflowState();
     this.workflows.clear();
+    if (this.dreamScheduler) {
+      try {
+        await this.dreamScheduler.dispose();
+        console.log("[LearningOptimizationCoordinator] DreamScheduler disposed");
+      } catch (error) {
+        console.error("[LearningOptimizationCoordinator] Error disposing DreamScheduler:", error);
+      }
+      this.dreamScheduler = null;
+    }
     if (this.initialized && this.sona) {
       try {
         await this.sona.close();
@@ -64801,7 +67933,7 @@ var LearningOptimizationCoordinator = class {
    * Run a learning cycle for a specific domain
    */
   async runLearningCycle(domain) {
-    const workflowId = uuidv442();
+    const workflowId = uuidv445();
     try {
       this.startWorkflow(workflowId, "learning-cycle");
       const agentResult = await this.spawnLearningAgent(workflowId, domain);
@@ -64885,7 +68017,7 @@ var LearningOptimizationCoordinator = class {
    * Optimize all domain strategies
    */
   async optimizeAllStrategies() {
-    const workflowId = uuidv442();
+    const workflowId = uuidv445();
     try {
       this.startWorkflow(workflowId, "optimization");
       const byDomain = {};
@@ -64953,7 +68085,7 @@ var LearningOptimizationCoordinator = class {
    * Share learnings across domains
    */
   async shareCrossDomainLearnings() {
-    const workflowId = uuidv442();
+    const workflowId = uuidv445();
     try {
       this.startWorkflow(workflowId, "transfer");
       let knowledgeShared = 0;
@@ -65219,11 +68351,95 @@ var LearningOptimizationCoordinator = class {
     this.ensureInitialized();
     return this.sona.verifyPerformance(iterations);
   }
+  // ============================================================================
+  // Dream Scheduler Methods
+  // ============================================================================
+  /**
+   * Trigger a dream cycle manually.
+   * Dreams consolidate patterns and generate novel insights through spreading activation.
+   *
+   * @param durationMs - Optional duration override in ms
+   * @returns Dream cycle result with generated insights
+   * @throws Error if DreamScheduler is not initialized
+   */
+  async triggerDreamCycle(durationMs) {
+    if (!this.dreamScheduler) {
+      throw new Error("[LearningOptimizationCoordinator] DreamScheduler not initialized");
+    }
+    const result = await this.dreamScheduler.triggerDream(durationMs);
+    if (this.config.publishEvents) {
+      await this.publishDreamCycleCompleted(
+        result.cycle.id,
+        result.cycle.durationMs ?? 0,
+        result.cycle.conceptsProcessed,
+        result.insights.map((i) => ({
+          id: i.id,
+          type: i.type,
+          description: i.description,
+          noveltyScore: i.noveltyScore,
+          confidenceScore: i.confidenceScore,
+          actionable: i.actionable,
+          suggestedAction: i.suggestedAction,
+          sourceConcepts: i.sourceConcepts
+        })),
+        result.patternsCreated
+      );
+    }
+    return result;
+  }
+  /**
+   * Get the current status of the DreamScheduler.
+   *
+   * @returns DreamScheduler status or null if not initialized
+   */
+  getDreamStatus() {
+    return this.dreamScheduler?.getStatus() ?? null;
+  }
+  /**
+   * Check if the DreamScheduler is available and running.
+   *
+   * @returns True if DreamScheduler is initialized
+   */
+  isDreamSchedulerAvailable() {
+    return this.dreamScheduler !== null;
+  }
+  /**
+   * Get the last dream cycle result from the scheduler.
+   *
+   * @returns Last dream result or null if no dreams have completed
+   */
+  getLastDreamResult() {
+    return this.dreamScheduler?.getLastDreamResult() ?? null;
+  }
+  /**
+   * Trigger a quick dream cycle for rapid insight generation.
+   *
+   * @returns Dream cycle result
+   * @throws Error if DreamScheduler is not initialized
+   */
+  async triggerQuickDream() {
+    if (!this.dreamScheduler) {
+      throw new Error("[LearningOptimizationCoordinator] DreamScheduler not initialized");
+    }
+    return this.dreamScheduler.triggerQuickDream();
+  }
+  /**
+   * Trigger a full dream cycle for comprehensive pattern consolidation.
+   *
+   * @returns Dream cycle result
+   * @throws Error if DreamScheduler is not initialized
+   */
+  async triggerFullDream() {
+    if (!this.dreamScheduler) {
+      throw new Error("[LearningOptimizationCoordinator] DreamScheduler not initialized");
+    }
+    return this.dreamScheduler.triggerFullDream();
+  }
   /**
    * Export learned models
    */
   async exportModels(domains) {
-    const workflowId = uuidv442();
+    const workflowId = uuidv445();
     try {
       this.startWorkflow(workflowId, "export");
       const targetDomains = domains || ALL_DOMAINS;
@@ -65288,7 +68504,7 @@ var LearningOptimizationCoordinator = class {
    * Import learned models
    */
   async importModels(modelExport) {
-    const workflowId = uuidv442();
+    const workflowId = uuidv445();
     try {
       this.startWorkflow(workflowId, "import");
       const calculatedChecksum = this.calculateChecksum(
@@ -65597,6 +68813,22 @@ var LearningOptimizationCoordinator = class {
         `[LearningOptimizationCoordinator] Experience ${experience.id} transferred to ${relatedDomains.length} related domains`
       );
     }
+    if (this.dreamScheduler) {
+      this.dreamScheduler.recordExperience({
+        id: experience.id,
+        agentType: experience.agent || "unknown",
+        domain,
+        taskType: experience.task,
+        success: experience.success,
+        duration: experience.durationMs,
+        context: {
+          quality: experience.quality,
+          steps: experience.steps.length,
+          patterns: experience.patterns?.length || 0
+        },
+        timestamp: new Date(experience.startedAt)
+      });
+    }
   }
   // ============================================================================
   // Event Publishing
@@ -65639,6 +68871,39 @@ var LearningOptimizationCoordinator = class {
     );
     await this.eventBus.publish(event);
   }
+  /**
+   * Publish a dream cycle completion event.
+   * This broadcasts dream insights to all interested domain coordinators.
+   *
+   * Called by the DreamScheduler or DreamEngine after completing a dream cycle.
+   *
+   * @param cycleId - Unique identifier for the dream cycle
+   * @param durationMs - How long the dream cycle took
+   * @param conceptsProcessed - Number of concepts processed during dreaming
+   * @param insights - Array of insights generated during the dream cycle
+   * @param patternsCreated - Number of patterns created from insights
+   */
+  async publishDreamCycleCompleted(cycleId, durationMs, conceptsProcessed, insights, patternsCreated) {
+    if (!this.config.publishEvents) {
+      return;
+    }
+    const payload = {
+      cycleId,
+      durationMs,
+      conceptsProcessed,
+      insights,
+      patternsCreated
+    };
+    const event = createEvent(
+      LearningOptimizationEvents.DreamCycleCompleted,
+      "learning-optimization",
+      payload
+    );
+    await this.eventBus.publish(event);
+    console.log(
+      `[LearningOptimizationCoordinator] Published dream cycle completion: ${insights.length} insights for ${conceptsProcessed} concepts`
+    );
+  }
   // ============================================================================
   // Agent Management
   // ============================================================================
@@ -66373,7 +69638,7 @@ init_types();
 
 // src/coordination/workflow-orchestrator.ts
 init_types();
-import { v4 as uuidv443 } from "uuid";
+import { v4 as uuidv446 } from "uuid";
 var WorkflowEvents = {
   WorkflowStarted: "workflow.WorkflowStarted",
   WorkflowCompleted: "workflow.WorkflowCompleted",
@@ -66487,7 +69752,7 @@ var WorkflowOrchestrator = class {
         )
       );
     }
-    const executionId = uuidv443();
+    const executionId = uuidv446();
     const startedAt = /* @__PURE__ */ new Date();
     const context2 = {
       input,
@@ -67999,7 +71264,7 @@ var QEKernelImpl = class {
 
 // src/coordination/queen-coordinator.ts
 init_types();
-import { v4 as uuidv447 } from "uuid";
+import { v4 as uuidv450 } from "uuid";
 
 // src/shared/utils/circular-buffer.ts
 var CircularBuffer = class {
@@ -68210,7 +71475,7 @@ function createTaskAuditLogger(config) {
 
 // src/coordination/mincut/queen-integration.ts
 init_types();
-import { v4 as uuidv446 } from "uuid";
+import { v4 as uuidv449 } from "uuid";
 
 // src/coordination/mincut/swarm-graph.ts
 var SwarmGraph = class _SwarmGraph {
@@ -68583,7 +71848,7 @@ function createSwarmGraph() {
 }
 
 // src/coordination/mincut/mincut-health-monitor.ts
-import { v4 as uuidv444 } from "uuid";
+import { v4 as uuidv447 } from "uuid";
 
 // src/coordination/mincut/mincut-calculator.ts
 var MinCutCalculator = class {
@@ -69217,7 +72482,7 @@ var MinCutHealthMonitor = class {
       return;
     }
     const alert = {
-      id: uuidv444(),
+      id: uuidv447(),
       severity,
       message,
       minCutValue,
@@ -69237,11 +72502,11 @@ var MinCutHealthMonitor = class {
   emitEvent(type, minCutValue, payload) {
     if (!this.eventBus) return;
     const event = {
-      id: uuidv444(),
+      id: uuidv447(),
       type,
       source: "coordination",
       timestamp: /* @__PURE__ */ new Date(),
-      correlationId: uuidv444(),
+      correlationId: uuidv447(),
       payload: {
         minCutValue,
         ...payload
@@ -69257,7 +72522,7 @@ function createMinCutHealthMonitor(graph, config, eventBus) {
 }
 
 // src/coordination/mincut/mincut-persistence.ts
-import { v4 as uuidv445 } from "uuid";
+import { v4 as uuidv448 } from "uuid";
 var MinCutPersistence = class {
   memory;
   initialized = false;
@@ -69282,7 +72547,7 @@ var MinCutPersistence = class {
    */
   async saveSnapshot(snapshot) {
     this.ensureInitialized();
-    const id = uuidv445();
+    const id = uuidv448();
     const db = this.memory.getDatabase();
     db.prepare(`
       INSERT INTO mincut_snapshots (
@@ -69444,7 +72709,7 @@ var MinCutPersistence = class {
     `);
     const insertMany = db.transaction((vertices) => {
       for (const weak of vertices) {
-        const id = uuidv445();
+        const id = uuidv448();
         insert.run(
           id,
           weak.vertexId,
@@ -69571,7 +72836,7 @@ var MinCutPersistence = class {
    */
   async recordHealingAction(result) {
     this.ensureInitialized();
-    const id = uuidv445();
+    const id = uuidv448();
     const db = this.memory.getDatabase();
     db.prepare(`
       INSERT INTO mincut_healing_actions (
@@ -69652,7 +72917,7 @@ var MinCutPersistence = class {
    */
   async recordObservation(observation) {
     this.ensureInitialized();
-    const id = uuidv445();
+    const id = uuidv448();
     const db = this.memory.getDatabase();
     let actualVsPredictedDiff = null;
     if (observation.prediction) {
@@ -70233,7 +73498,7 @@ var QueenMinCutBridge = class {
   // ==========================================================================
   async reportHealthIssue(issue) {
     await this.eventBus.publish({
-      id: uuidv446(),
+      id: uuidv449(),
       type: "MinCutHealthIssue",
       source: "mincut-bridge",
       timestamp: /* @__PURE__ */ new Date(),
@@ -71351,7 +74616,7 @@ var QueenCoordinator = class {
     if (!this.initialized) {
       return err(new Error("Queen Coordinator not initialized"));
     }
-    const taskId = `task_${uuidv447()}`;
+    const taskId = `task_${uuidv450()}`;
     const task = {
       ...taskInput,
       id: taskId,
@@ -71804,6 +75069,45 @@ var QueenCoordinator = class {
       await this.processQueue();
     }
   }
+  /**
+   * Handle task completion callback from domain plugin
+   * Queen-Domain Integration Fix: Direct task execution callback handler
+   */
+  async handleTaskCompletion(result) {
+    const execution = this.tasks.get(result.taskId);
+    if (!execution) {
+      console.warn(`[Queen] Received completion for unknown task: ${result.taskId}`);
+      return;
+    }
+    const updated = {
+      ...execution,
+      status: result.success ? "completed" : "failed",
+      completedAt: /* @__PURE__ */ new Date(),
+      result: result.data,
+      error: result.error
+    };
+    this.tasks.set(result.taskId, updated);
+    if (result.success) {
+      this.tasksCompleted++;
+      this.taskDurations.push(result.duration);
+      this.auditLogger.logComplete(result.taskId, execution.assignedAgents[0]);
+    } else {
+      this.tasksFailed++;
+      this.auditLogger.logFail(result.taskId, execution.assignedAgents[0], result.error || "Unknown error");
+    }
+    this.runningTaskCounter = Math.max(0, this.runningTaskCounter - 1);
+    for (const agentId of execution.assignedAgents) {
+      await this.agentCoordinator.stop(agentId);
+    }
+    await this.publishEvent(result.success ? "TaskCompleted" : "TaskFailed", {
+      taskId: result.taskId,
+      domain: execution.assignedDomain,
+      result: result.data,
+      error: result.error,
+      duration: result.duration
+    });
+    await this.processQueue();
+  }
   async assignTask(task) {
     const targetDomains = task.targetDomains.length > 0 ? task.targetDomains : TASK_DOMAIN_MAP[task.type] || [];
     if (targetDomains.length === 0) {
@@ -71875,17 +75179,46 @@ var QueenCoordinator = class {
     });
     if (this.domainPlugins) {
       const plugin = this.domainPlugins.get(domain);
+      if (plugin?.executeTask && plugin.canHandleTask?.(task.type)) {
+        const request = {
+          taskId: task.id,
+          taskType: task.type,
+          payload: task.payload,
+          priority: task.priority,
+          timeout: task.timeout,
+          correlationId: task.correlationId
+        };
+        const execResult = await plugin.executeTask(
+          request,
+          (result) => this.handleTaskCompletion(result)
+        );
+        if (!execResult.success) {
+          this.tasks.set(task.id, {
+            ...execution,
+            status: "failed",
+            error: execResult.error.message,
+            completedAt: /* @__PURE__ */ new Date()
+          });
+          this.runningTaskCounter = Math.max(0, this.runningTaskCounter - 1);
+          this.tasksFailed++;
+          this.auditLogger.logFail(task.id, agentIds[0], execResult.error.message);
+          return err(execResult.error);
+        }
+        return ok(task.id);
+      }
       if (plugin) {
         try {
           await plugin.handleEvent({
-            id: uuidv447(),
+            id: uuidv450(),
             type: "TaskAssigned",
             timestamp: /* @__PURE__ */ new Date(),
             source: "queen-coordinator",
             correlationId: task.correlationId,
             payload: { task }
           });
+          console.warn(`[Queen] Domain ${domain} has no executeTask handler, using event fallback`);
         } catch (error) {
+          console.warn(`[Queen] Failed to invoke domain ${domain} event handler:`, error);
         }
       }
     }
@@ -72009,7 +75342,7 @@ var QueenCoordinator = class {
   }
   async publishEvent(type, payload) {
     await this.eventBus.publish({
-      id: uuidv447(),
+      id: uuidv450(),
       type: `Queen${type}`,
       timestamp: /* @__PURE__ */ new Date(),
       source: "queen-coordinator",
@@ -72042,7 +75375,7 @@ var QueenCoordinator = class {
     return cleaned;
   }
 };
-function createQueenCoordinator(kernel, router, protocolExecutor, workflowExecutor, config) {
+function createQueenCoordinator(kernel, router, protocolExecutor, workflowExecutor, domainPlugins, config) {
   return new QueenCoordinator(
     kernel.eventBus,
     kernel.coordinator,
@@ -72050,14 +75383,14 @@ function createQueenCoordinator(kernel, router, protocolExecutor, workflowExecut
     router,
     protocolExecutor,
     workflowExecutor,
-    void 0,
+    domainPlugins,
     config
   );
 }
 
 // src/coordination/cross-domain-router.ts
 init_types();
-import { v4 as uuidv448 } from "uuid";
+import { v4 as uuidv451 } from "uuid";
 var CrossDomainEventRouter = class {
   constructor(eventBus, options) {
     this.eventBus = eventBus;
@@ -72101,7 +75434,7 @@ var CrossDomainEventRouter = class {
    * Subscribe to events from a specific domain
    */
   subscribeToDoamin(domain, handler) {
-    const id = `sub_domain_${uuidv448()}`;
+    const id = `sub_domain_${uuidv451()}`;
     this.subscriptions.set(id, {
       id,
       type: "domain",
@@ -72115,7 +75448,7 @@ var CrossDomainEventRouter = class {
    * Subscribe to specific event types
    */
   subscribeToEventType(eventType, handler) {
-    const id = `sub_type_${uuidv448()}`;
+    const id = `sub_type_${uuidv451()}`;
     this.subscriptions.set(id, {
       id,
       type: "eventType",
@@ -72232,7 +75565,7 @@ var CrossDomainEventRouter = class {
       eventsPerSecond: events.length > 0 ? events.length / ((windowEnd.getTime() - windowStart.getTime()) / 1e3) : 0
     };
     return {
-      id: uuidv448(),
+      id: uuidv451(),
       windowStart,
       windowEnd,
       events,
@@ -72360,7 +75693,7 @@ var CrossDomainEventRouter = class {
           this.eventBus.publish({
             ...eventToSend,
             // Add routing metadata
-            id: uuidv448(),
+            id: uuidv451(),
             correlationId: event.correlationId ?? event.id
           })
         );
@@ -72381,7 +75714,7 @@ var CrossDomainEventRouter = class {
 
 // src/coordination/protocol-executor.ts
 init_types();
-import { v4 as uuidv449 } from "uuid";
+import { v4 as uuidv452 } from "uuid";
 var ProtocolEvents = {
   ProtocolStarted: "coordination.ProtocolStarted",
   ProtocolCompleted: "coordination.ProtocolCompleted",
@@ -72585,7 +75918,7 @@ var DefaultProtocolExecutor = class {
    * Execute a protocol
    */
   async executeProtocol(protocol, params, triggeringEvent) {
-    const executionId = uuidv449();
+    const executionId = uuidv452();
     const correlationId = triggeringEvent?.correlationId ?? executionId;
     const execution = {
       executionId,
@@ -73385,7 +76718,7 @@ var EarlyExitTokenOptimizer = class {
 
 // src/learning/pattern-store.ts
 init_types();
-import { v4 as uuidv450 } from "uuid";
+import { v4 as uuidv453 } from "uuid";
 var DEFAULT_PATTERN_STORE_CONFIG = {
   namespace: "qe-patterns",
   embeddingDimension: 128,
@@ -73620,7 +76953,7 @@ var PatternStore = class {
   async create(options) {
     const now = /* @__PURE__ */ new Date();
     const pattern = {
-      id: uuidv450(),
+      id: uuidv453(),
       patternType: options.patternType,
       qeDomain: this.detectDomainFromType(options.patternType),
       domain: mapQEDomainToAQE(this.detectDomainFromType(options.patternType)),
@@ -82386,7 +85719,7 @@ function createTimedSpinner(text) {
 }
 
 // src/cli/handlers/task-handler.ts
-var TaskHandler = class {
+var TaskHandler5 = class {
   name = "task";
   description = "Manage QE tasks";
   cleanupAndExit;
@@ -82605,7 +85938,7 @@ Examples:
   }
 };
 function createTaskHandler(cleanupAndExit2, ensureInitialized2) {
-  return new TaskHandler(cleanupAndExit2, ensureInitialized2);
+  return new TaskHandler5(cleanupAndExit2, ensureInitialized2);
 }
 
 // src/cli/handlers/agent-handler.ts
@@ -89548,7 +92881,7 @@ function createPostgresWriter(config) {
 }
 
 // src/sync/sync-agent.ts
-import { v4 as uuidv451 } from "uuid";
+import { v4 as uuidv454 } from "uuid";
 var CloudSyncAgent = class {
   config;
   readers = /* @__PURE__ */ new Map();
@@ -89853,7 +93186,7 @@ var CloudSyncAgent = class {
   }
   createReport(mode) {
     return {
-      syncId: uuidv451(),
+      syncId: uuidv454(),
       startedAt: /* @__PURE__ */ new Date(),
       status: "running",
       environment: this.config.environment,
@@ -95691,7 +99024,7 @@ async function cleanupAndExit(code = 0) {
   process.exit(code);
 }
 var program = new Command13();
-var VERSION = true ? "3.3.1" : "0.0.0-dev";
+var VERSION = true ? "3.3.2" : "0.0.0-dev";
 program.name("aqe").description("Agentic QE - Domain-Driven Quality Engineering").version(VERSION);
 var registry = createCommandRegistry(context, cleanupAndExit, ensureInitialized);
 registry.registerAll(program);