agentic-qe 3.9.25 → 3.9.27

package/dist/cli/commands/hooks-handlers/task-hooks.js

@@ -311,10 +311,19 @@ export function registerTaskHooks(hooks) {
                         durationMs,
                         success,
                     });
+                    // Issue #460: when --agent arrives empty (Claude Code does not
+                    // expose $TOOL_RESULT_agent_id in PostToolUse context), `agent`
+                    // resolves to 'unknown' and every Q-value lands in the same
+                    // bucket — the router can never learn per-agent differentiation.
+                    // The pre-task bridge already carries `agent: routing.recommendedAgent`
+                    // which is the correct action key, so prefer that over 'unknown'.
+                    const effectiveAgent = agent === 'unknown' && outcome.bridge?.agent
+                        ? outcome.bridge.agent
+                        : agent;
                     // Stream D (patch 150): apply 6-dim outcome quality to the
                     // routing_outcomes sentinel that pre-task wrote with quality=-1.
                     await updateRoutingOutcomeQuality({
-                        agent,
+                        agent: effectiveAgent,
                         success,
                         durationMs,
                         qualityScore: outcome.qualityScore,
@@ -327,7 +336,7 @@ export function registerTaskHooks(hooks) {
                             priority: outcome.bridge.priority,
                             domain: outcome.bridge.domain,
                             complexityBucket: outcome.bridge.complexityBucket,
-                            agent,
+                            agent: effectiveAgent,
                             success,
                         });
                     }
@@ -355,6 +364,7 @@ export function registerTaskHooks(hooks) {
                     dreamTriggered: dreamResult.triggered,
                     dreamReason: dreamResult.reason,
                     dreamInsights: dreamResult.insightsGenerated,
+                    dreamInsightsApplied: dreamResult.insightsApplied,
                 });
             }
             else {
@@ -364,7 +374,10 @@ export function registerTaskHooks(hooks) {
                     console.log(chalk.green(`  Patterns learned: ${patternsLearned}`));
                 }
                 if (dreamResult.triggered) {
-                    console.log(chalk.blue(`  🌙 Dream cycle triggered (${dreamResult.reason}): ${dreamResult.insightsGenerated} insights`));
+                    const appliedSuffix = typeof dreamResult.insightsApplied === 'number'
+                        ? `, ${dreamResult.insightsApplied} applied`
+                        : '';
+                    console.log(chalk.blue(`  🌙 Dream cycle triggered (${dreamResult.reason}): ${dreamResult.insightsGenerated} insights${appliedSuffix}`));
                 }
             }
             return;

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';
@@ -75,6 +76,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 +229,26 @@ export class QEKernelImpl {
         catch {
             // Migration coordinator is best-effort — don't block kernel startup
         }
+        // Issue #479: 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.
+        // Best-effort — never block kernel startup on bridge failure.
+        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,
         });
     }
     /**
@@ -466,17 +487,48 @@ export class QEReasoningBank {
         for (const domain of QE_DOMAIN_LIST) {
             byDomain[domain] = patternStoreStats.byDomain[domain] || 0;
         }
+        // DB fallback (#454): in-memory `this.stats` is reset on every process
+        // start, but every hook invocation spawns a fresh node. Without a DB
+        // fallback, `aqe hooks stats` always reports zeros even when historical
+        // routing_outcomes / qe_pattern_usage rows exist. We use the in-memory
+        // counters when they're non-zero (live, current-process data), otherwise
+        // fall back to aggregated DB totals.
+        let routingRequests = this.stats.routingRequests;
+        let avgRoutingConfidence = this.stats.routingRequests > 0
+            ? this.stats.totalRoutingConfidence / this.stats.routingRequests
+            : 0;
+        let learningOutcomes = this.stats.learningOutcomes;
+        let patternSuccessRate = this.stats.learningOutcomes > 0
+            ? this.stats.successfulOutcomes / this.stats.learningOutcomes
+            : 0;
+        if (routingRequests === 0 || learningOutcomes === 0) {
+            try {
+                const agg = this.getSqliteStore().getAggregateOutcomeStats();
+                if (routingRequests === 0 && agg.routingRequests > 0) {
+                    routingRequests = agg.routingRequests;
+                    avgRoutingConfidence = agg.avgRoutingConfidence;
+                }
+                if (learningOutcomes === 0 && agg.learningOutcomes > 0) {
+                    learningOutcomes = agg.learningOutcomes;
+                    // Prefer per-usage success rate (closer to recordOutcome semantics);
+                    // fall back to qe_patterns.success_rate aggregate when no usage rows.
+                    patternSuccessRate =
+                        agg.learningOutcomes > 0
+                            ? agg.successfulOutcomes / agg.learningOutcomes
+                            : agg.avgPatternSuccessRate;
+                }
+            }
+            catch {
+                // best-effort — never let stats reporting crash the host
+            }
+        }
         return {
             totalPatterns: patternStoreStats.totalPatterns,
             byDomain,
-            routingRequests: this.stats.routingRequests,
-            avgRoutingConfidence: this.stats.routingRequests > 0
-                ? this.stats.totalRoutingConfidence / this.stats.routingRequests
-                : 0,
-            learningOutcomes: this.stats.learningOutcomes,
-            patternSuccessRate: this.stats.learningOutcomes > 0
-                ? this.stats.successfulOutcomes / this.stats.learningOutcomes
-                : 0,
+            routingRequests,
+            avgRoutingConfidence,
+            learningOutcomes,
+            patternSuccessRate,
             patternStoreStats,
         };
     }

package/dist/learning/rvf-pattern-store.d.ts

@@ -49,6 +49,15 @@ export declare class RvfPatternStore implements IPatternStore {
     /** Get the underlying RVF adapter (for COW branching, migration, etc.) */
     getAdapter(): RvfNativeAdapter | null;
     initialize(): Promise<void>;
