agentic-qe 3.13.10 → 3.13.12

package/dist/learning/pattern-routing-guidance.d.ts

@@ -0,0 +1,16 @@
+import type { QERoutingResult } from './qe-reasoning-bank-types.js';
+import type { QEPattern } from './qe-patterns.js';
+export declare const ROUTING_PATTERN_SIMILARITY_FLOOR = 0.5;
+export declare const ROUTING_PATTERN_QUALITY_FLOOR = 0.3;
+/**
+ * Add actionable learned-pattern context to an existing routing result.
+ * This is pure composition: callers retain ownership of the initialized store.
+ */
+export interface RoutingPatternMatch {
+    pattern: QEPattern;
+    similarity: number;
+}
+export declare function enhanceRoutingWithPatterns<T extends QERoutingResult>(routingResult: T, patternResults: RoutingPatternMatch[]): T;
+/** Preserve legacy routing output unless the caller explicitly enables learned guidance. */
+export declare function maybeEnhanceRoutingWithPatterns<T extends QERoutingResult>(enabled: boolean | undefined, routingResult: T, patternResults: RoutingPatternMatch[]): T;
+//# sourceMappingURL=pattern-routing-guidance.d.ts.map

package/dist/learning/pattern-routing-guidance.js

@@ -0,0 +1,34 @@
+export const ROUTING_PATTERN_SIMILARITY_FLOOR = 0.5;
+export const ROUTING_PATTERN_QUALITY_FLOOR = 0.3;
+export function enhanceRoutingWithPatterns(routingResult, patternResults) {
+    const relevantPatterns = patternResults.filter(({ pattern, similarity }) => similarity >= ROUTING_PATTERN_SIMILARITY_FLOOR
+        && pattern.qualityScore >= ROUTING_PATTERN_QUALITY_FLOOR);
+    if (relevantPatterns.length === 0)
+        return routingResult;
+    const patternHints = relevantPatterns.map(({ pattern, similarity }) => `[Pattern: ${pattern.name}] ${pattern.description} `
+        + `(confidence: ${(pattern.confidence * 100).toFixed(0)}%, `
+        + `similarity: ${(similarity * 100).toFixed(0)}%)`);
+    const existingPatternIds = new Set(routingResult.patterns.map(({ id }) => id));
+    const additionalPatterns = relevantPatterns
+        .map(({ pattern }) => pattern)
+        .filter(({ id }) => !existingPatternIds.has(id));
+    const avgSimilarity = relevantPatterns.reduce((sum, result) => sum + result.similarity, 0)
+        / relevantPatterns.length;
+    return {
+        ...routingResult,
+        patterns: [...routingResult.patterns, ...additionalPatterns],
+        guidance: [
+            ...routingResult.guidance,
+            '--- Relevant Patterns ---',
+            ...patternHints,
+        ],
+        reasoning: `${routingResult.reasoning}; Found ${relevantPatterns.length} relevant pattern(s) `
+            + `with avg similarity ${(avgSimilarity * 100).toFixed(0)}%`,
+        confidence: Math.min(1, routingResult.confidence + relevantPatterns.length * 0.02),
+    };
+}
+/** Preserve legacy routing output unless the caller explicitly enables learned guidance. */
+export function maybeEnhanceRoutingWithPatterns(enabled, routingResult, patternResults) {
+    return enabled ? enhanceRoutingWithPatterns(routingResult, patternResults) : routingResult;
+}
+//# sourceMappingURL=pattern-routing-guidance.js.map

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

