agentic-qe 3.9.26 → 3.9.28

package/dist/kernel/interfaces.d.ts

@@ -283,6 +283,20 @@ export interface KernelConfig {
     enabledDomains: DomainName[];
     /** Data directory for persistent storage (default: .agentic-qe relative to project root) */
     dataDir?: string;
+    /**
+     * Whether to start the CapturedExperienceBridge during initialize().
+     * The bridge drains hook-fired captured_experiences rows into eventBus
+     * domain events. When `true` (default), kernel.initialize() force-loads
+     * all enabled domain plugins before starting the bridge so their
+     * subscribeToEvents() handlers are wired before the bridge publishes
+     * (issue #482 — without this, the bridge's immediate drain publishes
+     * to a kernel with zero subscribers and the events are silently lost).
+     *
+     * Long-lived processes (MCP server, daemon) want this true.
+     * Short-lived CLI commands that don't need event-driven domain reactions
+     * can set false to skip the plugin-load cost.
+     */
+    enableExperienceBridge?: boolean;
 }
 /**
  * Event middleware interface for anti-drift and other event processing (ADR-060)

package/dist/kernel/kernel.d.ts

@@ -20,6 +20,7 @@ export declare class QEKernelImpl implements QEKernel {
     private _startTime;
     private _initialized;
     private _loopTracker;
+    private _experienceBridge?;
     constructor(config?: Partial<KernelConfig>);
     get eventBus(): EventBus;
     get coordinator(): AgentCoordinator;

package/dist/kernel/kernel.js

@@ -18,6 +18,7 @@ import * as path from 'path';
 import * as fs from 'fs';
 import { PluginLifecycleManager } from '../plugins/lifecycle';
 import { PluginCache } from '../plugins/cache';
+import { CapturedExperienceBridge } from '../bridge/captured-experience-bridge.js';
 // Import domain plugin factories
 import { createTestGenerationPlugin } from '../domains/test-generation/plugin';
 import { createTestExecutionPlugin } from '../domains/test-execution/plugin';
@@ -64,6 +65,10 @@ const DEFAULT_CONFIG = {
     lazyLoading: true,
     enabledDomains: [...ALL_DOMAINS],
     dataDir: undefined, // Will use project root + .agentic-qe
+    // Default ON: long-lived processes (MCP server, daemon) need the bridge
+    // working out of the box. CLI commands that don't need event-driven
+    // domain reactions opt out by passing `enableExperienceBridge: false`.
+    enableExperienceBridge: true,
 };
 export class QEKernelImpl {
     _eventBus;
@@ -75,6 +80,9 @@ export class QEKernelImpl {
     _initialized = false;
     // ADR-062: Loop detection tracker
     _loopTracker;
+    // Issue #479: drains captured_experiences into the eventBus so hook-driven
+    // activity reaches the 13 domain plugins' subscribeToEvents() handlers.
+    _experienceBridge;
     constructor(config = {}) {
         this._config = { ...DEFAULT_CONFIG, ...config };
         this._startTime = new Date();
@@ -225,9 +233,43 @@ export class QEKernelImpl {
         catch {
             // Migration coordinator is best-effort — don't block kernel startup
         }
+        // Issue #479 + #482: start the captured-experience bridge so hook-driven
+        // activity (written to captured_experiences SQLite by short-lived hook
+        // subprocesses) reaches the domain plugins' eventBus handlers.
+        //
+        // Critical ordering: domain plugins MUST be loaded before the bridge
+        // starts. A plugin's subscribeToEvents() runs inside its initialize(),
+        // which is invoked by pluginLoader.load(). Until that happens, the
+        // plugin's handlers aren't wired as eventBus subscribers. The bridge's
+        // start() does an immediate drain, so if plugins are still lazy-pending
+        // at that point, the drained events publish to a kernel with zero
+        // subscribers and are silently lost (issue #482).
+        //
+        // Best-effort throughout: never block kernel startup on either step.
+        if (this._config.enableExperienceBridge !== false) {
+            try {
+                await this._plugins.loadAll();
+            }
+            catch (err) {
+                console.warn('[QEKernel] domain plugin pre-load (for bridge subscribers) failed:', err instanceof Error ? err.message : err);
+            }
+            try {
+                this._experienceBridge = new CapturedExperienceBridge(this._eventBus, this._memory);
+                await this._experienceBridge.start();
+            }
+            catch (err) {
+                console.warn('[QEKernel] CapturedExperienceBridge failed to start:', err instanceof Error ? err.message : err);
+                this._experienceBridge = undefined;
+            }
+        }
         this._initialized = true;
     }
     async dispose() {
+        // Stop the bridge first so it doesn't try to publish to a disposed bus.
+        if (this._experienceBridge) {
+            await this._experienceBridge.stop();
+            this._experienceBridge = undefined;
+        }
         // Dispose in reverse order of initialization
         await this._plugins.disposeAll();
         await this._coordinator.dispose();

package/dist/learning/pattern-promotion.d.ts

@@ -53,6 +53,12 @@ export interface SeedingDeps {
     searchPatterns: (query: string | number[], options?: Record<string, unknown>) => Promise<Result<PatternSearchResult[]>>;
     storePattern: (options: Record<string, unknown>) => Promise<Result<QEPattern>>;
     patternStore: IPatternStore;
+    /**
+     * Optional cancellation signal. Checked before each store/search so that
+     * an aborted init (issue #478) stops appending to the pattern store
+     * instead of running to completion in the background.
+     */
+    signal?: AbortSignal;
 }
 /**
  * Seed cross-domain patterns by transferring generalizable patterns

package/dist/learning/pattern-promotion.js

@@ -152,10 +152,13 @@ export async function promotePattern(patternId, deps) {
  * from populated domains to their related domains.
  */
 export async function seedCrossDomainPatterns(deps) {
+    const { signal } = deps;
+    signal?.throwIfAborted();
     const stats = await deps.patternStore.getStats();
     let transferred = 0;
     let skipped = 0;
     for (const [sourceDomainStr, targetDomains] of Object.entries(RELATED_DOMAINS)) {
+        signal?.throwIfAborted();
         const sourceDomain = sourceDomainStr;
         const sourceCount = stats.byDomain[sourceDomain] || 0;
         if (sourceCount === 0)
@@ -167,12 +170,14 @@ export async function seedCrossDomainPatterns(deps) {
         if (!sourceResult.success)
             continue;
         for (const targetDomain of targetDomains) {
+            signal?.throwIfAborted();
             const targetCount = stats.byDomain[targetDomain] || 0;
             if (targetCount >= sourceCount) {
                 skipped++;
                 continue;
             }
             for (const { pattern: sourcePattern } of sourceResult.value) {
+                signal?.throwIfAborted();
                 const existingCheck = await deps.searchPatterns(sourcePattern.name, {
                     domain: targetDomain,
                     limit: 1,

package/dist/learning/qe-reasoning-bank-types.d.ts

@@ -112,8 +112,17 @@ export interface PromotionBlockedEvent {
  * QEReasoningBank interface
  */
 export interface IQEReasoningBank {
-    /** Initialize the reasoning bank */
-    initialize(): Promise<void>;
+    /**
+     * Initialize the reasoning bank.
+     *
+     * Pass `signal` to bound long-running init steps (pattern bootstrap,
+     * cross-domain seeding). When the signal is aborted, every awaited step
+     * checks it via `throwIfAborted()` so the work stops promptly instead of
+     * leaking past a caller-side timeout.
+     */
+    initialize(options?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
     /** Store a new pattern */
     storePattern(options: CreateQEPatternOptions): Promise<Result<QEPattern>>;
     /** Search for patterns */
@@ -136,7 +145,7 @@ export interface IQEReasoningBank {
     /** Get embedding for text */
     embed(text: string): Promise<number[]>;
     /** Seed cross-domain patterns by transferring from populated domains to related ones */
-    seedCrossDomainPatterns(): Promise<{
+    seedCrossDomainPatterns(signal?: AbortSignal): Promise<{
         transferred: number;
         skipped: number;
     }>;

package/dist/learning/qe-reasoning-bank.d.ts

@@ -65,9 +65,16 @@ export declare class QEReasoningBank implements IQEReasoningBank {
     private stats;
     constructor(memory: MemoryBackend, eventBus?: EventBus | undefined, config?: Partial<QEReasoningBankConfig>, coherenceService?: import("../integrations/coherence/coherence-service.js").ICoherenceService | undefined);
     /**
-     * Initialize the reasoning bank
+     * Initialize the reasoning bank.
+     *
+     * `options.signal` bounds the init: every step calls
+     * `signal.throwIfAborted()` before starting work, so a caller-side
+     * timeout that aborts the signal causes initialize() to reject promptly
+     * instead of leaking writes past the timeout (issue #478).
      */
-    initialize(): Promise<void>;
+    initialize(options?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
     /**
      * Load pre-trained patterns for common QE scenarios
      */
@@ -79,7 +86,7 @@ export declare class QEReasoningBank implements IQEReasoningBank {
      * Uses the domain compatibility matrix to determine which domains
      * are related and applies a relevance decay to transferred patterns.
      */
-    seedCrossDomainPatterns(): Promise<{
+    seedCrossDomainPatterns(signal?: AbortSignal): Promise<{
         transferred: number;
         skipped: number;
     }>;

package/dist/learning/qe-reasoning-bank.js

@@ -106,12 +106,20 @@ export class QEReasoningBank {
         });
     }
     /**
-     * Initialize the reasoning bank
+     * Initialize the reasoning bank.
+     *
+     * `options.signal` bounds the init: every step calls
+     * `signal.throwIfAborted()` before starting work, so a caller-side
+     * timeout that aborts the signal causes initialize() to reject promptly
+     * instead of leaking writes past the timeout (issue #478).
      */
-    async initialize() {
+    async initialize(options) {
         if (this.initialized)
             return;
+        const signal = options?.signal;
+        signal?.throwIfAborted();
         await this.patternStore.initialize();
+        signal?.throwIfAborted();
         // Wire SQLitePatternStore into PatternStore for delete/promote persistence
         try {
             const store = this.getSqliteStore();
@@ -121,8 +129,10 @@ export class QEReasoningBank {
         catch (e) {
             logger.warn('Failed to wire SQLitePatternStore into PatternStore', { error: toErrorMessage(e) });
         }
+        signal?.throwIfAborted();
         // Load any pre-trained patterns
-        await this.loadPretrainedPatterns();
+        await this.loadPretrainedPatterns(signal);
+        signal?.throwIfAborted();
         this.initialized = true;
         // Run cross-domain transfer ONCE per DB lifetime (not every init)
         // IMPORTANT: Set the flag BEFORE the transfer so that even if the transfer
@@ -134,7 +144,7 @@ export class QEReasoningBank {
             if (!alreadySeeded) {
                 // Set flag FIRST to prevent re-runs if transfer times out or process exits
                 await this.memory.set(SEED_FLAG_KEY, true);
-                await this.seedCrossDomainPatterns();
+                await this.seedCrossDomainPatterns(signal);
             }
             else {
                 const stats = await this.patternStore.getStats();
@@ -142,6 +152,10 @@ export class QEReasoningBank {
             }
         }
         catch (error) {
+            // Re-throw abort errors so the caller sees the cancellation;
+            // swallow other errors per the existing non-fatal contract.
+            if (signal?.aborted)
+                throw error;
             logger.warn('Cross-domain seeding failed (non-fatal)', { error });
         }
         logger.info('Initialized');
@@ -149,8 +163,9 @@ export class QEReasoningBank {
     /**
      * Load pre-trained patterns for common QE scenarios
      */
-    async loadPretrainedPatterns() {
+    async loadPretrainedPatterns(signal) {
         // Check if we already have patterns
+        signal?.throwIfAborted();
         const stats = await this.patternStore.getStats();
         if (stats.totalPatterns > 0) {
             logger.info('Found existing patterns', { totalPatterns: stats.totalPatterns });
@@ -189,10 +204,15 @@ export class QEReasoningBank {
         // 1. embeddings are computed via this.embed()
         // 2. patternStore.store() calls adapter.ingest() for each pattern
         for (const options of PRETRAINED_PATTERNS) {
+            // Bail before each store() so an aborted init does not keep appending
+            // to patterns.rvf (issue #478).
+            signal?.throwIfAborted();
             try {
                 await this.storePattern(options);
             }
             catch (error) {
+                if (signal?.aborted)
+                    throw error;
                 logger.warn('Failed to load pattern', { name: options.name, error });
             }
         }
@@ -205,14 +225,15 @@ export class QEReasoningBank {
      * Uses the domain compatibility matrix to determine which domains
      * are related and applies a relevance decay to transferred patterns.
      */
-    async seedCrossDomainPatterns() {
+    async seedCrossDomainPatterns(signal) {
         if (!this.initialized) {
-            await this.initialize();
+            await this.initialize({ signal });
         }
         return seedCrossDomainPatternsFn({
             searchPatterns: this.searchPatterns.bind(this),
             storePattern: this.storePattern.bind(this),
             patternStore: this.patternStore,
+            signal,
         });
     }
     /**