+    /**
+     * Compare the RVF vector count with the SQLite pattern count; if RVF has
+     * more rows, read the idmap.json and delete any vector IDs that no longer
+     * have a matching qe_patterns row.
+     *
+     * Fail-open: any error in the purge path is swallowed so a stale or
+     * corrupted idmap can't keep the store from initializing (#462).
+     */
+    private purgeOrphanedVectors;
     dispose(): Promise<void>;
     store(pattern: QEPattern): Promise<Result<string>>;
     create(options: CreateQEPatternOptions): Promise<Result<QEPattern>>;

package/dist/learning/rvf-pattern-store.js

@@ -89,6 +89,48 @@ export class RvfPatternStore {
                 // SQLite auto-attach is best-effort
             }
         }
+        // Issue #462: purge orphan vectors that survived in patterns.rvf when an
+        // upgrade workflow rewrote qe_patterns via INSERT OR REPLACE without
+        // calling RvfPatternStore.delete() on the old IDs. Ghost vectors win
+        // cosine-similarity matches, route to non-existent pattern IDs, and
+        // every learning write fails silently. Run once on init.
+        await this.purgeOrphanedVectors();
+    }
+    /**
+     * Compare the RVF vector count with the SQLite pattern count; if RVF has
+     * more rows, read the idmap.json and delete any vector IDs that no longer
+     * have a matching qe_patterns row.
+     *
+     * Fail-open: any error in the purge path is swallowed so a stale or
+     * corrupted idmap can't keep the store from initializing (#462).
+     */
+    async purgeOrphanedVectors() {
+        if (!this.adapter || !this.sqliteStore)
+            return;
+        try {
+            const rvfCount = this.adapter.status()?.totalVectors ?? 0;
+            const dbCount = this.sqliteStore.getStats()?.totalPatterns ?? 0;
+            if (rvfCount <= dbCount)
+                return;
+            const { readFileSync, existsSync } = await import('node:fs');
+            const idmapPath = `${this.rvfPath}.idmap.json`;
+            if (!existsSync(idmapPath))
+                return;
+            const idmap = JSON.parse(readFileSync(idmapPath, 'utf-8'));
+            const rvfIds = new Set((idmap.entries ?? [])
+                .map((e) => (Array.isArray(e) ? e[0] : undefined))
+                .filter((id) => typeof id === 'string'));
+            const dbIds = new Set(this.sqliteStore.getPatterns({ limit: 10_000 }).map((p) => p.id));
+            const orphans = [...rvfIds].filter((id) => !dbIds.has(id));
+            if (orphans.length === 0)
+                return;
+            this.adapter.delete(orphans);
+            console.log(`[RvfPatternStore] Removed ${orphans.length} ghost vectors (index ${rvfCount} > DB ${dbCount})`);
+        }
+        catch (error) {
+            // fail-open: a stale idmap or read error must not block initialization
+            console.warn(`[RvfPatternStore] orphan purge skipped: ${toErrorMessage(error)}`);
+        }
     }
     async dispose() {
         if (this.adapter && !this.skipCloseOnDispose) {

package/dist/learning/sqlite-persistence.d.ts

@@ -134,6 +134,24 @@ export declare class SQLitePatternStore {
         byDomain: Record<string, number>;
         byTier: Record<string, number>;
     };
+    /**
+     * Aggregate outcome counters used by QEReasoningBank.getStats() as a fallback
+     * when the in-memory `this.stats` object is zero — every hook subprocess
+     * starts with a fresh counter, so without this fallback observability is
+     * always blank (#454).
+     *
+     * routing_outcomes and qe_pattern_usage live in the same unified memory.db
+     * as qe_patterns. avgConfidence/avgSuccessRate return 0 when the source
+     * tables are empty rather than NaN.
+     */
+    getAggregateOutcomeStats(): {
+        routingRequests: number;
+        avgRoutingConfidence: number;
+        successfulRoutings: number;
+        learningOutcomes: number;
+        successfulOutcomes: number;
+        avgPatternSuccessRate: number;
+    };
     /**
      * Check if there's any historical data (embeddings, usage, trajectories)
      * even if qe_patterns is empty. Used to detect data loss vs fresh database.

package/dist/learning/sqlite-persistence.js

@@ -596,6 +596,65 @@ export class SQLitePatternStore {
         }
         return { totalPatterns: total, byDomain, byTier };
     }
+    /**
+     * Aggregate outcome counters used by QEReasoningBank.getStats() as a fallback
+     * when the in-memory `this.stats` object is zero — every hook subprocess
+     * starts with a fresh counter, so without this fallback observability is
+     * always blank (#454).
+     *
+     * routing_outcomes and qe_pattern_usage live in the same unified memory.db
+     * as qe_patterns. avgConfidence/avgSuccessRate return 0 when the source
+     * tables are empty rather than NaN.
+     */
+    getAggregateOutcomeStats() {
+        const empty = {
+            routingRequests: 0,
+            avgRoutingConfidence: 0,
+            successfulRoutings: 0,
+            learningOutcomes: 0,
+            successfulOutcomes: 0,
+            avgPatternSuccessRate: 0,
+        };
+        if (!this.db)
+            return empty;
+        const safeGet = (sql) => {
+            try {
+                return this.db.prepare(sql).get();
+            }
+            catch {
+                return undefined;
+            }
+        };
+        // routing_outcomes carries (success, quality_score) per closed turn.
+        // Sentinels still have quality_score = -1, so filter to closed rows.
+        const routing = safeGet(`
+      SELECT
+        COUNT(*) AS total,
+        COUNT(CASE WHEN quality_score >= 0 THEN 1 END) AS closed,
+        AVG(CASE WHEN quality_score >= 0 THEN quality_score END) AS avg_q,
+        COALESCE(SUM(CASE WHEN success = 1 THEN 1 ELSE 0 END), 0) AS succ
+      FROM routing_outcomes
+    `);
+        const usage = safeGet(`
+      SELECT
+        COUNT(*) AS total,
+        COALESCE(SUM(CASE WHEN success = 1 THEN 1 ELSE 0 END), 0) AS succ
+      FROM qe_pattern_usage
+    `);
+        const patternAvg = safeGet(`
+      SELECT AVG(success_rate) AS avg_sr
+      FROM qe_patterns
+      WHERE usage_count > 0
+    `);
+        return {
+            routingRequests: routing?.total ?? 0,
+            avgRoutingConfidence: routing?.avg_q ?? 0,
+            successfulRoutings: routing?.succ ?? 0,
+            learningOutcomes: usage?.total ?? 0,
+            successfulOutcomes: usage?.succ ?? 0,
+            avgPatternSuccessRate: patternAvg?.avg_sr ?? 0,
+        };
+    }
     /**
      * Check if there's any historical data (embeddings, usage, trajectories)
      * even if qe_patterns is empty. Used to detect data loss vs fresh database.