@@ -57,6 +57,8 @@ export interface QERoutingRequest {
     capabilities?: string[];
     /** Context for matching */
     context?: Partial<QEPatternContext>;
+    /** Append relevant learned patterns to guidance (opt-in for compatibility). */
+    includePatternGuidance?: boolean;
 }
 /**
  * Task routing result

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

@@ -29,6 +29,7 @@ import { AGENT_CAPABILITIES, calculateAgentScores, applyExplorationPolicy, resol
 import { resolveTopologyCriticalFromSharedMincut } from './routing-topology-gate.js';
 import { getUnifiedMemory } from '../kernel/unified-memory.js';
 import { resizeEmbedding, hashEmbedding } from './embedding-utils.js';
+import { maybeEnhanceRoutingWithPatterns } from './pattern-routing-guidance.js';
 import { checkPatternPromotionWithCoherence, promotePattern as promotePatternFn, seedCrossDomainPatterns as seedCrossDomainPatternsFn, } from './pattern-promotion.js';
 // ============================================================================
 // QEReasoningBank Implementation
@@ -494,7 +495,7 @@ export class QEReasoningBank {
                 criticality: safetyMultiplier,
                 qWeight: avgQWeight,
             };
-            return ok(result);
+            return ok(maybeEnhanceRoutingWithPatterns(request.includePatternGuidance, result, patternResults.success ? patternResults.value : []));
         }
         catch (error) {
             return err(toError(error));

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

@@ -36,6 +36,8 @@ export interface RealQERoutingRequest {
     domain?: QEDomain;
     capabilities?: string[];
     context?: Partial<QEPatternContext>;
+    /** Append relevant learned patterns to guidance (opt-in for compatibility). */
+    includePatternGuidance?: boolean;
 }
 export interface RealQERoutingResult {
     recommendedAgent: string;

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

@@ -18,6 +18,7 @@
 import { v4 as uuidv4 } from 'uuid';
 import { LoggerFactory } from '../logging/index.js';
 import { toError, toErrorMessage } from '../shared/error-utils.js';
+import { maybeEnhanceRoutingWithPatterns } from './pattern-routing-guidance.js';
 const logger = LoggerFactory.create('RealQEReasoningBank');
 import { computeRealEmbedding, isTransformerAvailable, getEmbeddingDimension, clearEmbeddingCache, } from './real-embeddings.js';
 import { createSQLitePatternStore, } from './sqlite-persistence.js';
@@ -507,7 +508,7 @@ export class RealQEReasoningBank {
             this.stats.totalRoutingLatency += latencyMs;
             // CircularBuffer handles bounded size automatically - O(1) operation
             this.routingLatencies.push(latencyMs);
-            return ok({
+            const result = {
                 recommendedAgent: recommended.agent,
                 confidence: recommended.score,
                 alternatives: alternatives.map(a => ({ agent: a.agent, score: a.score })),
@@ -516,7 +517,8 @@ export class RealQEReasoningBank {
                 guidance,
                 reasoning: recommended.reasoning.join('; '),
                 latencyMs,
-            });
+            };
+            return ok(maybeEnhanceRoutingWithPatterns(request.includePatternGuidance, result, searchResult.success ? searchResult.value : []));
         }
         catch (error) {
             return err(toError(error));

package/dist/learning/token-tracker.js

@@ -11,7 +11,7 @@
  *
  * @example
  * ```typescript
- * import { TokenMetricsCollector } from './token-tracker';
+ * import { TokenMetricsCollector } from './token-tracker.js';
  *
  * // Record token usage for a task
  * TokenMetricsCollector.recordTokenUsage('task-123', 'agent-1', 'test-generation', 'generate', {

package/dist/logging/index.js

@@ -7,7 +7,7 @@
  *
  * Usage:
  * ```typescript
- * import { LoggerFactory, LogLevel } from '../logging';
+ * import { LoggerFactory, LogLevel } from '../logging/index.js';
  *
  * // Configure (typically at application startup)
  * LoggerFactory.setLevel(LogLevel.DEBUG);

package/dist/logging/logger-factory.js

@@ -21,7 +21,7 @@ const DEFAULT_FACTORY_CONFIG = {
  *
  * Usage:
  * ```typescript
- * import { LoggerFactory } from '../logging';
+ * import { LoggerFactory } from '../logging/index.js';
  *
  * // Set global log level
  * LoggerFactory.setLevel(LogLevel.DEBUG);