agentic-qe 3.15.9 → 3.15.11

package/dist/learning/dream/spreading-activation.js

@@ -230,9 +230,10 @@ export class SpreadingActivation {
      * - Novel associations are discovered from unexpected co-activations
      *
      * @param durationMs - How long to dream in milliseconds
+     * @param signal - #1060: stops the dream early (engine closed, shutdown)
      * @returns Activation result from the dream cycle
      */
-    async dream(durationMs) {
+    async dream(durationMs, signal) {
         const startTime = Date.now();
         const allNovelAssociations = [];
         let totalIterations = 0;
@@ -251,7 +252,7 @@ export class SpreadingActivation {
         }
         // Dream loop with strict time enforcement
         const deadlineMs = startTime + durationMs;
-        while (Date.now() < deadlineMs) {
+        while (Date.now() < deadlineMs && !signal?.aborted) {
             // Randomly select a concept to activate
             const randomIndex = secureRandomInt(0, allConcepts.length);
             const randomNode = allConcepts[randomIndex];
@@ -277,10 +278,10 @@ export class SpreadingActivation {
                 }
             }
             // Check deadline again before sleeping
-            if (Date.now() >= deadlineMs)
+            if (Date.now() >= deadlineMs || signal?.aborted)
                 break;
             // Small delay to prevent CPU spike
-            await this.sleep(50 + secureRandom() * 50);
+            await this.sleep(50 + secureRandom() * 50, signal);
         }
         // Deduplicate and sort novel associations
         const uniqueAssociations = this.deduplicateAssociations(allNovelAssociations);
@@ -561,8 +562,16 @@ export class SpreadingActivation {
     /**
      * Helper to sleep for a duration
      */
-    sleep(ms) {
-        return new Promise((resolve) => setTimeout(resolve, ms));
+    sleep(ms, signal) {
+        return new Promise((resolve) => {
+            const timer = setTimeout(done, ms);
+            function done() {
+                clearTimeout(timer);
+                signal?.removeEventListener('abort', done);
+                resolve();
+            }
+            signal?.addEventListener('abort', done, { once: true });
+        });
     }
 }
 export default SpreadingActivation;

package/dist/learning/experience-capture.d.ts

@@ -71,6 +71,11 @@ export interface TaskExperience {
     reward?: number;
     /** Test outcome category (if applicable) */
     testOutcome?: TestOutcome;
+    /**
+     * #1129: what `success` was read from (e.g. test-results). Absent when the
+     * caller only knows the task completed; such usage is not a measured outcome.
+     */
+    outcomeBasis?: string;
     /** Feedback provided */
     feedback?: string;
     /** Extracted patterns (if any) */
@@ -209,6 +214,8 @@ export declare class ExperienceCaptureService {
         quality?: number;
         feedback?: string;
         testOutcome?: TestOutcome;
+        /** #1129: set when `success` was read from the result, not from completion. */
+        outcomeBasis?: string;
     }): Promise<Result<TaskExperience>>;
     /**
      * Get an active experience
@@ -295,6 +302,8 @@ export declare class ExperienceCaptureService {
     /**
      * Convert experience to pattern options
      */
+    /** #1129: tag the usage row so readers can tell a measured outcome from completion. */
+    private usageOutcomeTag;
     private experienceToPatternOptions;
     /**
      * Detect pattern type from task description

package/dist/learning/experience-capture.js

@@ -19,6 +19,7 @@ import { LoggerFactory } from '../logging/index.js';
 import { getRuVectorFeatureFlags } from '../integrations/ruvector/feature-flags.js';
 const logger = LoggerFactory.create('experience-capture');
 import { PROMOTION_THRESHOLD } from './qe-patterns.js';
+import { usageOutcomeMetrics } from './usage-outcome.js';
 /**
  * Reward values for each test outcome.
  * Based on GRPO (Group Relative Policy Optimization) binary reward model.
@@ -181,6 +182,8 @@ export class ExperienceCaptureService {
         experience.durationMs = now - experience.startedAt;
         experience.success = outcome.success;
         experience.feedback = outcome.feedback;
+        if (outcome.outcomeBasis)
+            experience.outcomeBasis = outcome.outcomeBasis;
         // Calculate quality from steps if not provided
         if (outcome.quality !== undefined) {
             experience.quality = outcome.quality;
@@ -250,9 +253,11 @@ export class ExperienceCaptureService {
         // Extract patterns: require positive reward (or no reward signal) AND quality threshold
         // Zero or negative reward blocks extraction — only learn from genuinely positive outcomes
         const rewardAllowsExtraction = experience.reward === undefined || experience.reward > 0;
-        if (experience.success &&
+        // #1129: a measured outcome is recorded whether it succeeded or failed.
+        // Recording only successes made the usage success rate 100% by selection.
+        if (experience.outcomeBasis !== undefined || (experience.success &&
             experience.quality >= this.config.minQualityForPatternExtraction &&
-            rewardAllowsExtraction) {
+            rewardAllowsExtraction)) {
             const extractionResult = await this.extractPattern(experience);
             if (extractionResult.newPattern || extractionResult.reinforced) {
                 experience.patterns = [extractionResult.patternId];
@@ -391,11 +396,13 @@ export class ExperienceCaptureService {
                 && origin.patternType === this.detectPatternType(experience.task)
                 && existing.pattern.patternType === origin.patternType
                 && (!experience.domain || existing.pattern.qeDomain === experience.domain)) {
-                const usageResult = await this.patternStore.recordUsage(existing.pattern.id, experience.success);
+                const usageResult = await this.patternStore.recordUsage(existing.pattern.id, experience.success, this.usageOutcomeTag(experience));
                 // Check if pattern should be promoted (short-term → long-term)
                 const pattern = await this.patternStore.get(existing.pattern.id);
                 let promoted = false;
+                // A failed use is now recorded too (#1129); it never promotes.
                 if (pattern &&
+                    experience.success &&
                     pattern.tier === 'short-term' &&
                     pattern.usageCount >= this.config.promotionThreshold) {
                     // Actually promote the pattern
@@ -420,7 +427,7 @@ export class ExperienceCaptureService {
         if (createResult.success) {
             this.stats.patternsExtracted++;
             // Record the initial usage (the experience that created this pattern)
-            await this.patternStore.recordUsage(createResult.value.id, experience.success);
+            await this.patternStore.recordUsage(createResult.value.id, experience.success, this.usageOutcomeTag(experience));
             return {
                 newPattern: true,
                 patternId: createResult.value.id,
@@ -583,6 +590,13 @@ export class ExperienceCaptureService {
     /**
      * Convert experience to pattern options
      */
+    /** #1129: tag the usage row so readers can tell a measured outcome from completion. */
+    usageOutcomeTag(experience) {
+        const runId = typeof experience.metadata?.runId === 'string' ? experience.metadata.runId : undefined;
+        return experience.outcomeBasis !== undefined
+            ? usageOutcomeMetrics({ measured: true, success: experience.success, basis: experience.outcomeBasis }, runId)
+            : usageOutcomeMetrics({ measured: false, success: null, basis: 'task-completed' }, runId);
+    }
     experienceToPatternOptions(experience) {
         // Detect pattern type from task
         const patternType = this.detectPatternType(experience.task);

package/dist/learning/memory-auditor.js

@@ -59,6 +59,7 @@
 import { randomUUID } from 'crypto';
 import { LoggerFactory } from '../logging/index.js';
 import { toErrorMessage } from '../shared/error-utils.js';
+import { createSafeRecord } from '../shared/utils/safe-record.js';
 const logger = LoggerFactory.create('MemoryAuditor');
 /**
  * Default auditor configuration
@@ -319,7 +320,8 @@ export class MemoryCoherenceAuditor {
      * Group patterns by domain
      */
     groupByDomain(patterns) {
-        const groups = {};
+        // #1157: domains come from stored pattern rows.
+        const groups = createSafeRecord();
         for (const pattern of patterns) {
             const domain = pattern.qeDomain;
             if (!groups[domain]) {

package/dist/learning/qe-patterns.js

@@ -163,7 +163,8 @@ export function validateQEPattern(pattern) {
 export function applyPatternTemplate(template, variables) {
     let content = template.content;
     for (const variable of template.variables) {
-        const value = variables[variable.name] ?? variable.defaultValue;
+        // #1157: the variable name comes from a stored pattern; read own values only.
+        const value = (Object.hasOwn(variables, variable.name) ? variables[variable.name] : undefined) ?? variable.defaultValue;
         if (variable.required && value === undefined) {
             throw new Error(`Required variable ${variable.name} not provided`);
         }

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

@@ -107,6 +107,12 @@ export interface LearningOutcome {
         testsFailed?: number;
         coverageImprovement?: number;
         executionTimeMs?: number;
+        /** #1129: whether `success` was read from the result or only from completion. */
+        outcome?: 'measured' | 'unmeasured';
+        /** #1129: what a measured verdict was read from (e.g. test-results). */
+        outcomeBasis?: string;
+        /** #1129: the run this use belongs to; one run may use several patterns. */
+        runId?: string;
     };
     /** Feedback from the agent or user */
     feedback?: string;
@@ -183,8 +189,17 @@ export interface QEReasoningBankStats {
     avgRoutingConfidence: number;
     /** Learning outcomes recorded */
     learningOutcomes: number;
-    /** Pattern success rate */
-    patternSuccessRate: number;
+    /** #1129: measured runs (success read from the result, e.g. test counts). */
+    measuredOutcomes?: number;
+    /** #1129: usage rows without a measured outcome; left out of the rate. */
+    unmeasuredOutcomes?: number;
+    /**
+     * Share of measured runs that succeeded; null when none is measured
+     * (#1129) instead of a rate built from completed calls.
+     */
+    patternSuccessRate: number | null;
+    /** #1129: set when no measured outcome exists to compute patternSuccessRate. */
+    evidenceStatus?: 'insufficient-evidence';
     /** Pattern store stats */
     patternStoreStats: import('./pattern-store.js').PatternStoreStats;
     /** ADR-061: Asymmetric learning metrics (optional, available in RealQEReasoningBank) */

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

@@ -33,6 +33,7 @@ import { resolveTopologyCriticalFromSharedMincut } from './routing-topology-gate
 import { getUnifiedMemory } from '../kernel/unified-memory.js';
 import { resizeEmbedding, hashEmbedding } from './embedding-utils.js';
 import { maybeEnhanceRoutingWithPatterns } from './pattern-routing-guidance.js';
+import { usageOutcomeOf } from './usage-outcome.js';
 import { checkPatternPromotionWithCoherence, promotePattern as promotePatternFn, seedCrossDomainPatterns as seedCrossDomainPatternsFn, } from './pattern-promotion.js';
 // ============================================================================
 // QEReasoningBank Implementation
@@ -97,6 +98,7 @@ export class QEReasoningBank {
         routingRequests: 0,
         totalRoutingConfidence: 0,
         learningOutcomes: 0,
+        measuredOutcomes: 0,
         successfulOutcomes: 0,
     };
     constructor(memory, eventBus, config = {}, coherenceService) {
@@ -431,8 +433,12 @@ export class QEReasoningBank {
         const result = await this.patternStore.recordUsage(outcome.patternId, outcome.success, outcome.metrics, outcome.feedback);
         if (result.success) {
             this.stats.learningOutcomes++;
-            if (outcome.success) {
-                this.stats.successfulOutcomes++;
+            // #1129: only a measured outcome counts toward the success rate.
+            const measured = usageOutcomeOf(outcome.metrics) === 'measured';
+            if (measured) {
+                this.stats.measuredOutcomes++;
+                if (outcome.success)
+                    this.stats.successfulOutcomes++;
             }
             // ADR-070: Record pattern update in witness chain
             getWitnessChain().then(wc => wc.append('PATTERN_UPDATE', { patternId: outcome.patternId, success: outcome.success }, 'reasoning-bank')).catch((e) => { logger.warn('Witness chain PATTERN_UPDATE failed', { error: toErrorMessage(e) }); });
@@ -721,9 +727,10 @@ export class QEReasoningBank {
             ? 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;
+        // In process each recorded outcome is its own run; the DB groups by runId.
+        let measuredOutcomes = this.stats.measuredOutcomes;
+        let unmeasuredOutcomes = this.stats.learningOutcomes - this.stats.measuredOutcomes;
+        let successfulOutcomes = this.stats.successfulOutcomes;
         try {
             const agg = this.getSqliteStore().getAggregateOutcomeStats();
             if (agg.routingRequests > routingRequests) {
@@ -732,24 +739,28 @@ export class QEReasoningBank {
             }
             if (agg.learningOutcomes > learningOutcomes) {
                 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;
+                measuredOutcomes = agg.measuredOutcomes;
+                unmeasuredOutcomes = agg.unmeasuredOutcomes;
+                successfulOutcomes = agg.successfulOutcomes;
             }
         }
         catch {
             // best-effort — never let stats reporting crash the host
         }
+        // #1129: the rate is over measured outcomes only. A usage row that only
+        // records a completed call says nothing about whether the result was
+        // good, so with none measured there is no rate to report.
+        const patternSuccessRate = measuredOutcomes > 0 ? successfulOutcomes / measuredOutcomes : null;
         return {
             totalPatterns: patternStoreStats.totalPatterns,
             byDomain,
             routingRequests,
             avgRoutingConfidence,
             learningOutcomes,
+            measuredOutcomes,
+            unmeasuredOutcomes,
             patternSuccessRate,
+            ...(patternSuccessRate === null ? { evidenceStatus: 'insufficient-evidence' } : {}),
             patternStoreStats,
         };
     }

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

@@ -38,6 +38,17 @@ export interface RealQEPatternSearchResult {
     matchType: 'vector' | 'lexical';
     canReuse: boolean;
 }
+/**
+ * #1022: how pattern search works in this process. Without an embedding
+ * runtime the bank stores patterns text-only (vectors pending, filled later by
+ * `aqe learning backfill-embeddings`) and searches by SQLite FTS text matching
+ * only. No similarity score is computed in that mode.
+ */
+export interface PatternSearchStatus {
+    mode: 'vector' | 'lexical-only';
+    /** Why vector search is unavailable (only for 'lexical-only'). */
+    reason?: string;
+}
 export interface RealQERoutingRequest {
     task: string;
     taskType?: 'test-generation' | 'analysis' | 'debugging' | 'optimization';
@@ -94,6 +105,8 @@ export interface RealQEReasoningBankStats {
     transformerAvailable: boolean;
     embeddingDimension: number;
     sqliteDbPath: string;
+    /** #1022: whether pattern search uses vectors, or text matching only */
+    patternSearch: PatternSearchStatus;
     /** ADR-061: Asymmetric learning metrics */
     asymmetricLearning?: {
         failurePenaltyRatio: string;
@@ -119,6 +132,8 @@ export declare class RealQEReasoningBank {
     private hnswIndex;
     private patternIdMap;
     private initialized;
+    /** #1022: set when no embedding runtime is available; null when vectors work. */
+    private embedderUnavailableReason;
     private stats;
     private routingLatencies;
     private readonly asymmetricEngine;
@@ -128,6 +143,8 @@ export declare class RealQEReasoningBank {
      * Initialize the QE ReasoningBank
      */
     initialize(): Promise<void>;
+    /** #1022: whether pattern search uses vectors or text matching only. */
+    getPatternSearchStatus(): PatternSearchStatus;
     /**
      * Initialize HNSW index for fast similarity search
      */
@@ -153,6 +170,8 @@ export declare class RealQEReasoningBank {
         domain?: QEDomain;
         minSimilarity?: number;
     }): Promise<Result<RealQEPatternSearchResult[]>>;
+    /** Append HNSW vector matches for `query` to `patterns`. */
+    private collectVectorMatches;
     /**
      * Route a task to optimal agent
      */

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

@@ -80,6 +80,8 @@ export class RealQEReasoningBank {
     hnswIndex = null;
     patternIdMap = new Map();
     initialized = false;
+    /** #1022: set when no embedding runtime is available; null when vectors work. */
+    embedderUnavailableReason = null;
     // Statistics tracking - using CircularBuffer for O(1) operations (ADR memory leak fix)
     stats = {
         routingRequests: 0,
@@ -167,12 +169,24 @@ export class RealQEReasoningBank {
         await this.sqliteStore.initialize();
         logger.info('SQLite persistence initialized');
         // Establish executable provenance before any persisted vectors enter ANN.
-        await computeRealEmbedding(EMBEDDING_SPACE_CANARY, this.qeConfig.embeddings);
-        // Initialize HNSW index
-        await this.initializeHNSW();
-        logger.info('HNSW index initialized');
-        // Load existing patterns into HNSW
-        await this.loadPatternsIntoHNSW();
+        // #1022: without an embedding runtime (no @huggingface/transformers and no
+        // AQE_EMBEDDER_ENDPOINT) run text-only instead of failing: no vector is
+        // computed, stored or searched (ADR-097: no hash-embedding fallback).
+        try {
+            await computeRealEmbedding(EMBEDDING_SPACE_CANARY, this.qeConfig.embeddings);
+        }
+        catch (error) {
+            this.embedderUnavailableReason = toErrorMessage(error);
+            logger.warn('No embedding runtime: patterns are stored without vectors (pending ' +
+                '`aqe learning backfill-embeddings`) and searched by text matching only', { reason: this.embedderUnavailableReason });
+        }
+        if (this.embedderUnavailableReason === null) {
+            // Initialize HNSW index
+            await this.initializeHNSW();
+            logger.info('HNSW index initialized');
+            // Load existing patterns into HNSW
+            await this.loadPatternsIntoHNSW();
+        }
         // Load foundational patterns ONLY if this is a brand-new database (no tables or genuinely empty).
         // CRITICAL: Do NOT overwrite existing data. If patterns were unexpectedly wiped,
         // loading 22 seed patterns would mask the data loss. Log a warning instead.
@@ -193,6 +207,12 @@ export class RealQEReasoningBank {
         const initTime = performance.now() - startTime;
         logger.info('Fully initialized', { durationMs: Math.round(initTime) });
     }
+    /** #1022: whether pattern search uses vectors or text matching only. */
+    getPatternSearchStatus() {
+        return this.embedderUnavailableReason === null
+            ? { mode: 'vector' }
+            : { mode: 'lexical-only', reason: this.embedderUnavailableReason };
+    }
     /**
      * Initialize HNSW index for fast similarity search
      */
@@ -311,9 +331,12 @@ export class RealQEReasoningBank {
     async storeQEPattern(options) {
         // Require explicit initialization - don't auto-initialize to avoid memory issues
         try {
-            // Generate REAL embedding using transformer model
+            // Generate REAL embedding using transformer model. #1022: without an
+            // embedding runtime the pattern is stored text-only (vector pending).
             const textToEmbed = `${options.name} ${options.description || ''} ${options.context?.tags?.join(' ') || ''}`;
-            const embedding = await computeRealEmbedding(textToEmbed, this.qeConfig.embeddings);
+            const embedding = this.embedderUnavailableReason === null
+                ? await computeRealEmbedding(textToEmbed, this.qeConfig.embeddings)
+                : undefined;
             // Detect QE domain
             const qeDomain = detectQEDomain(textToEmbed) || 'test-generation';
             // ADR-058: Check MemoryWriteGate for contradictions before storing
@@ -374,7 +397,7 @@ export class RealQEReasoningBank {
             // Store in SQLite
             this.sqliteStore.storePattern(pattern, embedding);
             // Add to HNSW index
-            if (this.hnswIndex) {
+            if (this.hnswIndex && embedding) {
                 const index = this.hnswIndex.getCurrentCount();
                 this.hnswIndex.addPoint(embedding, index);
                 this.patternIdMap.set(index, patternId);
@@ -410,38 +433,15 @@ export class RealQEReasoningBank {
         // Require explicit initialization - don't auto-initialize to avoid memory issues
         const startTime = performance.now();
         try {
-            if (!this.hnswIndex) {
-                return err(new Error('HNSW index not available'));
-            }
-            // Generate REAL embedding for query
-            const queryEmbedding = await computeRealEmbedding(query, this.qeConfig.embeddings);
-            // Search HNSW index
             const limit = options.limit || 10;
-            const results = this.hnswIndex.searchKnn(queryEmbedding, limit * 2); // Get extra for filtering
             const patterns = [];
-            for (let i = 0; i < results.neighbors.length; i++) {
-                const hnswIndex = results.neighbors[i];
-                const distance = results.distances[i];
-                const similarity = 1 - distance; // Convert distance to similarity
-                if (options.minSimilarity !== undefined && similarity < options.minSimilarity) {
-                    continue;
-                }
-                const patternId = this.patternIdMap.get(hnswIndex);
-                if (!patternId)
-                    continue;
-                const pattern = this.sqliteStore.getPattern(patternId);
-                if (!pattern)
-                    continue;
-                // Filter by domain if specified
-                if (options.domain && pattern.qeDomain !== options.domain) {
-                    continue;
+            // #1022: without an embedding runtime only the lexical (FTS) branch
+            // below runs; its hits are labelled matchType 'lexical'.
+            if (this.embedderUnavailableReason === null) {
+                if (!this.hnswIndex) {
+                    return err(new Error('HNSW index not available'));
                 }
-                const reuse = DEFAULT_PATTERN_STORE_CONFIG.reuseOptimization;
-                const ageDays = (Date.now() - new Date(pattern.lastUsedAt).getTime()) / 86_400_000;
-                patterns.push({ pattern, similarity, score: similarity, matchType: 'vector',
-                    canReuse: Boolean(pattern.reusable && similarity >= reuse.minSimilarityForReuse
-                        && pattern.successRate >= reuse.minSuccessRateForReuse && ageDays <= reuse.maxAgeForReuse),
-                });
+                await this.collectVectorMatches(query, limit, options, patterns);
             }
             const existing = new Map(patterns.map(hit => [hit.pattern.id, hit]));
             for (const lexical of this.sqliteStore.searchFTS(query, limit * 2)) {
@@ -471,6 +471,37 @@ export class RealQEReasoningBank {
             return err(toError(error));
         }
     }
+    /** Append HNSW vector matches for `query` to `patterns`. */
+    async collectVectorMatches(query, limit, options, patterns) {
+        // Generate REAL embedding for query
+        const queryEmbedding = await computeRealEmbedding(query, this.qeConfig.embeddings);
+        // Search HNSW index
+        const results = this.hnswIndex.searchKnn(queryEmbedding, limit * 2); // Get extra for filtering
+        for (let i = 0; i < results.neighbors.length; i++) {
+            const hnswIndex = results.neighbors[i];
+            const distance = results.distances[i];
+            const similarity = 1 - distance; // Convert distance to similarity
+            if (options.minSimilarity !== undefined && similarity < options.minSimilarity) {
+                continue;
+            }
+            const patternId = this.patternIdMap.get(hnswIndex);
+            if (!patternId)
+                continue;
+            const pattern = this.sqliteStore.getPattern(patternId);
+            if (!pattern)
+                continue;
+            // Filter by domain if specified
+            if (options.domain && pattern.qeDomain !== options.domain) {
+                continue;
+            }
+            const reuse = DEFAULT_PATTERN_STORE_CONFIG.reuseOptimization;
+            const ageDays = (Date.now() - new Date(pattern.lastUsedAt).getTime()) / 86_400_000;
+            patterns.push({ pattern, similarity, score: similarity, matchType: 'vector',
+                canReuse: Boolean(pattern.reusable && similarity >= reuse.minSimilarityForReuse
+                    && pattern.successRate >= reuse.minSuccessRateForReuse && ageDays <= reuse.maxAgeForReuse),
+            });
+        }
+    }
     /**
      * Route a task to optimal agent
      */
@@ -701,6 +732,7 @@ export class RealQEReasoningBank {
                 : 0,
             embeddingCacheSize: 0, // Would need to track this in real-embeddings
             transformerAvailable: isTransformerAvailable(),
+            patternSearch: this.getPatternSearchStatus(),
             embeddingDimension: getEmbeddingDimension(),
             sqliteDbPath: this.qeConfig.sqlite.dbPath || '.agentic-qe/memory.db',
             // ADR-061: Asymmetric learning stats

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

@@ -185,12 +185,18 @@ export declare class SQLitePatternStore {
      * 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.
+     *
+     * #1129: measuredOutcomes and successfulOutcomes count measured runs (rows
+     * tagged outcome 'measured', grouped by runId); unmeasuredOutcomes counts
+     * every other usage row. learningOutcomes stays the total row count.
      */
     getAggregateOutcomeStats(): {
         routingRequests: number;
         avgRoutingConfidence: number;
         successfulRoutings: number;
         learningOutcomes: number;
+        measuredOutcomes: number;
+        unmeasuredOutcomes: number;
         successfulOutcomes: number;
         avgPatternSuccessRate: number;
     };

package/dist/learning/sqlite-persistence.js

@@ -21,6 +21,7 @@ import { ensurePatternFtsInSync } from '../kernel/pattern-fts-self-heal.js';
 import { computeBatchEmbeddings, getEmbeddingDimension, isUsingEndpoint, getActiveEmbeddingSpaceIdentity, } from './real-embeddings.js';
 import { EMBEDDING_SPACE_CANARY, inspectEmbeddingSpaceRows, } from './embedding-space.js';
 import { recordPatternUsage } from './pattern-usage-recorder.js';
+import { MEASURED_USAGE_SQL, USAGE_RUN_SQL } from './usage-outcome.js';
 export const DEFAULT_SQLITE_CONFIG = {
     // LEGACY: Ignored when useUnified=true (the default). All data goes to memory.db
     dbPath: '.agentic-qe/memory.db',
@@ -718,6 +719,10 @@ export class SQLitePatternStore {
      * 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.
+     *
+     * #1129: measuredOutcomes and successfulOutcomes count measured runs (rows
+     * tagged outcome 'measured', grouped by runId); unmeasuredOutcomes counts
+     * every other usage row. learningOutcomes stays the total row count.
      */
     getAggregateOutcomeStats() {
         const empty = {
@@ -725,6 +730,8 @@ export class SQLitePatternStore {
             avgRoutingConfidence: 0,
             successfulRoutings: 0,
             learningOutcomes: 0,
+            measuredOutcomes: 0,
+            unmeasuredOutcomes: 0,
             successfulOutcomes: 0,
             avgPatternSuccessRate: 0,
         };
@@ -751,8 +758,13 @@ export class SQLitePatternStore {
         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
+        COALESCE(SUM(measured), 0) AS measuredRows,
+        COUNT(DISTINCT CASE WHEN measured = 1 THEN run END) AS measured,
+        COUNT(DISTINCT CASE WHEN measured = 1 AND success = 1 THEN run END) AS succ
+      FROM (
+        SELECT success, ${MEASURED_USAGE_SQL} AS measured, ${USAGE_RUN_SQL} AS run
+        FROM qe_pattern_usage
+      )
     `);
         const patternAvg = safeGet(`
       SELECT AVG(success_rate) AS avg_sr
@@ -764,6 +776,8 @@ export class SQLitePatternStore {
             avgRoutingConfidence: routing?.avg_q ?? 0,
             successfulRoutings: routing?.succ ?? 0,
             learningOutcomes: usage?.total ?? 0,
+            measuredOutcomes: usage?.measured ?? 0,
+            unmeasuredOutcomes: (usage?.total ?? 0) - (usage?.measuredRows ?? 0),
             successfulOutcomes: usage?.succ ?? 0,
             avgPatternSuccessRate: patternAvg?.avg_sr ?? 0,
         };

package/dist/learning/usage-outcome.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Agentic QE v3 - Measured outcomes for pattern usage (#1129)
+ *
+ * `qe_pattern_usage.success` used to mean "the call completed": MCP tool runs
+ * were captured with a fixed `success: true`, hooks pass a hardcoded
+ * `--success`, and session consolidation writes only aggregates whose success
+ * rate already passed a threshold. The aggregate "Pattern Success Rate" was
+ * 100% by construction.
+ *
+ * A usage row counts as a measured outcome only when it says so:
+ * `metrics_json.outcome = 'measured'`, written when success was read from the
+ * result. Today that is a test run: every test passed, or some failed.
+ * Every other row, whatever its age or writer, is unmeasured (tag and exclude,
+ * the #1109 decision): it is kept and counted as a use, never rewritten, and
+ * never part of the rate.
+ *
+ * The rate is per run, not per row: one tool run writes a row for each
+ * pattern involved (the captured experience's pattern plus every routing
+ * hint), all with the same verdict, and they share `metrics_json.runId`.
+ */
+export type UsageOutcome = 'measured' | 'unmeasured';
+/** The outcome of one tool run, as far as its result shows it. */
+export interface ToolOutcome {
+    /** True when `success` was read from the result, not from completion. */
+    readonly measured: boolean;
+    /** For a measured outcome, whether it was good; otherwise null. */
+    readonly success: boolean | null;
+    /** What the verdict was read from, e.g. `test-results`. */
+    readonly basis: string;
+}
+/**
+ * Read the outcome of a completed tool run from its result.
+ * Tools without an outcome measure here are `unmeasured`: completing is not
+ * evidence that the result was good.
+ */
+export declare function measureToolOutcome(taskType: string, data: unknown): ToolOutcome;
+/** Metrics fields that tag a usage row with its outcome provenance and run. */
+export declare function usageOutcomeMetrics(outcome: ToolOutcome, runId?: string): {
+    outcome: UsageOutcome;
+    outcomeBasis: string;
+    runId?: string;
+};
+/** Classify one qe_pattern_usage row (TypeScript twin of MEASURED_USAGE_SQL). */
+export declare function usageOutcomeOf(metrics: Record<string, unknown> | null | undefined): UsageOutcome;
+/**
+ * SQL expression over qe_pattern_usage: 1 for a measured row, 0 otherwise.
+ * Mirrors usageOutcomeOf; json_valid keeps a malformed row from failing the query.
+ */
+export declare const MEASURED_USAGE_SQL = "(CASE WHEN json_valid(metrics_json) AND json_extract(metrics_json, '$.outcome') = 'measured' THEN 1 ELSE 0 END)";
+/** SQL expression: the run a usage row belongs to (a row without runId is its own run). */
+export declare const USAGE_RUN_SQL = "COALESCE(CASE WHEN json_valid(metrics_json) THEN json_extract(metrics_json, '$.runId') END, 'row:' || id)";
+/** Fields of the reasoning-bank stats that describe usage outcomes. */
+interface OutcomeStats {
+    learningOutcomes: number;
+    measuredOutcomes?: number;
+    patternSuccessRate: number | null;
+}
+/**
+ * e.g. "9 (4 measured runs, 0 unmeasured)". A run can write several usage
+ * rows (one per pattern involved), so measured runs can be fewer than rows.
+ */
+export declare function formatLearningOutcomes(stats: OutcomeStats & {
+    unmeasuredOutcomes?: number;
+}): string;
+/** The rate as a percentage, or why there is none (#1129). */
+export declare function formatPatternSuccessRate(stats: OutcomeStats): string;
+export {};
+//# sourceMappingURL=usage-outcome.d.ts.map